From 99871c5bef05829aa5f187fd105050591abab03d Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 13:31:58 -0400
Subject: [PATCH 001/101] cwNbMpScQueue.h/cpp : 1. Added peek(). 2. blockL is
 now made from individual allocated blocks to ease memory alignment. 3. node_t
 and blob length is now padded out to a multiple of 8 bytes to guarantee
 memory alignment. 4. advance() now returns the next blob.

---
 cwNbMpScQueue.cpp | 152 ++++++++++++++++++++++++++++++++++++----------
 cwNbMpScQueue.h   |  20 ++++--
 2 files changed, 136 insertions(+), 36 deletions(-)

diff --git a/cwNbMpScQueue.cpp b/cwNbMpScQueue.cpp
index 6708965..2940b8f 100644
--- a/cwNbMpScQueue.cpp
+++ b/cwNbMpScQueue.cpp
@@ -30,12 +30,15 @@ namespace cw
 
     typedef struct node_str
     {
-      std::atomic<struct node_str*> next;
-      block_t*                      block;
-      unsigned                      blobByteN;
+      std::atomic<struct node_str*> next;       // 0
+      block_t*                      block;      // 8
+      unsigned                      blobByteN;  // 16
+      unsigned                      pad;        // 20-24 (mult. of 8)
       // blob data follows
     } node_t;
 
+    static_assert( sizeof(node_t) % 8 == 0 );
+    
     typedef struct nbmpscq_str
     {
       uint8_t* mem;       // Pointer to a single area of memory which holds all blocks.
@@ -51,6 +54,8 @@ namespace cw
       std::atomic<node_t*> head; // last-in
       
       node_t*              tail; // first-out
+
+      node_t*              peek;
       
     } nbmpscq_t;
 
@@ -62,8 +67,18 @@ namespace cw
       rc_t rc = kOkRC;
       if( p != nullptr )
       {
+
+        block_t* b = p->blockL;
+        while( b != nullptr )
+        {
+          block_t* b0 = b->link;
+          mem::release(b->buf);
+          mem::release(b);
+          b=b0;
+        }
+        
+        
         mem::release(p->stub);
-        mem::release(p->mem);
         mem::release(p);
       }
       return rc;
@@ -98,6 +113,22 @@ namespace cw
       p->cleanProcN += 1;
     }
 
+    void _init_blob( blob_t& b, node_t* node )
+    {
+      if( node == nullptr )
+      {
+        b.blob      = nullptr;
+        b.blobByteN = 0;
+      }
+      else
+      {
+        b.blob      = (uint8_t*)(node+1);
+        b.blobByteN = node->blobByteN;
+      }
+
+      b.rc = kOkRC;
+      
+    }
 
     typedef struct shared_str
     {
@@ -142,7 +173,6 @@ cw::rc_t cw::nbmpscq::create( handle_t& hRef, unsigned initBlkN, unsigned blkByt
 {
   rc_t       rc    = kOkRC;
   nbmpscq_t* p     = nullptr;
-  unsigned   byteN = 0;
   
   if((rc = destroy(hRef)) != kOkRC )
     goto errLabel;
@@ -151,11 +181,31 @@ cw::rc_t cw::nbmpscq::create( handle_t& hRef, unsigned initBlkN, unsigned blkByt
   
   p->stub = mem::allocZ<node_t>();
   p->head = p->stub;   // last-in
-  p->tail = p->stub;   // first-out 
+  p->tail = p->stub;   // first-out
+  p->peek = nullptr;
   p->cleanBlkN = 0;
   
   p->blkN     = initBlkN;
   p->blkByteN = blkByteN;
+
+  for(unsigned i=0; i<initBlkN; ++i)
+  {
+    block_t* b = mem::allocZ<block_t>();
+    b->buf = mem::allocZ<uint8_t>(blkByteN);
+
+    b->bufByteN = blkByteN;
+    
+    b->full_flag.store(false);
+    b->index.store(0);
+    b->eleN.store(0);
+    
+    b->link = p->blockL;
+    p->blockL = b;
+    
+  }
+
+
+  /*
   byteN       = initBlkN * (sizeof(block_t) + blkByteN );
   p->mem      = mem::allocZ<uint8_t>(byteN);
   
@@ -172,7 +222,8 @@ cw::rc_t cw::nbmpscq::create( handle_t& hRef, unsigned initBlkN, unsigned blkByt
     b->link = p->blockL;
     p->blockL = b;
   }
-
+  */
+  
   hRef.set(p);
   
 errLabel:
@@ -215,6 +266,15 @@ cw::rc_t cw::nbmpscq::push( handle_t h, const void* blob, unsigned blobByteN )
   // Note that this case will immediately overflow the queue.
 
   unsigned nodeByteN = blobByteN + sizeof(node_t);
+
+  // force the size of the node to be a multiple of 8
+  nodeByteN = ((nodeByteN-1) & 0xfffffff8) + 8;
+
+  // We will eventually be addressing node_t records stored in pre-allocated blocks
+  // of memory - be sure that they always begin on 8 byte alignment to conform
+  // to Intel standard.
+  assert( nodeByteN % 8 == 0 );
+
   
   for(; b!=nullptr; b=b->link)
   {
@@ -274,33 +334,22 @@ cw::rc_t cw::nbmpscq::push( handle_t h, const void* blob, unsigned blobByteN )
 
 cw::nbmpscq::blob_t  cw::nbmpscq::get( handle_t h )
 {
-  blob_t blob;
-  nbmpscq_t* p = _handleToPtr(h);
-  
-  node_t* t    = p->tail;
-  node_t* n    = t->next.load(std::memory_order_acquire);  //  ACQUIRE 'next' from producer
-  
-  if( n == nullptr )
-  {
-    blob.blob      = nullptr;
-    blob.blobByteN = 0;
-  }
-  else
-  {
-    blob.blob      = (uint8_t*)(n+1);
-    blob.blobByteN = n->blobByteN;
-  }
-  
-  return blob;
+  blob_t     blob;
+  nbmpscq_t* p    = _handleToPtr(h);  
+  node_t*    t    = p->tail;
+  node_t*    node = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
+
+  _init_blob( blob, node );
   
+  return blob;  
 }
 
-cw::rc_t cw::nbmpscq::advance( handle_t h )
-{  
-  nbmpscq_t* p = _handleToPtr(h);
-  rc_t    rc   = kOkRC;
-  node_t* t    = p->tail;
-  node_t* next = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
+cw::nbmpscq::blob_t cw::nbmpscq::advance( handle_t h )
+{
+  blob_t     blob;  
+  nbmpscq_t* p    = _handleToPtr(h);
+  node_t*    t    = p->tail;
+  node_t*    next = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
   
   if( next != nullptr )
   {    
@@ -317,7 +366,46 @@ cw::rc_t cw::nbmpscq::advance( handle_t h )
   if( p->cleanBlkN.load(std::memory_order_relaxed) > 0 )
     _clean(p);
 
-  return rc;
+
+  _init_blob(blob,next);
+  
+  return blob;
+}
+
+
+cw::nbmpscq::blob_t cw::nbmpscq::peek( handle_t h )
+{
+  blob_t blob;
+  nbmpscq_t* p = _handleToPtr(h);
+  node_t*    n = p->peek;
+
+  // if p->peek is not set ... 
+  if( n == nullptr )
+  {
+    // ... then set it to the tail
+    n = p->tail->next.load(std::memory_order_acquire);  //  ACQUIRE 'next' from producer
+
+  }
+
+  _init_blob(blob,n);
+
+  if( n != nullptr )
+    p->peek = n->next.load(std::memory_order_acquire);
+  
+  return blob;
+  
+}
+
+
+
+bool cw::nbmpscq::is_empty( handle_t h )
+{
+  nbmpscq_t* p = _handleToPtr(h);
+  
+  node_t* t    = p->tail;
+  node_t* next = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
+
+  return next == nullptr;
 }
 
 cw::rc_t cw::nbmpscq::test( const object_t* cfg )
diff --git a/cwNbMpScQueue.h b/cwNbMpScQueue.h
index 2e775da..ac3dbf2 100644
--- a/cwNbMpScQueue.h
+++ b/cwNbMpScQueue.h
@@ -34,7 +34,7 @@ namespace cw
   namespace nbmpscq
   {
     typedef handle<struct nbmpscq_str> handle_t;
-
+    
     rc_t create( handle_t& hRef, unsigned initBlkN, unsigned blkByteN );
     
     rc_t destroy( handle_t& hRef );
@@ -46,18 +46,30 @@ namespace cw
 
     typedef struct blob_str
     {
+      rc_t rc;
       const void* blob;
       unsigned blobByteN;
     } blob_t;
 
     // get() is called by the single consumer thread to access the
-    // current blob at the front of the queue.  Note that this call
+    // oldest record in the queue.  Note that this call
     // does not change the state of the queue.
     blob_t  get( handle_t h );
 
-    // advance() disposes of the blob at the front of the
+    // advance() disposes of the oldest blob in the
     // queue and makes the next blob current.
-    rc_t advance( handle_t h );
+    blob_t advance( handle_t h );
+
+    // The queue maintains a single internal iterator which the consumer
+    // may use to traverse stored records without removing them.
+    // The first call to peek() will return the oldest stored record.
+    // Each subsequent call to peek() will return the next stored record
+    // until no records are available - at which point blob_t.blob will be
+    // set to 'nullptr'. The following call will then revert to returning
+    // the oldest stored record.
+    blob_t peek( handle_t h );
+    
+    bool is_empty( handle_t h );
 
     rc_t test( const object_t* cfg );
     

From 693c87d5981b4f7e8f69c76753772426d8d4f0b5 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 13:32:46 -0400
Subject: [PATCH 002/101] cwWebSock.cpp : Now uses cwNbMpScQueue to cache
 outgoing messages.

---
 cwWebSock.cpp | 238 ++++++++++++++++++++++++++++++--------------------
 1 file changed, 141 insertions(+), 97 deletions(-)

diff --git a/cwWebSock.cpp b/cwWebSock.cpp
index 3d4bdfc..156dfca 100644
--- a/cwWebSock.cpp
+++ b/cwWebSock.cpp
@@ -1,13 +1,16 @@
+
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
 #include "cwMem.h"
 #include "cwFileSys.h"
+#include "cwObject.h"
 #include "cwWebSock.h"
-#include "cwMpScNbQueue.h"
+#include "cwNbMpScQueue.h"
 #include "cwTime.h"
 
 #include <libwebsockets.h>
+#include <memory>
 
 namespace cw
 {
@@ -31,15 +34,18 @@ namespace cw
     // Internal outgoing msg structure.
     typedef struct msg_str
     {
-      unsigned        protocolId; // Protocol associated with this msg.
-      unsigned        sessionId;  // Session Id that this msg should be sent to or kInvalidId if it should be sent to all sessions.
-      unsigned char*  msg;        // Msg data array.
-      unsigned        msgByteN;   // Count of bytes in msg[].
-      unsigned        msgId;      // The msgId assigned when this msg is addded to the protocol state msg queue.
-      unsigned        sessionN;   // Count of sessions to which this msg has been sent.
-      struct msg_str* link;       // Pointer to next message or nullptr if this is the last msg in the queue.
+      unsigned        protocolId; //  0 Protocol associated with this msg.
+      unsigned        sessionId;  //  4 Session Id that this msg should be sent to or kInvalidId if it should be sent to all sessions.
+      unsigned char*  msg;        //  8 Msg data array.
+      unsigned        msgByteN;   // 16 Count of bytes in msg[].
+      unsigned        msgId;      // 20 The msgId assigned when this msg is addded to the protocol state msg queue.
+      unsigned        sessionN;   // 24 Count of sessions to which this msg has been sent.
+      struct msg_str* link;       // 28 Pointer to next message or nullptr if this is the last msg in the queue.
+      unsigned        pad;        // 36-40 (make size of msg_t a multiple of 8)
     } msg_t;
 
+    static_assert( sizeof(msg_t) % 8 == 0 ); 
+
     typedef struct websock_str
     {
       cbFunc_t               _cbFunc;                  //
@@ -50,7 +56,7 @@ namespace cw
       unsigned               _nextSessionId = 0;       // Next session id.
       unsigned               _connSessionN  = 0;       // Count of connected sessions.
       struct lws_http_mount* _mount         = nullptr; //
-      MpScNbQueue<msg_t>*    _q; // Thread safe, non-blocking, protocol independent msg queue.
+      nbmpscq::handle_t      _qH; // Thread safe, non-blocking, protocol independent msg queue.
 
       lws_pollfd* _pollfdA;     // socket handle array used by poll()
       int         _pollfdMaxN;
@@ -184,14 +190,13 @@ namespace cw
 
         case LWS_CALLBACK_SERVER_WRITEABLE:
           {
-            msg_t* m1 = protoState->endMsg;
-            cwAssert(m1 != nullptr);
+            msg_t* m = protoState->endMsg;
 
-            // for each possible msg
-            while( m1->link != nullptr )
+            // for each possible outgoing msg in this protocol state record
+            while( m != nullptr )
             {
-              msg_t* m = m1->link;
-          
+              bool msg_written_fl = false;
+              
               // if this msg has not already been sent to this session
               if( m->msgId >= sess->nextMsgId )
               {
@@ -199,7 +204,8 @@ namespace cw
                 // if the msg sessiond id is not valid or matches this session id ...
                 if( m->sessionId == kInvalidId || m->sessionId == sess->id )
                 {
-                  // ... then send the msg to  this session            
+                  // ... then send the msg to  this session
+                  
                   // Note: msgByteN should not include LWS_PRE
                   int lws_result = lws_write(wsi, m->msg + LWS_PRE , m->msgByteN, LWS_WRITE_TEXT);
             
@@ -209,17 +215,25 @@ namespace cw
                     cwLogError(kWriteFailRC,"Websocket error: %d on write", lws_result);
                     return -1;
                   }
+
+                  msg_written_fl = true;
                 }
               
                 // at this point the write  succeeded or this session was skipped
                 sess->nextMsgId  = m->msgId + 1;
-                m->sessionN     += 1;
-                            
-                break;
+
+                // incr the msg session count - once m->sessionN >= protoState->sessionN this msg will be deleted in _cleanProtocoStateList()
+                m->sessionN     += 1;  
+
+                // If a record was actually sent then we are done since only one
+                // call to lws_write() per LWS_CALLBACK_SERVER_WRITEABLE callback
+                // is permitted
+                if(msg_written_fl)
+                  break;   
               }
           
 
-              m1 = m1->link;
+              m = m->link;
             }
 
           }
@@ -255,40 +269,41 @@ namespace cw
       return nullptr;
     }
 
-  
-    void _cleanProtocolStateList( protocolState_t* ps )
+    // Remove message from the send queue (p->_qH), and the protocol msg list,
+    //  which have already been sent to all relevant sessions.
+    rc_t _cleanProtocolStateList( websock_t* p, protocolState_t* ps )
     {
-      msg_t* m0 = nullptr;
-      msg_t* m1 = ps->endMsg;
+      rc_t rc  = kOkRC;
+      nbmpscq::blob_t b = get(p->_qH);
 
-      while( m1->link != nullptr )
+      msg_t* oldest_msg = (msg_t*)b.blob;
+
+      // if the last protocol end msg has been sent to all sessions ...
+      while( oldest_msg != nullptr && ps->endMsg != nullptr && ps->endMsg->sessionN >= ps->sessionN )
       {
-        if( m1->link->sessionN >= ps->sessionN )
+        // ... and this msg is also the oldest msg in the send queue
+        if( oldest_msg->msgId == ps->endMsg->msgId )
         {
-          if( m0 == nullptr )
-            ps->endMsg = m1->link;
-          else
-            m0->link   = m1->link;
-
-          msg_t* t = m1->link;
-      
-          //mem::free(m1->msg);
-          mem::free(m1);
-
-          m1 = t;
-
-          continue;
+          ps->endMsg = ps->endMsg->link;
+          b = advance(p->_qH);  // ... then pop the msg off the send queue
+          oldest_msg = (msg_t*)b.blob;
+        }
+        else // ... otherwise the no further progress can be made
+        {
+          break;
         }
-    
-        m0 = m1;
-        m1 = m1->link;
       }
+
+      if( ps->endMsg == nullptr )
+        ps->begMsg = nullptr;
+
+      return rc;
     }
   
-  
     rc_t _destroy( websock_t* p )
     {
-      msg_t* m;
+      rc_t rc = kOkRC;
+      //msg_t* m;
 
       cwLogInfo("Websock: sent: msgs:%i largest msg:%i - recv: msgs:%i largest msg:%i - LWS_PRE:%i",p->_sendMsgCnt,p->_sendMaxByteN,p->_recvMsgCnt,p->_recvMaxByteN,LWS_PRE);
       cwLogInfo("Exec Time: %i avg ms, %i total ms, %i cnt", p->_execN==0 ? 0 : p->_execSumMs/p->_execN, p->_execSumMs, p->_execN );
@@ -298,39 +313,20 @@ namespace cw
         lws_context_destroy(p->_ctx);
         p->_ctx = nullptr;
       }
-
-      if( p->_q != nullptr )
-      {
       
-        while((m = p->_q->pop()) != nullptr)
-        {
-          //mem::free(m->msg);
-          mem::free(m);
-        }
-      
-        delete p->_q;
-      }
-    
       for(int i=0; p->_protocolA!=nullptr and p->_protocolA[i].callback != nullptr; ++i)
       {
         mem::free(const_cast<char*>(p->_protocolA[i].name));
     
         // TODO: delete any msgs in the protocol state here
         auto ps = static_cast<protocolState_t*>(p->_protocolA[i].user);
-    
-        m = ps->endMsg;
-        while( m != nullptr )
-        {
-          msg_t* tmp = m->link;
-      
-          //mem::free(m->msg);
-          mem::free(m);
-          m = tmp;
-        }
-    
+
         mem::free(ps); 
       }
-  
+
+      if((rc = nbmpscq::destroy(p->_qH)) != kOkRC )
+        cwLogError(rc,"Websock queue destroy failed.");
+      
       mem::release(p->_protocolA);
       p->_protocolN = 0;
 
@@ -573,11 +569,11 @@ cw::rc_t cw::websock::create(
   {
     // Allocate the application protocol state array where this application can keep protocol related info
     auto protocolState = mem::allocZ<protocolState_t>(1);
-    auto dummy         = mem::allocZ<msg_t>(1);
+    //auto dummy         = mem::allocZ<msg_t>(1);
     
     protocolState->thisPtr = p;
-    protocolState->begMsg  = dummy;
-    protocolState->endMsg  = dummy;
+    protocolState->begMsg  = nullptr;
+    protocolState->endMsg  = nullptr;
     
     // Setup the interal lws_protocols record 
     struct lws_protocols* pr  = p->_protocolA + i;
@@ -607,7 +603,12 @@ cw::rc_t cw::websock::create(
 	foreign_loops[0] = p;                  // pass in the custom poll object as the foreign loop object we will bind to
 	info.foreign_loops = foreign_loops;
 
-  p->_q = new MpScNbQueue<msg_t>();
+  if((rc = nbmpscq::create(p->_qH,3,4*4096)) != kOkRC )
+  {
+    rc = cwLogError(rc,"Websock queue create failed.");
+    goto errLabel;
+  }
+  
   p->_cbFunc = cbFunc;
   p->_cbArg  = cbArg;
 
@@ -651,23 +652,33 @@ cw::rc_t cw::websock::destroy( handle_t& h )
 cw::rc_t cw::websock::send(handle_t h,  unsigned protocolId, unsigned sessionId, const void* msg, unsigned byteN )
 {
   rc_t rc = kOkRC;
-
-  uint8_t* mem = mem::allocZ<uint8_t>( sizeof(msg_t) + LWS_PRE + byteN  );
-
-  msg_t* m = (msg_t*)mem;
-  m->msg = mem + sizeof(msg_t);
-  
-  memcpy(m->msg+LWS_PRE,msg,byteN);
-  m->msgByteN   = byteN;
-  m->protocolId = protocolId;
-  m->sessionId = sessionId;
-
   websock_t* p = _handleToPtr(h);
-  p->_q->push(m);
+
+  unsigned dataByteN = sizeof(msg_t) + LWS_PRE + byteN;
+  uint8_t mem[ dataByteN ];
+  msg_t* m = (msg_t*)mem;
+  
+  memcpy(mem + sizeof(msg_t) + LWS_PRE,msg,byteN);
+  m->protocolId = protocolId;
+  m->sessionId  = sessionId;
+  m->msg        = nullptr;
+  m->msgByteN   = byteN;     // length of msg w/o LWS_PRE
+  m->msgId      = kInvalidId;
+  m->sessionN   = 0;
+  m->link       = nullptr;
+    
+
+  // put the outgoing msgs on the queue 
+  if((rc = nbmpscq::push(p->_qH,mem,dataByteN)) != kOkRC )
+  {
+    rc = cwLogError(rc,"Websock queue push failed.");
+    goto errLabel;
+  }
 
   p->_sendMsgCnt += 1;
   p->_sendMaxByteN = std::max(p->_sendMaxByteN,byteN);
   
+errLabel:
   return rc;
 }
 
@@ -704,28 +715,61 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
 
   time::spec_t t0 = time::current_time();
 
-  // service any pending websocket activity - with no-timeout
+  // service any pending websocket activity - with no timeout
   lws_service_tsi(p->_ctx, -1, 0 );
 
-  msg_t* m; 
-  
-  // Get the next pending outgoing message.
-  while((m = p->_q->pop()) != nullptr )
+  // clean already sent messages from each protocol outgoing msg list
+  for(unsigned i=0; i<p->_protocolN-1; ++i)
   {
-    auto protocol = _idToProtocol(p,m->protocolId);
+    protocolState_t* ps = static_cast<protocolState_t*>(p->_protocolA[i].user);
+    _cleanProtocolStateList( p, ps );
+  }
 
-    // Get the application protcol record for this message
+  // Get the next pending outgoing message.
+  while(1)
+  {
+    nbmpscq::blob_t b = nbmpscq::peek(p->_qH);
+
+    // if the outgoing queue is empty
+    if( b.blob == nullptr )
+      break;
+    
+    msg_t* m = (msg_t*)b.blob;
+
+    // if msg data ptr is not null then this msg has been seen in an earlier call to this function.
+    if( m->msg != nullptr )
+      break;
+    
+    m->msg = (unsigned char*)(m+1); 
+
+    // Get the protocol record for this msg.
+    struct lws_protocols* protocol = _idToProtocol(p,m->protocolId);
+
+    // Get the application protcol state record from the protocol 'user' field 
     protocolState_t* ps = static_cast<protocolState_t*>(protocol->user);
 
     // remove messages from the protocol message queue which have already been sent
-    _cleanProtocolStateList( ps );
-    
+    //_cleanProtocolStateList( p, ps );
+
+    // Put the msg in the front of the protocal state list (msg's are removed from the back of the list)
     m->msgId          = ps->nextNewMsgId;  // set the msg id
-    ps->begMsg->link  = m;                 // put the msg on the front of the outgoing  queue
-    ps->begMsg        = m;                 // 
+    m->link           = nullptr;
     ps->nextNewMsgId += 1;
-        
-    lws_callback_on_writable_all_protocol(p->_ctx,protocol);
+
+    if( ps->begMsg == nullptr )
+    {
+      ps->begMsg = m;
+      ps->endMsg = m;
+    }
+    else
+    {
+      ps->begMsg->link = m;
+      ps->begMsg       = m;
+    }
+
+    // we want one callback for each session
+    for(unsigned i=0; i<ps->sessionN; ++i)
+      lws_callback_on_writable_all_protocol(p->_ctx,protocol);
 
     lws_service_tsi(p->_ctx, -1, 0 );
   }

From c9281603de4b1516dea0bea8593856d4f731aa79 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 14:29:25 -0400
Subject: [PATCH 003/101] cwNbMpScQueue.h/cpp: Added count().

---
 cwNbMpScQueue.cpp | 12 ++++++++++++
 cwNbMpScQueue.h   |  2 ++
 2 files changed, 14 insertions(+)

diff --git a/cwNbMpScQueue.cpp b/cwNbMpScQueue.cpp
index 2940b8f..70fbb1d 100644
--- a/cwNbMpScQueue.cpp
+++ b/cwNbMpScQueue.cpp
@@ -408,6 +408,18 @@ bool cw::nbmpscq::is_empty( handle_t h )
   return next == nullptr;
 }
 
+unsigned cw::nbmpscq::count( handle_t h )
+{
+  nbmpscq_t* p = _handleToPtr(h);
+
+  block_t* b = p->blockL;
+  int eleN = 0;
+  for(; b!=nullptr; b=b->link)
+    eleN += b->eleN.load(std::memory_order_acquire);
+
+  return eleN;
+}
+
 cw::rc_t cw::nbmpscq::test( const object_t* cfg )
 {
   rc_t rc=kOkRC,rc0,rc1;
diff --git a/cwNbMpScQueue.h b/cwNbMpScQueue.h
index ac3dbf2..fe6c13e 100644
--- a/cwNbMpScQueue.h
+++ b/cwNbMpScQueue.h
@@ -71,6 +71,8 @@ namespace cw
     
     bool is_empty( handle_t h );
 
+    unsigned count( handle_t h );
+
     rc_t test( const object_t* cfg );
     
   }

From 55aed815e199123295138aec51c949fea9826559 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 14:29:58 -0400
Subject: [PATCH 004/101] cwUi.h/cpp : Added ui::ws::realTimeReport().

---
 cwUi.cpp | 8 ++++++++
 cwUi.h   | 3 +++
 2 files changed, 11 insertions(+)

diff --git a/cwUi.cpp b/cwUi.cpp
index 5792db7..62427c4 100644
--- a/cwUi.cpp
+++ b/cwUi.cpp
@@ -2210,6 +2210,7 @@ void cw::ui::realTimeReport( handle_t h )
 {
   ui_t* p  = _handleToPtr(h);
   printf("UI msg count: recv:%i send:%i\n",p->recvMsgN,p->sentMsgN);
+  
 }
 
 
@@ -2498,6 +2499,12 @@ cw::ui::handle_t cw::ui::ws::uiHandle( handle_t h )
   return p->uiH;
 }
 
+void cw::ui::ws::realTimeReport( handle_t h )
+{
+  ui_ws_t* p  = _handleToPtr(h);
+  report(p->wsH);
+  realTimeReport(p->uiH);  
+}
 
  
 namespace cw
@@ -2668,3 +2675,4 @@ cw::ui::handle_t      cw::ui::srv::uiHandle( handle_t h )
   ui_ws_srv_t* p = _handleToPtr(h);
   return ws::uiHandle(p->wsUiH);
 }
+
diff --git a/cwUi.h b/cwUi.h
index 7bbf535..e4077e4 100644
--- a/cwUi.h
+++ b/cwUi.h
@@ -236,6 +236,9 @@ namespace cw
       
       websock::handle_t websockHandle( handle_t h );
       ui::handle_t      uiHandle( handle_t h );
+
+      void realTimeReport( handle_t h );
+      
     }
 
     namespace srv

From 230f3841d750edbbbc2382a3512c1414ce26d30f Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 14:30:47 -0400
Subject: [PATCH 005/101] cwIo.cpp: Added call to uiRealTimeReport() in call to
 io::realTimeReport().

---
 cwIo.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cwIo.cpp b/cwIo.cpp
index 9d23d5d..bb5fae2 100644
--- a/cwIo.cpp
+++ b/cwIo.cpp
@@ -2497,7 +2497,7 @@ void cw::io::realTimeReport( handle_t h )
 {
   io_t* p = _handleToPtr(h);
   audio::device::realTimeReport(p->audioH);
-
+  uiRealTimeReport(h);
 }
 
 
@@ -3957,8 +3957,8 @@ void cw::io::uiReport( handle_t h )
 
 void cw::io::uiRealTimeReport( handle_t h )
 {
-  ui::handle_t uiH;
-  if(_handleToUiHandle(h,uiH) == kOkRC )
-    ui::realTimeReport(uiH);
+  ui::ws::handle_t uiH;
+  if(_handleToWsUiHandle(h,uiH) == kOkRC )
+    ui::ws::realTimeReport(uiH);
 }
 

From 488648a9675281d4860fa6349b828303e33da34d Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 14:31:03 -0400
Subject: [PATCH 006/101] cwWebSock.cpp : Added report().

---
 cwWebSock.cpp | 6 ++++++
 cwWebSock.h   | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/cwWebSock.cpp b/cwWebSock.cpp
index 156dfca..4d5650d 100644
--- a/cwWebSock.cpp
+++ b/cwWebSock.cpp
@@ -783,3 +783,9 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
   
   return rc;
 }
+
+void cw::websock::report( handle_t h )
+{
+  websock_t* p  = _handleToPtr(h);
+  printf("Websock: msgs sent:%i recvd:%i que count:%i\n",p->_sendMsgCnt,p->_recvMsgCnt,count(p->_qH));
+}
diff --git a/cwWebSock.h b/cwWebSock.h
index e87fb04..de6dece 100644
--- a/cwWebSock.h
+++ b/cwWebSock.h
@@ -56,6 +56,8 @@ namespace cw
 
     // Call periodically from the same thread to send/recv messages.
     rc_t exec( handle_t h, unsigned timeOutMs );
+
+    void report( handle_t h );
     
   }  
 

From 43c5be958a957c7041e6a28593d21bac3ec8796b Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 22:14:42 -0400
Subject: [PATCH 007/101] cwFileSys.cpp : Fixed failure to free expanded path
 on path not existing in isFile(),isDir(),isLink().

---
 cwFileSys.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cwFileSys.cpp b/cwFileSys.cpp
index 32264cc..6661082 100644
--- a/cwFileSys.cpp
+++ b/cwFileSys.cpp
@@ -75,7 +75,7 @@ bool cw::filesys::isDir( const char* dir0 )
   {
     // if the dir does not exist
     if( errno == ENOENT )
-      return false;
+      goto errLabel;
 
     cwLogSysError( kOpFailRC, errno, "'stat' failed on '%s'",cwStringNullGuard(dir));
     goto errLabel;
@@ -106,7 +106,7 @@ bool cw::filesys::isFile( const char* fn0 )
 
     // if the file does not exist
     if( errno == ENOENT )
-      return false;
+      goto errLabel;
 
     cwLogSysError( kOpFailRC, errno, "'stat' failed on '%s'.",cwStringNullGuard(fn));
     goto errLabel;
@@ -137,7 +137,7 @@ bool cw::filesys::isLink( const char* fn0 )
   {
     // if the file does not exist
     if( errno == ENOENT )
-      return false;
+      goto errLabel;
 
     cwLogSysError( kOpFailRC, errno, "'stat' failed on '%s'.",cwStringNullGuard(fn));
     goto errLabel;

From 89a4b83c455a315795f5fa7ecb2e6c780e379167 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 25 Mar 2024 22:17:40 -0400
Subject: [PATCH 008/101] cwUi.cpp : 1. Add one to hashA[] to prevent a hash
 index of 0xffff from going past the end of the array. 2. Fix bug where hash
 table buckets were not released.

---
 cwUi.cpp | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/cwUi.cpp b/cwUi.cpp
index a744f31..3ba352f 100644
--- a/cwUi.cpp
+++ b/cwUi.cpp
@@ -117,7 +117,7 @@ namespace cw
       unsigned sentMsgN;
       unsigned recvMsgN;
 
-      bucket_t hashA[ hashN ];
+      bucket_t hashA[ hashN+1 ]; 
 
     } ui_t;
 
@@ -129,7 +129,11 @@ namespace cw
       assert( parentUuId != kInvalidId && appId != kInvalidId );
       unsigned hc = parentUuId + cwSwap32(appId);
       
-      return (unsigned short)(((hc & 0xffff0000)>>16) + (hc & 0x0000ffff));
+      unsigned short hash_idx = (unsigned short)(((hc & 0xffff0000)>>16) + (hc & 0x0000ffff));
+
+      assert( hash_idx <= hashN );
+      
+      return hash_idx;
     }
     
 
@@ -225,6 +229,18 @@ namespace cw
         m = m0;
       }
 
+      // Note: hashA[] has hashN+1 elements
+      for(unsigned i=0; i<=hashN; ++i)
+      {
+        bucket_t* b = p->hashA[i].link;
+        while( b!=nullptr )
+        {
+          bucket_t* b0 = b->link;
+          mem::release(b);
+          b = b0;
+        }
+      }
+
       mem::release(p->sessA);
       mem::release(p->eleA);
       mem::release(p->buf);

From 73b433feae89c6d420583202c9951613808b65de Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 27 Mar 2024 20:19:06 -0400
Subject: [PATCH 009/101] cwPresetSel.cpp : Fix problem where there were two
 version of delete_fragment() - one of which allowed a memory leak.

---
 cwPresetSel.cpp | 99 ++++++++++++++++++++++---------------------------
 1 file changed, 45 insertions(+), 54 deletions(-)

diff --git a/cwPresetSel.cpp b/cwPresetSel.cpp
index 0324269..0f3a420 100644
--- a/cwPresetSel.cpp
+++ b/cwPresetSel.cpp
@@ -102,38 +102,52 @@ namespace cw
       return kInvalidIdx;
     }
 
-    
-    rc_t _delete_fragment( preset_sel_t*  p, unsigned fragId )
-    {
-      frag_t*       f0 = nullptr;
-      frag_t*       f1 = p->fragL;
-  
-      for(; f1!=nullptr; f1=f1->link)
-      {
-        if( f1->fragId == fragId )
-        {
-          if( f0 == nullptr )
-            p->fragL = f1->link;
-          else
-            f0->link = f1->link;
 
-          for(unsigned i=0; i<f1->presetN; ++i)
-            mem::release(f1->presetA[i].alt_str);
+    rc_t _delete_fragment( preset_sel_t* p, unsigned fragId )
+    {
+      rc_t    rc = kOkRC;
+      frag_t* f = p->fragL;
+  
+      for(; f!=nullptr; f=f->link)
+      {
+        if( f->fragId == fragId )
+        {
+          // if this is the first frag in the list
+          if( f->prev == nullptr )
+            p->fragL = f->link;
+          else
+          {
+
+            // link the prev fragment to the next fragment
+            f->prev->link = f->link;
+
+            // dur of prev frag now include the dur of the deleted frag
+            f->prev->endLoc = f->endLoc; 
+          }
+
+          // link the next fragment back to the previous fragment
+          if( f->link != nullptr )
+            f->link->prev = f->prev;
+
+          for(unsigned i=0; i<f->presetN; ++i)
+            mem::release(f->presetA[i].alt_str);
 
           // release the fragment
-          mem::release(f1->note);
-          mem::release(f1->presetA);
-          mem::release(f1);
-      
-          return kOkRC;
+          mem::release(f->note);
+          mem::release(f->presetA);
+          mem::release(f->altPresetIdxA);
+          mem::release(f->multiPresetA);
+          mem::release(f);
+          goto errLabel;
         }
-    
-        f0 = f1;
       }
-  
-      return kOkRC;
-    }
 
+      rc = cwLogError(kEleNotFoundRC,"The fragment with id %i was not found.",fragId);
+
+    errLabel:
+      return rc;
+    }
+    
     void _destroy_all_frags( preset_sel_t* p )
     {
       while( p->fragL != nullptr)
@@ -242,7 +256,7 @@ namespace cw
       else
       {
         unsigned alt_strN           = textLength(alt_str);
-        char alt_str_buf[ alt_strN+1  ] = {0};
+        char alt_str_buf[ alt_strN+1  ];
         unsigned asi                = 0;
           
         // clear the alt's pointing to the selected preset - because the 'alt_str' has changed
@@ -257,6 +271,9 @@ namespace cw
             assert( asi < alt_strN );
             alt_str_buf[ asi++ ] = alt_str[i];
           } 
+
+        assert( asi <= alt_strN );
+        alt_str_buf[asi] = 0;
         
         // store the preset's new alt str.
         f->presetA[ sel_preset_idx ].alt_str = mem::reallocStr(f->presetA[ sel_preset_idx ].alt_str, alt_str_buf);
@@ -1145,33 +1162,7 @@ cw::rc_t cw::preset_sel::create_fragment( handle_t h, unsigned end_loc, time::sp
 cw::rc_t cw::preset_sel::delete_fragment( handle_t h, unsigned fragId )
 {
   preset_sel_t* p  = _handleToPtr(h);
-  frag_t*       f = p->fragL;
-  
-  for(; f!=nullptr; f=f->link)
-    if( f->fragId == fragId )
-    {
-      if( f->prev == nullptr )
-        p->fragL = f->link;
-      else
-      {
-        // the previous fragment's end-loc become the
-        // endloc of the deleted fragment
-        f->prev->endLoc = f->endLoc;
-        f->prev->link = f->link;
-      }
-
-      if( f->link != nullptr )
-        f->link->prev = f->prev;
-
-      // release the fragment
-      mem::release(f->presetA);
-      mem::release(f->multiPresetA);
-      mem::release(f);
-      
-      return kOkRC;
-    }
-  
-  return cwLogError(kInvalidArgRC,"The fragment '%i' could not be found to delete.",fragId);
+  return _delete_fragment(p,fragId);
 }
 
 bool cw::preset_sel::is_fragment_end_loc( handle_t h, unsigned loc )

From 475cf5e541d91c380b2bed5651c8f4ed47d03f67 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 28 Mar 2024 19:43:40 -0400
Subject: [PATCH 010/101] cwNbMpScQueue.h/c : Fixed bug where the tail was not
 correctly updated in advance(). Added peek_reset().

---
 cwNbMpScQueue.cpp | 71 ++++++++++++++++++++++++++++-------------------
 cwNbMpScQueue.h   | 16 ++++++++++-
 2 files changed, 57 insertions(+), 30 deletions(-)

diff --git a/cwNbMpScQueue.cpp b/cwNbMpScQueue.cpp
index 70fbb1d..2f21581 100644
--- a/cwNbMpScQueue.cpp
+++ b/cwNbMpScQueue.cpp
@@ -164,6 +164,19 @@ namespace cw
       
       return true;
     }
+
+    void _block_report( nbmpscq_t* p )
+    {
+      block_t* b = p->blockL;
+      for(; b!=nullptr; b=b->link)
+      {
+        bool     full_fl = b->full_flag.load(std::memory_order_acquire);
+        unsigned index   = b->index.load(std::memory_order_acquire);
+        int      eleN    = b->eleN.load(std::memory_order_acquire);
+        
+        printf("full:%i idx:%i eleN:%i\n",full_fl,index,eleN);
+      }
+    }
     
           
   }
@@ -204,26 +217,6 @@ cw::rc_t cw::nbmpscq::create( handle_t& hRef, unsigned initBlkN, unsigned blkByt
     
   }
 
-
-  /*
-  byteN       = initBlkN * (sizeof(block_t) + blkByteN );
-  p->mem      = mem::allocZ<uint8_t>(byteN);
-  
-  for(unsigned i=0; i<byteN; i+=(sizeof(block_t) + blkByteN))
-  {
-    block_t* b = (block_t*)(p->mem+i);
-    b->buf = (uint8_t*)(b + 1);
-    b->bufByteN = blkByteN;
-    
-    b->full_flag.store(false);
-    b->index.store(0);
-    b->eleN.store(0);
-    
-    b->link = p->blockL;
-    p->blockL = b;
-  }
-  */
-  
   hRef.set(p);
   
 errLabel:
@@ -275,6 +268,8 @@ cw::rc_t cw::nbmpscq::push( handle_t h, const void* blob, unsigned blobByteN )
   // to Intel standard.
   assert( nodeByteN % 8 == 0 );
 
+  if( nodeByteN > p->blkByteN )
+    return cwLogError(kInvalidArgRC,"The blob size is too large:%i > %i.",nodeByteN,p->blkByteN);
   
   for(; b!=nullptr; b=b->link)
   {
@@ -325,7 +320,13 @@ cw::rc_t cw::nbmpscq::push( handle_t h, const void* blob, unsigned blobByteN )
   {
     // TODO: continue to iterate through the blocks waiting for the consumer
     // to make more space available.
+    //_block_report(p);
+
+    // BEWARE: BUG BUG BUG: Since the cwLog makes calls to cwWebSocket
+    // this error message, and subsequent error messages,
+    // will result in a recursive loop which will crash the program.
     rc = cwLogError(kBufTooSmallRC,"NbMpScQueue overflow.");
+    
   }
   
   return rc;
@@ -335,9 +336,10 @@ cw::rc_t cw::nbmpscq::push( handle_t h, const void* blob, unsigned blobByteN )
 cw::nbmpscq::blob_t  cw::nbmpscq::get( handle_t h )
 {
   blob_t     blob;
-  nbmpscq_t* p    = _handleToPtr(h);  
-  node_t*    t    = p->tail;
-  node_t*    node = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
+  nbmpscq_t* p    = _handleToPtr(h);
+
+  // We always access the tail element through tail->next.
+  node_t*    node = p->tail->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
 
   _init_blob( blob, node );
   
@@ -349,17 +351,23 @@ cw::nbmpscq::blob_t cw::nbmpscq::advance( handle_t h )
   blob_t     blob;  
   nbmpscq_t* p    = _handleToPtr(h);
   node_t*    t    = p->tail;
-  node_t*    next = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
   
+  // We always access the tail element through tail->next.
+  node_t*    next = t->next.load(std::memory_order_acquire); //  ACQUIRE 'next' from producer
+
+  // We always leave the last element on the queue to act as 'stub'.
   if( next != nullptr )
   {    
     p->tail = next;    
 
-    block_t* b = next->block;
-    int eleN = b->eleN.fetch_add(-1,std::memory_order_acq_rel);
+    // first 'stub' will not have a valid block pointer
+    if( t->block != nullptr )
+    {
+      int eleN = t->block->eleN.fetch_add(-1,std::memory_order_acq_rel);
     
-    // next was valid and so eleN must be >= 1
-    assert( eleN >= 1 );
+      // next was valid and so eleN must be >= 1
+      assert( eleN >= 1 );
+    }
     
   }
 
@@ -393,7 +401,12 @@ cw::nbmpscq::blob_t cw::nbmpscq::peek( handle_t h )
     p->peek = n->next.load(std::memory_order_acquire);
   
   return blob;
-  
+}
+
+void ::cw::nbmpscq::peek_reset(handle_t h)
+{
+  nbmpscq_t* p = _handleToPtr(h);
+  p->peek = nullptr;
 }
 
 
diff --git a/cwNbMpScQueue.h b/cwNbMpScQueue.h
index fe6c13e..591d6bf 100644
--- a/cwNbMpScQueue.h
+++ b/cwNbMpScQueue.h
@@ -39,11 +39,20 @@ namespace cw
     
     rc_t destroy( handle_t& hRef );
 
+    //
+    // Producer Function
+    // 
+
     // push() is called by multiple producer threads to insert
     // an element in the queue.  Note that the 'blob' is copied into
     // the queue and therefore can be released by the caller.
     rc_t push( handle_t h, const void* blob, unsigned blobByteN );
 
+
+    //
+    // Consumer Functions 
+    //
+
     typedef struct blob_str
     {
       rc_t rc;
@@ -68,9 +77,14 @@ namespace cw
     // set to 'nullptr'. The following call will then revert to returning
     // the oldest stored record.
     blob_t peek( handle_t h );
-    
+
+    // Reset peek to point to the oldest stored record.
+    void   peek_reset( handle_t h );
+
+    // Return true if the queue is empty.
     bool is_empty( handle_t h );
 
+    // Count of elements in the queue.
     unsigned count( handle_t h );
 
     rc_t test( const object_t* cfg );

From 60e6c2f772fb4f3880ba72b2c96382f67d851917 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 28 Mar 2024 19:45:40 -0400
Subject: [PATCH 011/101] cwWebSock.h/cpp : Optimize exec() to decrease
 cwIoPresetSelApp GUI startup time. Added _timed_exec_0/1/2()

---
 cwWebSock.cpp | 106 ++++++++++++++++++++++++++++++++++++++++++++++----
 cwWebSock.h   |   4 +-
 2 files changed, 101 insertions(+), 9 deletions(-)

diff --git a/cwWebSock.cpp b/cwWebSock.cpp
index 7411b07..e8a682d 100644
--- a/cwWebSock.cpp
+++ b/cwWebSock.cpp
@@ -462,12 +462,15 @@ namespace cw
     }
 
 
-    rc_t _exec( websock_t* p, unsigned timeOutMs )
+    rc_t _exec( websock_t* p, unsigned timeOutMs, bool* msg_fl_ref=nullptr )
     {
       rc_t rc         = kOkRC;  
       int  adjTimeOut = lws_service_adjust_timeout(p->_ctx, timeOutMs, 0);
       int  sysRC      = 0;
 
+      if( msg_fl_ref != nullptr )
+        *msg_fl_ref = false;
+
       if( p->_pollfdN > 0 )
         sysRC = poll(p->_pollfdA, p->_pollfdN, adjTimeOut);
 
@@ -509,11 +512,76 @@ namespace cw
         {
           // check if it is an fd owned by the application 
         }
+
+        if( msg_fl_ref != nullptr )
+          *msg_fl_ref = true;
+
       }
       
     errLabel:
       return rc;
     }
+
+    // Call _exec() repeatedly for at least timeOutMs-5 milliseconds.
+    rc_t _timed_exec_0( websock_t* p, unsigned timeOutMs )
+    {
+      rc_t rc = kOkRC;
+      time::spec_t t0 = time::current_time();
+      unsigned dMs = 0;
+      unsigned adjTimeOutMs;
+
+      do {
+
+        adjTimeOutMs = timeOutMs - dMs;
+
+        if((rc = _exec(p,adjTimeOutMs)) != kOkRC )
+          break;
+        
+        dMs = time::elapsedMs(t0);
+        
+      }while( dMs+5 < timeOutMs );
+
+      return rc;
+    }
+
+    // Call _exec() as long as incoming messages are received.
+    rc_t _timed_exec_1( websock_t* p, unsigned timeOutMs )
+    {
+      rc_t rc = kOkRC;
+      bool fl = false;
+      
+      do {
+
+        fl = false;
+        if((rc = _exec(p,5,&fl)) != kOkRC )
+          break;
+        
+      }while( fl );
+
+      return rc;
+    }
+
+    // Call _exec() as long as incoming messages are received.
+    // or 'timeOutMs' time elapses.
+    rc_t _timed_exec_2( websock_t* p, unsigned timeOutMs )
+    {
+      rc_t         rc  = kOkRC;
+      bool         fl  = false;
+      time::spec_t t0  = time::current_time();
+      unsigned     dMs = 0;
+      
+      do {
+
+        fl = false;
+        if((rc = _exec(p,5,&fl)) != kOkRC )
+          break;
+
+        dMs = time::elapsedMs(t0);
+        
+      }while( fl && (dMs+5 < timeOutMs) );
+
+      return rc;
+    }
     
   }
 }
@@ -526,7 +594,9 @@ cw::rc_t cw::websock::create(
   const char*       dfltHtmlPageFn,
   int               port,
   const protocol_t* protocolArgA,
-  unsigned          protocolN )
+  unsigned          protocolN,
+  unsigned          queueBlkCnt,
+  unsigned          queueBlkByteCnt )
 {
   rc_t                             rc;
 	struct lws_context_creation_info info;
@@ -571,7 +641,6 @@ cw::rc_t cw::websock::create(
   {
     // Allocate the application protocol state array where this application can keep protocol related info
     auto protocolState = mem::allocZ<protocolState_t>(1);
-    //auto dummy         = mem::allocZ<msg_t>(1);
     
     protocolState->thisPtr = p;
     protocolState->begMsg  = nullptr;
@@ -605,7 +674,7 @@ cw::rc_t cw::websock::create(
 	foreign_loops[0] = p;                  // pass in the custom poll object as the foreign loop object we will bind to
 	info.foreign_loops = foreign_loops;
 
-  if((rc = nbmpscq::create(p->_qH,3,4*4096)) != kOkRC )
+  if((rc = nbmpscq::create(p->_qH,queueBlkCnt,queueBlkByteCnt)) != kOkRC )
   {
     rc = cwLogError(rc,"Websock queue create failed.");
     goto errLabel;
@@ -718,8 +787,10 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
   time::spec_t t0 = time::current_time();
 
   // service any pending websocket activity - with no timeout
-  lws_service_tsi(p->_ctx, -1, 0 );
+  //_timed_exec_1(p,timeOutMs/2);
+  _exec(p,0);
 
+  
   // clean already sent messages from each protocol outgoing msg list
   for(unsigned i=0; i<p->_protocolN-1; ++i)
   {
@@ -727,6 +798,8 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
     _cleanProtocolStateList( p, ps );
   }
 
+  nbmpscq::peek_reset(p->_qH);
+
   // Get the next pending outgoing message.
   while(1)
   {
@@ -751,7 +824,7 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
     protocolState_t* ps = static_cast<protocolState_t*>(protocol->user);
 
     // remove messages from the protocol message queue which have already been sent
-    //_cleanProtocolStateList( p, ps );
+    _cleanProtocolStateList( p, ps );
 
     // Put the msg in the front of the protocal state list (msg's are removed from the back of the list)
     m->msgId          = ps->nextNewMsgId;  // set the msg id
@@ -771,13 +844,16 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
 
     // we want one callback for each session
     for(unsigned i=0; i<ps->sessionN; ++i)
+    {
       lws_callback_on_writable_all_protocol(p->_ctx,protocol);
 
-    lws_service_tsi(p->_ctx, -1, 0 );
+      _exec(p,0);
+
+    }
   }
 
   // block waiting for incoming messages
-  _exec(p,timeOutMs);
+  _timed_exec_2(p,timeOutMs);
   
   p->_execSumMs += time::elapsedMs(t0);
   p->_execN += 1;
@@ -789,5 +865,19 @@ cw::rc_t cw::websock::exec( handle_t h, unsigned timeOutMs )
 void cw::websock::report( handle_t h )
 {
   websock_t* p  = _handleToPtr(h);
+
   printf("Websock: msgs sent:%i recvd:%i que count:%i\n",p->_sendMsgCnt,p->_recvMsgCnt,count(p->_qH));
+
+  // clean already sent messages from each protocol outgoing msg list
+  for(unsigned i=0; i<p->_protocolN-1; ++i)
+  {
+    protocolState_t* ps = static_cast<protocolState_t*>(p->_protocolA[i].user);
+
+    const msg_t* m;
+    unsigned     cnt = 0;
+    for(m=ps->endMsg; m!=nullptr; m=m->link)
+      cnt += 1;
+
+    printf("Protocol:%i %i\n",i,cnt);
+  }  
 }
diff --git a/cwWebSock.h b/cwWebSock.h
index de6dece..b7884ed 100644
--- a/cwWebSock.h
+++ b/cwWebSock.h
@@ -45,7 +45,9 @@ namespace cw
       const char*       dfltHtmlPageFn,
       int               port,
       const protocol_t* protocolA,
-      unsigned          protocolN );
+      unsigned          protocolN,
+      unsigned          queueBlkCnt,
+      unsigned          queueBlkByteCnt );
 
     rc_t destroy( handle_t& h );
 

From 98ed33d2cc3f5a9268edd16e73b5237b63c8f53d Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 28 Mar 2024 19:47:29 -0400
Subject: [PATCH 012/101] cwUi.h/cpp : Add queueBlkCnt and queueBlkByteCnt to
 websock based API's. Removed websockTimeOutMs from UI cfg. and replace it as
 an argument to ui::ws::exec().

---
 cwUi.cpp | 123 +++++++++++++++++++++++++++++++------------------------
 cwUi.h   |  58 ++++++++++++++------------
 2 files changed, 100 insertions(+), 81 deletions(-)

diff --git a/cwUi.cpp b/cwUi.cpp
index 3ba352f..722ca9f 100644
--- a/cwUi.cpp
+++ b/cwUi.cpp
@@ -166,7 +166,7 @@ namespace cw
         bucket_t* b = p->hashA + hash_idx;
 
         for(; b!=nullptr; b=b->link)
-          if( b->ele->appId==appId && b->ele->logical_parent->uuId==parentUuId && (chanId==kInvalidId || b->ele->chanId==chanId) )
+          if( b->ele != nullptr && b->ele->logical_parent!=nullptr && b->ele->appId==appId && b->ele->logical_parent->uuId==parentUuId && (chanId==kInvalidId || b->ele->chanId==chanId) )
             return b->ele->uuId;
       }
       
@@ -2249,7 +2249,6 @@ namespace cw
         void*             cbArg;
         uiCallback_t      uiCbFunc;
         websock::cbFunc_t wsCbFunc;
-        unsigned          wsTimeOutMs;
         unsigned          idleMsgPeriodMs;
         time::spec_t      lastRecvMsgTimeStamp;
       } ui_ws_t;
@@ -2303,7 +2302,7 @@ namespace cw
         ui_ws_t* p = static_cast<ui_ws_t*>(cbArg);
         return websock::send( p->wsH, kUiProtocolId, wsSessId, msg, msgByteN );
       }
-      
+
     }
   }
 }
@@ -2331,13 +2330,18 @@ cw::rc_t cw::ui::ws::parseArgs(  const object_t& o, args_t& args, const char* ob
         "rcvBufByteN", args.rcvBufByteN,
         "xmtBufByteN", args.xmtBufByteN,
         "fmtBufByteN", args.fmtBufByteN,
-        "websockTimeOutMs", args.wsTimeOutMs,
         "idleMsgPeriodMs", args.idleMsgPeriodMs,
+        "queueBlkCnt",     args.queueBlkCnt,
+        "queueBlkByteCnt", args.queueBlkByteCnt,
         "uiCfgFn", uiCfgFn )) != kOkRC )
   {
     rc = cwLogError(rc,"'ui' cfg. parse failed.");
   }
 
+  if( op->find_child("websockTimeOutMs") != nullptr )
+    cwLogWarning("The UI parameter 'websockTimeOutMs' is obsolete and ignored.");
+
+
   // expand the physical root directory
   if((physRootDir = filesys::expandPath( args.physRootDir)) == nullptr )
   {
@@ -2388,11 +2392,12 @@ cw::rc_t cw::ui::ws::create( handle_t& h,
                 appIdMapN,
                 wsCbFunc,
                 args.dfltPageFn,
-                args.wsTimeOutMs,
                 args.idleMsgPeriodMs,
                 args.rcvBufByteN,
                 args.xmtBufByteN,
-                args.fmtBufByteN );
+                args.fmtBufByteN,
+                args.queueBlkCnt,
+                args.queueBlkByteCnt);
 }
 
   
@@ -2406,11 +2411,12 @@ cw::rc_t cw::ui::ws::create(  handle_t& h,
                               unsigned          appIdMapN,
                               websock::cbFunc_t wsCbFunc,
                               const char*       dfltPageFn,
-                              unsigned          websockTimeOutMs,
                               unsigned          idleMsgPeriodMs,
                               unsigned          rcvBufByteN,
                               unsigned          xmtBufByteN,
-                              unsigned          fmtBufByteN )
+                              unsigned          fmtBufByteN,
+                              unsigned          queueBlkCnt,
+                              unsigned          queueBlkByteCnt )
 {
   rc_t rc = kOkRC;
 
@@ -2430,7 +2436,7 @@ cw::rc_t cw::ui::ws::create(  handle_t& h,
   void*             wsCbA     = wsCbFunc==nullptr ? p          : cbArg;
   
   // create the websocket
-  if((rc = websock::create(p->wsH, wsCbF, wsCbA, physRootDir, dfltPageFn, port, protocolA, protocolN )) != kOkRC )
+  if((rc = websock::create(p->wsH, wsCbF, wsCbA, physRootDir, dfltPageFn, port, protocolA, protocolN, queueBlkCnt, queueBlkByteCnt )) != kOkRC )
   {
     cwLogError(rc,"UI Websock create failed.");
     goto errLabel;
@@ -2446,7 +2452,6 @@ cw::rc_t cw::ui::ws::create(  handle_t& h,
   p->cbArg       = cbArg;
   p->uiCbFunc    = uiCbFunc;
   p->wsCbFunc    = wsCbFunc;
-  p->wsTimeOutMs = websockTimeOutMs;
   p->idleMsgPeriodMs = idleMsgPeriodMs;
   // initialize the last received msg
   time::get(p->lastRecvMsgTimeStamp);
@@ -2479,13 +2484,13 @@ cw::rc_t cw::ui::ws::destroy( handle_t& h )
   return rc;
 }
       
-cw::rc_t cw::ui::ws::exec( handle_t h )
+cw::rc_t cw::ui::ws::exec( handle_t h, unsigned wsTimeOutMs )
 {
-  rc_t     rc = kOkRC;
   ui_ws_t* p  = _handleToPtr(h);
+  rc_t     rc = kOkRC;
   time::spec_t t;
   
-  if((rc = websock::exec( p->wsH, p->wsTimeOutMs )) != kOkRC)
+  if((rc = websock::exec( p->wsH, wsTimeOutMs )) != kOkRC)
     cwLogError(rc,"The UI websock execution failed.");
 
   // make the idle callback
@@ -2500,6 +2505,7 @@ cw::rc_t cw::ui::ws::exec( handle_t h )
   return rc;
 }
 
+
 cw::rc_t cw::ui::ws::onReceive( handle_t h, unsigned protocolId, unsigned sessionId, websock::msgTypeId_t msg_type, const void* msg, unsigned byteN )
 {
   ui_ws_t* p = _handleToPtr(h);
@@ -2521,6 +2527,7 @@ cw::ui::handle_t cw::ui::ws::uiHandle( handle_t h )
   return p->uiH;
 }
 
+
 void cw::ui::ws::realTimeReport( handle_t h )
 {
   ui_ws_t* p  = _handleToPtr(h);
@@ -2539,6 +2546,7 @@ namespace cw
       {
         ws::handle_t     wsUiH;
         thread::handle_t thH;
+        unsigned         wsTimeOutMs;
       } ui_ws_srv_t;
 
       ui_ws_srv_t* _handleToPtr(handle_t h )
@@ -2563,7 +2571,7 @@ namespace cw
         ui_ws_srv_t* p = static_cast<ui_ws_srv_t*>(arg);
         rc_t rc;
         
-        if((rc = ws::exec(p->wsUiH)) != kOkRC )
+        if((rc = ws::exec(p->wsUiH,p->wsTimeOutMs)) != kOkRC )
         {
           cwLogError(rc,"Websocket UI exec failed.");
         }
@@ -2574,20 +2582,51 @@ namespace cw
   }
 }
 
+cw::rc_t cw::ui::srv::create( handle_t& h,
+                              const ws::args_t&     args,
+                              void*             cbArg,
+                              uiCallback_t      uiCbFunc,
+                              const appIdMap_t* appIdMapA,
+                              unsigned          appIdMapN,
+                              unsigned          wsTimeOutMs,
+                              websock::cbFunc_t wsCbFunc )
+{
+  return create(h,
+                args.port,
+                args.physRootDir,
+                cbArg,
+                uiCbFunc,
+                args.uiRsrc,
+                appIdMapA,
+                appIdMapN,
+                wsTimeOutMs,
+                wsCbFunc,
+                args.dfltPageFn,
+                args.idleMsgPeriodMs,
+                args.rcvBufByteN,
+                args.xmtBufByteN,
+                args.fmtBufByteN,
+                args.queueBlkCnt,
+                args.queueBlkByteCnt );
+}
+      
 cw::rc_t cw::ui::srv::create(  handle_t& h,
-  unsigned          port,
-  const char*       physRootDir,
-  void*             cbArg,
-  uiCallback_t      uiCbFunc,
-  const object_t*   uiRsrc,
-  const appIdMap_t* appIdMapA,
-  unsigned          appIdMapN,
-  websock::cbFunc_t wsCbFunc,
-  const char*       dfltPageFn,
-  unsigned          websockTimeOutMs,
-  unsigned          rcvBufByteN,
-  unsigned          xmtBufByteN,
-  unsigned          fmtBufByteN )
+                               unsigned          port,
+                               const char*       physRootDir,
+                               void*             cbArg,
+                               uiCallback_t      uiCbFunc,
+                               const object_t*   uiRsrc,
+                               const appIdMap_t* appIdMapA,
+                               unsigned          appIdMapN,
+                               unsigned          wsTimeOutMs,
+                               websock::cbFunc_t wsCbFunc,
+                               const char*       dfltPageFn,
+                               unsigned          idleMsgPeriodMs,
+                               unsigned          rcvBufByteN,
+                               unsigned          xmtBufByteN,
+                               unsigned          fmtBufByteN,
+                               unsigned          queueBlkCnt,
+                               unsigned          queueBlkByteCnt )
 {
   rc_t rc = kOkRC;
   if((rc = destroy(h)) != kOkRC )
@@ -2595,7 +2634,7 @@ cw::rc_t cw::ui::srv::create(  handle_t& h,
 
   ui_ws_srv_t* p = mem::allocZ<ui_ws_srv_t>();
   
-  if((rc = ws::create(p->wsUiH, port, physRootDir, cbArg, uiCbFunc, uiRsrc,appIdMapA, appIdMapN, wsCbFunc, dfltPageFn, websockTimeOutMs, rcvBufByteN, xmtBufByteN, fmtBufByteN )) != kOkRC )
+  if((rc = ws::create(p->wsUiH, port, physRootDir, cbArg, uiCbFunc, uiRsrc,appIdMapA, appIdMapN, wsCbFunc, dfltPageFn, idleMsgPeriodMs, rcvBufByteN, xmtBufByteN, fmtBufByteN, queueBlkCnt, queueBlkByteCnt )) != kOkRC )
   {
     cwLogError(rc,"The websock UI creationg failed.");
     goto errLabel;
@@ -2607,6 +2646,8 @@ cw::rc_t cw::ui::srv::create(  handle_t& h,
     goto errLabel;
   }
 
+  p->wsTimeOutMs = wsTimeOutMs;
+  
   h.set(p);
   
  errLabel:
@@ -2616,32 +2657,6 @@ cw::rc_t cw::ui::srv::create(  handle_t& h,
   return rc;
 }
 
-cw::rc_t cw::ui::srv::create( handle_t& h,
-  const ws::args_t&     args,
-  void*             cbArg,
-  uiCallback_t      uiCbFunc,
-  const appIdMap_t* appIdMapA,
-  unsigned          appIdMapN,        
-  websock::cbFunc_t wsCbFunc )
-{
-  return create(h,
-    args.port,
-    args.physRootDir,
-    cbArg,
-    uiCbFunc,
-    args.uiRsrc,
-    appIdMapA,
-    appIdMapN,
-    wsCbFunc,
-    args.dfltPageFn,
-    args.wsTimeOutMs,
-    args.rcvBufByteN,
-    args.xmtBufByteN,
-    args.fmtBufByteN );
-}
-      
-
-
 cw::rc_t cw::ui::srv::destroy( handle_t& h )
 {
   rc_t rc = kOkRC;
diff --git a/cwUi.h b/cwUi.h
index e4077e4..fa685f9 100644
--- a/cwUi.h
+++ b/cwUi.h
@@ -188,8 +188,9 @@ namespace cw
         unsigned        rcvBufByteN;
         unsigned        xmtBufByteN;
         unsigned        fmtBufByteN;
-        unsigned        wsTimeOutMs;
         unsigned        idleMsgPeriodMs; // min period without messages before an idle message is generated
+        unsigned        queueBlkCnt;
+        unsigned        queueBlkByteCnt;
       } args_t;
 
       rc_t parseArgs( const object_t& o, args_t& args, const char* object_label="ui" );
@@ -214,20 +215,20 @@ namespace cw
                     unsigned          appIdMapN        = 0,
                     websock::cbFunc_t wsCbFunc         = nullptr,        
                     const char*       dfltPageFn       = "index.html",        
-                    unsigned          websockTimeOutMs = 50,
                     unsigned          idleMsgPeriodMs  = 50,
                     unsigned          rcvBufByteN      = 1024,
                     unsigned          xmtBufByteN      = 1024,
-                    unsigned          fmtBufByteN      = 4096                    
-                    );
+                    unsigned          fmtBufByteN      = 4096,
+                    unsigned          queueBlkCnt      = 4,
+                    unsigned          queueBlkByteCnt  = 4096 );
 
       rc_t destroy( handle_t& h );
 
       // This function should be called periodically to send and receive
       // queued messages to and from the websocket.
       // Note that this call may block for up to 'wsTimeOutMs' milliseconds
-      // on the websocket handle.
-      rc_t exec( handle_t h );
+      // while waiting for incoming websocket messages.
+      rc_t exec( handle_t h, unsigned wsTimeOutMs );
 
       // This function executes the internal default websock callback function.
       // It is useful if the user provides a custom websock callback function
@@ -236,8 +237,7 @@ namespace cw
       
       websock::handle_t websockHandle( handle_t h );
       ui::handle_t      uiHandle( handle_t h );
-
-      void realTimeReport( handle_t h );
+      void              realTimeReport( handle_t h );
       
     }
 
@@ -247,27 +247,31 @@ namespace cw
       typedef handle<struct ui_ws_srv_str> handle_t;
 
       rc_t create( handle_t& h,
-        const ws::args_t&     args,
-        void*             cbArg,
-        uiCallback_t      uiCbFunc,        
-        const appIdMap_t* appIdMapA = nullptr,
-        unsigned          appIdMapN = 0,        
-        websock::cbFunc_t wsCbFunc  = nullptr );
+                   const ws::args_t& args,
+                   void*             cbArg,
+                   uiCallback_t      uiCbFunc,        
+                   const appIdMap_t* appIdMapA = nullptr,
+                   unsigned          appIdMapN = 0,
+                   unsigned          wsTimeOutMs = 50,                   
+                   websock::cbFunc_t wsCbFunc  = nullptr );
       
       rc_t create(  handle_t& h,
-        unsigned          port,
-        const char*       physRootDir,
-        void*             cbArg,
-        uiCallback_t      uiCbFunc,
-        const object_t*   uiRsrc           = nullptr,
-        const appIdMap_t* appIdMapA        = nullptr,
-        unsigned          appIdMapN        = 0,        
-        websock::cbFunc_t wsCbFunc         = nullptr,
-        const char*       dfltPageFn       = "index.html",
-        unsigned          websockTimeOutMs = 50,
-        unsigned          rcvBufByteN      = 1024,
-        unsigned          xmtBufByteN      = 1024,
-        unsigned          fmtBufByteN      = 4096 );
+                    unsigned          port,
+                    const char*       physRootDir,
+                    void*             cbArg,
+                    uiCallback_t      uiCbFunc,
+                    const object_t*   uiRsrc           = nullptr,
+                    const appIdMap_t* appIdMapA        = nullptr,
+                    unsigned          appIdMapN        = 0,        
+                    unsigned          wsTimeOutMs      = 50,
+                    websock::cbFunc_t wsCbFunc         = nullptr,
+                    const char*       dfltPageFn       = "index.html",
+                    unsigned          idleMsgPeriodMs  = 50,                    
+                    unsigned          rcvBufByteN      = 1024,
+                    unsigned          xmtBufByteN      = 1024,
+                    unsigned          fmtBufByteN      = 4096,
+                    unsigned          queueBlkCnt      = 4,
+                    unsigned          queueBlkByteCnt  = 4096 );
 
 
       rc_t destroy( handle_t& h );

From d5f75f961c6e67e986c4c15d7b9c1225538b520e Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 28 Mar 2024 19:48:46 -0400
Subject: [PATCH 013/101] Added 'timeOutMs' arg. to all calls to
 ui::ws::exec().

---
 cwIo.cpp             |  8 +++++---
 cwIo.h               |  7 ++++---
 cwIoAudioMidi.cpp    | 12 ++++++++++--
 cwIoAudioMidiApp.cpp | 12 ++++++++++--
 cwIoMinTest.cpp      | 12 ++++++++++--
 cwIoPresetSelApp.cpp | 46 +++++++++++++++++++++++++++++---------------
 cwIoTest.cpp         | 12 ++++++++++--
 cwUiTest.cpp         |  7 ++++---
 cwWebSockSvr.cpp     | 10 +++++++---
 cwWebSockSvr.h       |  4 +++-
 10 files changed, 94 insertions(+), 36 deletions(-)

diff --git a/cwIo.cpp b/cwIo.cpp
index c00f79a..5a0ebc5 100644
--- a/cwIo.cpp
+++ b/cwIo.cpp
@@ -2439,7 +2439,8 @@ cw::rc_t cw::io::stop( handle_t h )
   return rc;
 }
 
-cw::rc_t cw::io::exec( handle_t h, void* execCbArg )
+
+cw::rc_t cw::io::exec( handle_t h, unsigned timeOutMs, void* execCbArg )
 {
   rc_t rc = kOkRC;
   io_t* p = _handleToPtr(h);
@@ -2447,8 +2448,9 @@ cw::rc_t cw::io::exec( handle_t h, void* execCbArg )
   if( p->wsUiH.isValid() )
   {
     ui::flushCache( ui::ws::uiHandle( p->wsUiH ));
+    
     // Note this call blocks on the websocket handle: See cwUi.h:ws:exec()
-    rc = ui::ws::exec( p->wsUiH );
+    rc = ui::ws::exec( p->wsUiH, timeOutMs );
   }
   
   time::get(p->t0);
@@ -2490,7 +2492,7 @@ void cw::io::report( handle_t h )
     }
 
   for(unsigned i=0; i<audioDeviceCount(h); ++i)
-    printf("audio: %s\n", audioDeviceName(h,i));  
+    printf("audio: %s\n", cwStringNullGuard(audioDeviceName(h,i)));  
 }
 
 void cw::io::realTimeReport( handle_t h )
diff --git a/cwIo.h b/cwIo.h
index ce2fbdd..ec4a8e1 100644
--- a/cwIo.h
+++ b/cwIo.h
@@ -164,10 +164,11 @@ namespace cw
     rc_t start( handle_t h );
     rc_t pause( handle_t h );
     rc_t stop(  handle_t h );
-    
-    // Note that this call blocks on the the UI websocket handle.
+
+
+    // Note that this call blocks on the the UI websocket handle for up to 'timeOutMs'.
     // See ui:ws:exec().
-    rc_t exec(  handle_t h, void* execCbArg=nullptr );
+    rc_t exec(  handle_t h, unsigned timeOutMs, void* execCbArg=nullptr );
     
     bool isShuttingDown( handle_t h );
     void report( handle_t h );
diff --git a/cwIoAudioMidi.cpp b/cwIoAudioMidi.cpp
index b7ebc07..0c60b5f 100644
--- a/cwIoAudioMidi.cpp
+++ b/cwIoAudioMidi.cpp
@@ -1024,8 +1024,16 @@ cw::rc_t cw::io::audio_midi::main( const object_t* cfg )
   // execute the io framework
   while( !isShuttingDown(app.ioH))
   {
-    exec(app.ioH);
-    sleepMs(50);
+    const unsigned wsTimeOutMs = 50;
+    time::spec_t t0 = time::current_time();
+    
+    exec(app.ioH,wsTimeOutMs);
+    
+    time::spec_t t1  = time::current_time();
+    unsigned     dMs = time::elapsedMs(t0,t1);
+    
+    if( dMs < wsTimeOutMs ) 
+      sleepMs(wsTimeOutMs-dMs);
   }
 
  errLabel:
diff --git a/cwIoAudioMidiApp.cpp b/cwIoAudioMidiApp.cpp
index 2ac0322..a048411 100644
--- a/cwIoAudioMidiApp.cpp
+++ b/cwIoAudioMidiApp.cpp
@@ -580,8 +580,16 @@ cw::rc_t cw::audio_midi_app::main( const object_t* cfg )
   // execute the io framework
   while( !isShuttingDown(app.ioH))
   {
-    exec(app.ioH);
-    sleepMs(50);
+    const unsigned wsTimeOutMs = 50;
+    time::spec_t t0 = time::current_time();
+    
+    exec(app.ioH,wsTimeOutMs);
+    
+    time::spec_t t1  = time::current_time();
+    unsigned     dMs = time::elapsedMs(t0,t1);
+    
+    if( dMs < wsTimeOutMs ) 
+      sleepMs(wsTimeOutMs-dMs);
   }
 
  errLabel:
diff --git a/cwIoMinTest.cpp b/cwIoMinTest.cpp
index bbeffea..27597bd 100644
--- a/cwIoMinTest.cpp
+++ b/cwIoMinTest.cpp
@@ -118,8 +118,16 @@ cw::rc_t cw::min_test( const object_t* cfg )
   // execuite the io framework
   while( !isShuttingDown(app.ioH))
   {
-    exec(app.ioH);
-    sleepMs(500);
+    const unsigned wsTimeOutMs = 50;
+    time::spec_t t0 = time::current_time();
+    
+    exec(app.ioH,wsTimeOutMs);
+    
+    time::spec_t t1  = time::current_time();
+    unsigned     dMs = time::elapsedMs(t0,t1);
+    
+    if( dMs < wsTimeOutMs ) 
+      sleepMs(wsTimeOutMs-dMs);
 
     if( isKeyWaiting() )
       break;
diff --git a/cwIoPresetSelApp.cpp b/cwIoPresetSelApp.cpp
index 54c9e7a..b5c28c3 100644
--- a/cwIoPresetSelApp.cpp
+++ b/cwIoPresetSelApp.cpp
@@ -372,6 +372,7 @@ namespace cw
 
       const char* dflt_perf_label;
       unsigned    dflt_perf_app_id;
+      unsigned    run_dur_secs;
       
       
     } app_t;
@@ -446,6 +447,7 @@ namespace cw
                                     "beg_play_loc",         app->beg_play_loc,
                                     "end_play_loc",         app->end_play_loc,
                                     "dflt_perf_label",      app->dflt_perf_label,
+                                    "run_dur_secs",         app->run_dur_secs,
                                     "live_mode_fl",         app->useLiveMidiFl,
                                     "enable_recording_fl",  app->enableRecordFl,
                                     "midi_record_dir",      midi_record_dir,
@@ -553,8 +555,8 @@ namespace cw
     {
       app_t*   app     = (app_t*)arg;
       unsigned logUuId = uiFindElementUuId( app->ioH, kLogId);
-
-      uiSetLogLine( app->ioH, logUuId, text );
+      
+      //uiSetLogLine( app->ioH, logUuId, text );
       log::defaultOutput(nullptr,level,text);
     }
 
@@ -711,6 +713,7 @@ namespace cw
       char*             perf_fname = nullptr;
       char*             meta_fname = nullptr;
       bool              skip_fl    = false;
+      
       // create the performance recording file path
       if((perf_fname = filesys::makeFn(dir,fname,nullptr,recording_folder,nullptr)) == nullptr )
       {
@@ -782,8 +785,11 @@ namespace cw
 
       mem::release(meta_fname);
       mem::release(perf_fname);
-      return rc;
+
+      if( meta_cfg != nullptr )
+        meta_cfg->free();
       
+      return rc;      
     }
 
     rc_t _parse_perf_recording_dir( app_t* app, const char* dir, const char* fname, const object_t* velTblCfg )
@@ -1813,7 +1819,7 @@ namespace cw
 
     errLabel:
       if(rc != kOkRC )
-        rc = cwLogError(rc,"Preset control index '%i' create failed.");
+        rc = cwLogError(rc,"Preset control index '%i' create failed.", preset_idx);
       return rc;
     }
 
@@ -1900,7 +1906,7 @@ namespace cw
       // read the preset data file
       if((rc = preset_sel::read( app->psH, fn)) != kOkRC )
       {
-        rc = cwLogError(rc,"File write failed on preset select.");
+        rc = cwLogError(rc,"File read failed on preset select.");
         goto errLabel;
       }
 
@@ -3019,7 +3025,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
           break;
 
         case kIoReportBtnId:
-          io::report( app->ioH );
+          io::realTimeReport( app->ioH );
           break;
 
         case kNetPrintBtnId:
@@ -3586,6 +3592,7 @@ cw::rc_t cw::preset_sel_app::main( const object_t* cfg, int argc, const char* ar
   unsigned              bigMapN = mapN + vtMapN;
   ui::appIdMap_t        bigMap[ bigMapN ];
   double                sysSampleRate = 0;
+  time::spec_t          start_time = time::current_time();
 
   for(unsigned i=0; i<mapN; ++i)
     bigMap[i] = mapA[i];
@@ -3709,18 +3716,27 @@ cw::rc_t cw::preset_sel_app::main( const object_t* cfg, int argc, const char* ar
   // execute the io framework
   while( !io::isShuttingDown(app.ioH))
   {
-    //time::spec_t t0;
-    //time::get(t0);
+    const unsigned wsTimeOutMs = 50;
+    time::spec_t t0 = time::current_time();
+
+    unsigned timeOutMs = app.psNextFrag != nullptr ? 0 : wsTimeOutMs;
 
     // This call may block on the websocket handle.
-    io::exec(app.ioH);
-    
-    //unsigned dMs = time::elapsedMs(t0);
-    //if( dMs < 50 && app.psNextFrag == nullptr )
-    //{      
-    //  sleepMs( 50-dMs );      
-    //}
+    io::exec(app.ioH,timeOutMs);
 
+    time::spec_t t1  = time::current_time();
+    unsigned     dMs = time::elapsedMs(t0,t1);
+    
+    if( dMs < wsTimeOutMs && app.psNextFrag == nullptr )
+    {      
+      sleepMs( wsTimeOutMs-dMs );      
+    }
+
+    if( app.run_dur_secs != 0 && time::elapsedMs( start_time )/1000 > app.run_dur_secs )
+    {
+      printf("Run duration expired (%i secs).  Shutting down.\n",app.run_dur_secs);
+      io::stop(app.ioH);
+    }
   }
 
   // stop the io framework
diff --git a/cwIoTest.cpp b/cwIoTest.cpp
index 298736b..94c27ed 100644
--- a/cwIoTest.cpp
+++ b/cwIoTest.cpp
@@ -308,8 +308,16 @@ cw::rc_t cw::io::test( const object_t* cfg )
   // execuite the io framework
   while( !isShuttingDown(app.ioH))
   {
-    exec(app.ioH);
-    sleepMs(50);
+    const unsigned wsTimeOutMs = 50;
+    time::spec_t t0 = time::current_time();
+    
+    exec(app.ioH,wsTimeOutMs);
+    
+    time::spec_t t1  = time::current_time();
+    unsigned     dMs = time::elapsedMs(t0,t1);
+    
+    if( dMs < wsTimeOutMs ) 
+      sleepMs(wsTimeOutMs-dMs);
   }
 
  errLabel:
diff --git a/cwUiTest.cpp b/cwUiTest.cpp
index cefc571..48054b9 100644
--- a/cwUiTest.cpp
+++ b/cwUiTest.cpp
@@ -378,8 +378,9 @@ namespace cw
 
 cw::rc_t cw::ui::test( const object_t* cfg )
 {
-  rc_t           rc   = kOkRC;
-  ui::ws::args_t args = {};
+  rc_t           rc          = kOkRC;
+  unsigned       wsTimeOutMs = 50;
+  ui::ws::args_t args        = {};
   
   // Application Id's for the resource based UI elements.
   appIdMap_t mapA[] =
@@ -437,7 +438,7 @@ cw::rc_t cw::ui::test( const object_t* cfg )
   //app->uiCfgFn = "/home/kevin/src/cwtest/src/libcw/html/uiTest/ui.cfg";
 
   // create the UI server
-  if((rc = srv::create(app->wsUiSrvH, args, app, _uiTestCallback, mapA, mapN, nullptr )) != kOkRC )
+  if((rc = srv::create(app->wsUiSrvH, args, app, _uiTestCallback, mapA, mapN, wsTimeOutMs, nullptr )) != kOkRC )
     return rc;
 
   if((rc = uiTestCreateUi( app )) != kOkRC )
diff --git a/cwWebSockSvr.cpp b/cwWebSockSvr.cpp
index e55dbc4..9c083c8 100644
--- a/cwWebSockSvr.cpp
+++ b/cwWebSockSvr.cpp
@@ -56,7 +56,9 @@ cw::rc_t cw::websockSrv::create(
     int                        port,
     const websock::protocol_t* protocolA,
     unsigned                   protocolN,
-    unsigned                   timeOutMs )
+    unsigned                   timeOutMs,
+    unsigned                   queueBlkCnt,
+    unsigned                   queueBlkByteCnt )
 {
   rc_t rc;
   if((rc = destroy(h)) != kOkRC )
@@ -64,7 +66,7 @@ cw::rc_t cw::websockSrv::create(
 
   websockSrv_t* p = mem::allocZ<websockSrv_t>();
 
-  if((rc = websock::create( p->_websockH, cbFunc, cbArg, physRootDir, dfltHtmlPageFn, port, protocolA, protocolN )) != kOkRC )
+  if((rc = websock::create( p->_websockH, cbFunc, cbArg, physRootDir, dfltHtmlPageFn, port, protocolA, protocolN, queueBlkCnt, queueBlkByteCnt )) != kOkRC )
     goto errLabel;
   
 
@@ -176,6 +178,8 @@ cw::rc_t cw::websockSrvTest( const object_t* cfg )
   int                  port           = 5687;
   unsigned             rcvBufByteN    = 128;
   unsigned             xmtBufByteN    = 128;
+  unsigned             queueBlkCnt    = 3;
+  unsigned             queueBlkByteCnt= 4096;
   appCtx_t             appCtx;
 
   enum
@@ -198,7 +202,7 @@ cw::rc_t cw::websockSrvTest( const object_t* cfg )
   unsigned protocolN = sizeof(protocolA)/sizeof(protocolA[0]);
 
   
-  if((rc = websockSrv::create( h, websockCb, &appCtx, physRootDir, dfltHtmlPageFn, port, protocolA, protocolN, timeOutMs )) != kOkRC )
+  if((rc = websockSrv::create( h, websockCb, &appCtx, physRootDir, dfltHtmlPageFn, port, protocolA, protocolN, timeOutMs, queueBlkCnt, queueBlkByteCnt )) != kOkRC )
     return rc;
 
   appCtx.wsH        = websockSrv::websockHandle(h);
diff --git a/cwWebSockSvr.h b/cwWebSockSvr.h
index fdab325..2be27e4 100644
--- a/cwWebSockSvr.h
+++ b/cwWebSockSvr.h
@@ -16,7 +16,9 @@ namespace cw {
       int                        port,
       const websock::protocol_t* protocolA,
       unsigned                   protocolN,
-      unsigned                   websockTimeOutMs );
+      unsigned                   websockTimeOutMs,
+      unsigned                   queueBlkCnt,
+      unsigned                   queueBlkByteCnt);
 
     rc_t destroy( handle_t& h );
 

From 97da53650415a24afef2b2dd62886968e6b8c90b Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 30 Mar 2024 18:01:08 -0400
Subject: [PATCH 014/101] cwIoPresetSelApp.cpp : beg_loc,end_loc is now applied
 to midi player from meta.cfg on file load.

---
 cwIoPresetSelApp.cpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/cwIoPresetSelApp.cpp b/cwIoPresetSelApp.cpp
index b5c28c3..d33c970 100644
--- a/cwIoPresetSelApp.cpp
+++ b/cwIoPresetSelApp.cpp
@@ -293,7 +293,7 @@ namespace cw
       const char* record_fn_ext;
       const char* record_backup_dir;
       
-      const char*     scoreFn;
+      //const char*     scoreFn;
       const object_t* perfDirL;
       const char*     velTableFname;
       const char*     velTableBackupDir;
@@ -388,13 +388,13 @@ namespace cw
           app->record_fn = argv[i+1];
           goto found_fl;
         }
-        
+        /*
         if( textCompare(argv[i],"score_fn") == 0 )
         {
           app->scoreFn = argv[i+1];
           goto found_fl;
         }
-
+        */
         if( textCompare(argv[i],"beg_play_loc") == 0 )
         {
           string_to_number( argv[i+1], app->beg_play_loc );
@@ -436,7 +436,7 @@ namespace cw
       if((rc = params_cfgRef->getv( "record_dir",           app->record_dir,
                                     "record_fn",            app->record_fn,
                                     "record_fn_ext",        app->record_fn_ext,
-                                    "score_fn",             app->scoreFn,
+            //"score_fn",             app->scoreFn,
                                     "perfDirL",             app->perfDirL,
                                     "flow_proc_dict_fn",    flow_proc_dict_fn,                                    
                                     "midi_play_record",     app->midi_play_record_cfg,
@@ -470,11 +470,13 @@ namespace cw
       _apply_command_line_args(app,argc,argv);
 
 
+      /*
       if((app->scoreFn    = filesys::expandPath( app->scoreFn )) == nullptr )
       {
         rc = cwLogError(kInvalidArgRC,"The score file name is invalid.");
         goto errLabel;
       }
+      */
       
       if((app->record_dir = filesys::expandPath(app->record_dir)) == nullptr )
       {
@@ -587,7 +589,7 @@ namespace cw
 
       mem::release((char*&)app.record_backup_dir);
       mem::release((char*&)app.record_dir);
-      mem::release((char*&)app.scoreFn);
+      //mem::release((char*&)app.scoreFn);
       mem::release(app.midiRecordDir);
       mem::release(app.midiLoadFname);
       vtbl::destroy(app.vtH);
@@ -1135,7 +1137,6 @@ namespace cw
             {
               if( preset_sel::track_loc( app->psH, loc, f ) )  
               {
-
                 _apply_preset( app, loc, (const perf_score::event_t*)msg_arg, f );
                 
                 if( f != nullptr )
@@ -2131,7 +2132,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
             m[i].id     = e->uid;
             m[i].loc    = e->loc;
             m[i].arg    = e;
-
+            
             app->locMap[i].loc = e->loc;
             app->locMap[i].timestamp = m[i].timestamp;
 
@@ -2222,7 +2223,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
       return rc;
     }
 
-    rc_t _do_load_perf_score( app_t* app, const char* perf_fn, const vel_tbl_t* vtA=nullptr, unsigned vtN=0 )
+    rc_t _do_load_perf_score( app_t* app, const char* perf_fn, const vel_tbl_t* vtA=nullptr, unsigned vtN=0, unsigned beg_loc=score_parse::kInvalidLocId, unsigned end_loc=score_parse::kInvalidLocId )
     {
       rc_t     rc          = kOkRC;
       unsigned midiEventN  = 0;
@@ -2267,8 +2268,8 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
       // set the UI begin/end play to the locations of the newly loaded performance
       if( !lockLoctnFl )
       {
-        app->end_play_loc = app->maxPerfLoc;
-        app->beg_play_loc = app->minPerfLoc;
+        app->end_play_loc = end_loc==score_parse::kInvalidLocId ? app->maxPerfLoc : end_loc;
+        app->beg_play_loc = beg_loc==score_parse::kInvalidLocId ? app->minPerfLoc : beg_loc;
       }
       
       // Update the master range of the play beg/end number widgets
@@ -2334,7 +2335,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
       printf("Loading:%s\n",prp->fname );
       
       // load the requested performance
-      if((rc = _do_load_perf_score(app,prp->fname,prp->vel_tblA, prp->vel_tblN)) != kOkRC )
+      if((rc = _do_load_perf_score(app,prp->fname,prp->vel_tblA, prp->vel_tblN, prp->beg_loc, prp->end_loc)) != kOkRC )
       {
         rc = cwLogError(kSyntaxErrorRC,"The performance load failed.");
         goto errLabel;

From 7d3be5ebc6ed6017676d6381f36a5061bf33ecbe Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 6 Apr 2024 15:41:20 -0400
Subject: [PATCH 015/101] cwIoPresetSelApp.cpp, ui.cfg : Add 'RT' and 'Hw'
 reports buttons.

---
 cwIoPresetSelApp.cpp   | 12 ++++++++++++
 html/preset_sel/ui.cfg |  2 ++
 2 files changed, 14 insertions(+)

diff --git a/cwIoPresetSelApp.cpp b/cwIoPresetSelApp.cpp
index b5c28c3..e717df3 100644
--- a/cwIoPresetSelApp.cpp
+++ b/cwIoPresetSelApp.cpp
@@ -47,6 +47,8 @@ namespace cw
       kPanelDivId = 1000,
       kQuitBtnId,
       kIoReportBtnId,
+      kIoHwReportBtnId,
+      kIoRtReportBtnId,
       kNetPrintBtnId,
       kReportBtnId,
       kLatencyBtnId,
@@ -155,6 +157,8 @@ namespace cw
       { ui::kRootAppId,  kPanelDivId,     "panelDivId" },
       { kPanelDivId,     kQuitBtnId,      "quitBtnId" },
       { kPanelDivId,     kIoReportBtnId,  "ioReportBtnId" },
+      { kPanelDivId,     kIoHwReportBtnId, "ioHwReportBtnId" },
+      { kPanelDivId,     kIoRtReportBtnId, "ioRtReportBtnId" },
       { kPanelDivId,     kNetPrintBtnId,  "netPrintBtnId" },
       { kPanelDivId,     kReportBtnId,    "reportBtnId" },
       { kPanelDivId,     kLatencyBtnId,   "latencyBtnId" },
@@ -3025,6 +3029,14 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
           break;
 
         case kIoReportBtnId:
+          io::report( app->ioH );
+          break;
+
+        case kIoHwReportBtnId:
+          io::hardwareReport( app->ioH );
+          break;
+          
+        case kIoRtReportBtnId:
           io::realTimeReport( app->ioH );
           break;
 
diff --git a/html/preset_sel/ui.cfg b/html/preset_sel/ui.cfg
index 0b722b6..95de588 100644
--- a/html/preset_sel/ui.cfg
+++ b/html/preset_sel/ui.cfg
@@ -10,6 +10,8 @@
 	    row: {
 		button:{ name: quitBtnId,     title:"Quit"   },
 		button:{ name: ioReportBtnId, title:"IO Report" },
+		button:{ name: ioRtReportBtnId, title: "IO RT Report" },
+		button:{ name: ioHwReportBtnId, title: "IO Hw Report" },
 		button:{ name: netPrintBtnId, title:"Print Network" }
 		button:{ name: reportBtnId,   title:"App Report" },
 		button:{ name: latencyBtnId,  title:"Latency Reset"},

From a6f518ed54c98cf93368ebf4755b84b77da076db Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 6 Apr 2024 15:44:43 -0400
Subject: [PATCH 016/101] cwMidiDevice.h/cpp,cwMidiDecls.h : Added
 getBuffer(),clearBuffer(),maxBufferMsgCount() to cwMidiDevice. Changed the
 MIDI device callback function to move the user arg outside of the 'packet_t'.
 Added midi::ch_msg_t

---
 cwMidiDecls.h    |  17 +++++--
 cwMidiDevice.cpp | 127 +++++++++++++++++++++++++++++++++++++++++++----
 cwMidiDevice.h   |  10 +++-
 3 files changed, 140 insertions(+), 14 deletions(-)

diff --git a/cwMidiDecls.h b/cwMidiDecls.h
index 9746385..b282ccc 100644
--- a/cwMidiDecls.h
+++ b/cwMidiDecls.h
@@ -14,10 +14,10 @@ namespace cw
       uint8_t  d0;      // midi data byte 0
       uint8_t  d1;      // midi data byte 1
     } msg_t;
-
+    
     typedef struct packet_str
     {
-      void*         cbArg; // Application supplied reference value
+      //void*         cbArg; // Application supplied reference value
       unsigned      devIdx;    // The device the msg originated from
       unsigned      portIdx;   // The port index on the source device
       msg_t*        msgArray;  // Pointer to an array of 'msgCnt' mdMsg records or NULL if sysExMsg is non-NULL
@@ -25,8 +25,19 @@ namespace cw
       unsigned      msgCnt;    // Count of mdMsg records or sys-ex bytes
     } packet_t;
 
-    typedef void (*cbFunc_t)( const packet_t* pktArray, unsigned pktCnt );
+    typedef void (*cbFunc_t)( void* cbArg, const packet_t* pktArray, unsigned pktCnt );
 
+    typedef struct ch_msg_str
+    {
+      time::spec_t timeStamp;
+      unsigned     devIdx;      // The device the msg originated from
+      unsigned     portIdx;     // The port index on the source device
+      unsigned     uid;         // application specified id
+      uint8_t      ch;          // midi channel
+      uint8_t      status;      // midi status byte (channel has been removed)
+      uint8_t      d0;          // midi data byte 0
+      uint8_t      d1;          // midi data byte 1
+    } ch_msg_t;
   }
 }
 #endif
diff --git a/cwMidiDevice.cpp b/cwMidiDevice.cpp
index d487eb9..f36845d 100644
--- a/cwMidiDevice.cpp
+++ b/cwMidiDevice.cpp
@@ -29,7 +29,7 @@ namespace cw
         kPausedStateId,
         kPlayingStateId
       } transportStateId_t;
-      
+
       typedef struct device_str
       {
         cbFunc_t cbFunc;
@@ -54,6 +54,11 @@ namespace cw
         unsigned long long offset_micros;
         unsigned long long last_posn_micros;
         time::spec_t       start_time;
+
+        ch_msg_t* buf;
+        unsigned  bufN;
+        std::atomic<unsigned>  buf_ii;
+        std::atomic<unsigned>  buf_oi;
         
       } device_t;
 
@@ -101,9 +106,12 @@ namespace cw
           rc = cwLogError(rc,"MIDI port thread destroy failed.");
           goto errLabel;
         }
+
         
         destroy(p->alsaDevH);
         destroy(p->fileDevH);
+
+        mem::release(p->buf);
         mem::release(p);
 
       errLabel:
@@ -173,6 +181,45 @@ namespace cw
         return true;
       }
 
+      void _callback( void* cbArg, const packet_t* pktArray, unsigned pktCnt )
+      {
+        device_t* p = (device_t*)cbArg;
+        
+        for(unsigned i=0; i<pktCnt; ++i)
+        {
+          const packet_t* pkt = pktArray + i;
+          if( pkt->msgArray != nullptr )
+          {
+            unsigned ii = p->buf_ii.load();
+            unsigned oi = p->buf_oi.load();
+            for(unsigned j=0;  j<pkt->msgCnt; ++j)
+            {
+              ch_msg_t* m = p->buf + ii;
+              m->devIdx    = pkt->devIdx;
+              m->portIdx   = pkt->portIdx;
+              m->timeStamp = pkt->msgArray[j].timeStamp;
+              m->uid       = pkt->msgArray[j].uid;
+              m->ch        = pkt->msgArray[j].ch;
+              m->status    = pkt->msgArray[j].status;
+              m->d0        = pkt->msgArray[j].d0;
+              m->d1        = pkt->msgArray[j].d1;
+
+              ii = (ii+1 == p->bufN ? 0 : ii+1);
+              if( ii == oi )
+              {
+                cwLogError(kBufTooSmallRC,"The MIDI device buffer is full %i.",p->bufN);
+              }
+            }
+
+            p->buf_ii.store(ii);
+            
+          }
+        }
+
+        if( p->cbFunc != nullptr )
+          p->cbFunc(p->cbArg,pktArray,pktCnt);
+      }
+
       
     } // device
   } // midi
@@ -188,7 +235,9 @@ cw::rc_t cw::midi::device::create( handle_t&   hRef,
                                    const char* appNameStr,
                                    const char* fileDevName,
                                    unsigned    fileDevReadAheadMicros,
-                                   unsigned    parserBufByteCnt )
+                                   unsigned    parserBufByteCnt,
+                                   bool        enableBufFl,
+                                   unsigned    bufferMsgCnt )
 {
   rc_t rc  = kOkRC;
   rc_t rc1 = kOkRC;  
@@ -198,7 +247,11 @@ cw::rc_t cw::midi::device::create( handle_t&   hRef,
 
   device_t* p = mem::allocZ<device_t>();
   
-  if((rc = create( p->alsaDevH, cbFunc, cbArg, parserBufByteCnt, appNameStr )) != kOkRC )
+  if((rc = create( p->alsaDevH,
+                   enableBufFl ? _callback : cbFunc,
+                   enableBufFl ? p         : cbArg,
+                   parserBufByteCnt,
+                   appNameStr )) != kOkRC )
   {
     rc = cwLogError(rc,"ALSA MIDI device create failed.");
     goto errLabel;
@@ -206,16 +259,29 @@ cw::rc_t cw::midi::device::create( handle_t&   hRef,
 
   p->alsa_dev_cnt = count(p->alsaDevH);
 
-  if((rc = create( p->fileDevH, cbFunc, cbArg, p->alsa_dev_cnt, filePortLabelA, max_file_cnt, fileDevName, fileDevReadAheadMicros )) != kOkRC )
+  if((rc = create( p->fileDevH,
+                   enableBufFl ? _callback : cbFunc,
+                   enableBufFl ? p         : cbArg,
+                   p->alsa_dev_cnt,
+                   filePortLabelA,
+                   max_file_cnt,
+                   fileDevName,
+                   fileDevReadAheadMicros )) != kOkRC )
   {
     rc = cwLogError(rc,"MIDI file device create failed.");
     goto errLabel;
   }
 
+  p->cbFunc        = cbFunc;
+  p->cbArg         = cbArg;
   p->file_dev_cnt  = count(p->fileDevH);    
   p->total_dev_cnt = p->alsa_dev_cnt + p->file_dev_cnt;
   p->alsaPollfdA   = pollFdArray(p->alsaDevH,p->alsaPollfdN);
   p->fileDevStateId = kStoppedStateId;
+  p->buf            = mem::allocZ<ch_msg_t>( bufferMsgCnt );
+  p->bufN           = bufferMsgCnt;
+  p->buf_ii.store(0);
+  p->buf_oi.store(0);
   
   if((rc = thread::create(p->threadH,
                           _thread_func,
@@ -257,6 +323,8 @@ cw::rc_t cw::midi::device::create( handle_t&       h,
   const char*     fileDevName            = "file_dev";
   unsigned        fileDevReadAheadMicros = 3000;
   unsigned        parseBufByteCnt        = 1024;
+  bool            enableBufFl            = false;
+  unsigned        bufMsgCnt              = 0;
   const object_t* file_ports             = nullptr;
   const object_t* port                   = nullptr;
 
@@ -264,6 +332,8 @@ cw::rc_t cw::midi::device::create( handle_t&       h,
                       "fileDevName",fileDevName,
                       "fileDevReadAheadMicros",fileDevReadAheadMicros,
                       "parseBufByteCnt",parseBufByteCnt,
+                      "enableBufFl",enableBufFl,
+                      "bufferMsgCnt",bufMsgCnt,
                       "file_ports",file_ports)) != kOkRC )
   {
     rc = cwLogError(rc,"MIDI port parse args. failed.");
@@ -290,7 +360,7 @@ cw::rc_t cw::midi::device::create( handle_t&       h,
       }
     }
     
-    rc = create(h,cbFunc,cbArg,labelArray,fpi,appNameStr,fileDevName,fileDevReadAheadMicros,parseBufByteCnt);
+    rc = create(h,cbFunc,cbArg,labelArray,fpi,appNameStr,fileDevName,fileDevReadAheadMicros,parseBufByteCnt,enableBufFl,bufMsgCnt);
     
   }
   
@@ -437,15 +507,15 @@ const char* cw::midi::device::portName(   handle_t h, unsigned devIdx, unsigned
   const char* name       = nullptr;
 
   if((alsaDevIdx   = _devIdxToAlsaDevIdx(p,devIdx)) != kInvalidIdx )
-    name           = portName(p->alsaDevH,alsaDevIdx,flags,portIdx);
+    name = portName(p->alsaDevH,alsaDevIdx,flags,portIdx);
   else
     if((fileDevIdx = _devIdxToFileDevIdx(p,devIdx)) != kInvalidIdx )
-      name         = portName(p->fileDevH,fileDevIdx,flags,portIdx);
+      name = portName(p->fileDevH,fileDevIdx,flags,portIdx);
     else
       cwLogError(kInvalidArgRC,"The device index %i is not valid.");
 
   if( name == nullptr )
-    cwLogError(kOpFailRC,"The access to port name on device index %i port index %i failed.",devIdx,portIdx);
+    cwLogError(kOpFailRC,"The access to %s port name on device index %i port index %i failed.",flags & kInMpFl ? "input" : "output", devIdx,portIdx);
 
   return name;  
 }
@@ -573,7 +643,7 @@ errLabel:
 cw::rc_t cw::midi::device::setEndMsg( handle_t h, unsigned devIdx, unsigned portIdx, unsigned msgIdx )
 {
   rc_t      rc = kOkRC;
-  device_t* p          = _handleToPtr(h);
+  device_t* p  = _handleToPtr(h);
   
   if(_devIdxToFileDevIdx(p,devIdx) == kInvalidIdx )
   {
@@ -591,6 +661,43 @@ errLabel:
 }
 
 
+unsigned cw::midi::device::maxBufferMsgCount( handle_t h )
+{
+  device_t* p  = _handleToPtr(h);
+  return p->bufN;
+}
+
+const cw::midi::ch_msg_t* cw::midi::device::getBuffer(   handle_t h, unsigned& msgCntRef )
+{
+  device_t* p  = _handleToPtr(h);
+  unsigned  ii = p->buf_ii.load();
+  unsigned  oi = p->buf_oi.load();
+  ch_msg_t* m  = nullptr;
+  
+  msgCntRef  = ii >= oi ? ii-oi : p->bufN - oi;
+  
+  if( msgCntRef > 0 )
+    m = p->buf + oi;
+  
+  return m;
+}
+
+cw::rc_t            cw::midi::device::clearBuffer( handle_t h, unsigned msgCnt )
+{
+  if( msgCnt > 0 )
+  {
+    device_t* p  = _handleToPtr(h);
+    unsigned oi = p->buf_oi.load();
+    
+    oi = (oi + msgCnt) % p->bufN;
+  
+    p->buf_oi.store(oi);
+  }
+  
+  return kOkRC;
+}
+
+
 cw::rc_t cw::midi::device::start( handle_t h )
 {
   rc_t rc = kOkRC;
@@ -668,6 +775,8 @@ cw::rc_t cw::midi::device::report( handle_t h )
     goto errLabel;
 
   report(h,tbH);
+
+  printf("%s\n",text(tbH));
   
 errLabel:
   destroy(tbH);
diff --git a/cwMidiDevice.h b/cwMidiDevice.h
index 6c8b16d..237052f 100644
--- a/cwMidiDevice.h
+++ b/cwMidiDevice.h
@@ -30,7 +30,9 @@ namespace cw
                    const char* appNameStr,
                    const char* fileDevName = "file_dev",
                    unsigned    fileDevReadAheadMicros = 3000,
-                   unsigned    parserBufByteCnt = 1024  );
+                   unsigned    parserBufByteCnt = 1024,
+                   bool        enableBufFl = false,   // Enable buffer to hold all incoming msg's until RT thread can pick them up.
+                   unsigned    bufferMsgCnt = 4096);  // Count of messages in input buffer.
 
       rc_t create( handle_t&       h,
                    cbFunc_t        cbFunc,
@@ -47,7 +49,7 @@ namespace cw
       const char* portName(   handle_t h, unsigned devIdx, unsigned flags, unsigned portIdx );
       unsigned    portNameToIndex( handle_t h, unsigned devIdx, unsigned flags, const char* portName );
       rc_t        portEnable(      handle_t h, unsigned devIdx, unsigned flags, unsigned portIdx, bool enableFl );
-      
+
       rc_t        send(       handle_t h, unsigned devIdx, unsigned portIdx, uint8_t st, uint8_t d0, uint8_t d1 );
       rc_t        sendData(   handle_t h, unsigned devIdx, unsigned portIdx, const uint8_t* dataPtr, unsigned byteCnt );
 
@@ -57,6 +59,10 @@ namespace cw
       rc_t        seekToMsg(    handle_t h, unsigned devIdx, unsigned portIdx, unsigned msgIdx );
       rc_t        setEndMsg(    handle_t h, unsigned devIdx, unsigned portidx, unsigned msgIdx );
 
+      unsigned        maxBufferMsgCount( handle_t h ); // max number of msg's which will ever be returned in a buffer
+      const ch_msg_t* getBuffer(   handle_t h, unsigned& msgCntRef );
+      rc_t            clearBuffer( handle_t h, unsigned msgCnt );
+
       rc_t start( handle_t h );
       rc_t stop( handle_t h );
       rc_t pause( handle_t h, bool pause_fl );

From 3526b2c8074e9519342a3672d56335c82136aeab Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 6 Apr 2024 16:02:52 -0400
Subject: [PATCH 017/101] cwMidiAlsa.cpp : Ports that do not qualify based on
 READ/WRITE attributes are now dropped. Ports without names are now given the
 default name '<None>'.

---
 cwMidiAlsa.cpp | 45 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/cwMidiAlsa.cpp b/cwMidiAlsa.cpp
index cc969a7..bc33b7f 100644
--- a/cwMidiAlsa.cpp
+++ b/cwMidiAlsa.cpp
@@ -283,6 +283,7 @@ namespace cw
               time::spec_t ts;
               ts.tv_sec = ev->time.time.tv_sec;
               ts.tv_nsec = ev->time.time.tv_nsec;
+
               parser::midiTriple(p->prvRcvPort->parserH, &ts, status | ch, d0, d1 );
 
               p->prvTimeMicroSecs  = microSecs1;
@@ -439,7 +440,7 @@ namespace cw
               {
                 assert(j<p->devArray[i].iPortCnt);
                 p->devArray[i].iPortArray[j].inputFl   = true;
-                p->devArray[i].iPortArray[j].nameStr   = mem::duplStr(cwStringNullGuard(port));
+                p->devArray[i].iPortArray[j].nameStr   = mem::duplStr(port==nullptr ? "<None>" : port);
                 p->devArray[i].iPortArray[j].alsa_type = type;
                 p->devArray[i].iPortArray[j].alsa_cap  = caps;
                 p->devArray[i].iPortArray[j].alsa_addr = addr;
@@ -461,7 +462,7 @@ namespace cw
               {
                 assert(k<p->devArray[i].oPortCnt);
                 p->devArray[i].oPortArray[k].inputFl   = false;
-                p->devArray[i].oPortArray[k].nameStr   = mem::duplStr(cwStringNullGuard(port));
+                p->devArray[i].oPortArray[k].nameStr   = mem::duplStr(port==nullptr ? "<None>" : port);
                 p->devArray[i].oPortArray[k].alsa_type = type;
                 p->devArray[i].oPortArray[k].alsa_cap  = caps;
                 p->devArray[i].oPortArray[k].alsa_addr = addr;
@@ -475,6 +476,11 @@ namespace cw
                 ++k;
               }
             }
+
+            // The capabilities of some ports may not have been as expected
+            // decrease the in/out port count to account for these ports
+            p->devArray[i].iPortCnt = j;
+            p->devArray[i].oPortCnt = k;
           }
 
         errLabel:
@@ -736,7 +742,7 @@ const char*    cw::midi::device::alsa::portName(   handle_t h, unsigned devIdx,
   if( cwIsFlag(flags,kInMpFl) )
   {
     if( portIdx >= p->devArray[devIdx].iPortCnt )
-      return 0;
+      return nullptr;
 
     return p->devArray[devIdx].iPortArray[portIdx].nameStr;
   }
@@ -782,7 +788,7 @@ cw::rc_t  cw::midi::device::alsa::send( handle_t h, unsigned devIdx, unsigned po
   rc_t            rc = kOkRC;
   snd_seq_event_t ev;
   int             arc;
-  alsa_device_t*       p  = _handleToPtr(h);
+  alsa_device_t*  p  = _handleToPtr(h);
 
   assert( p!=NULL && devIdx < p->devCnt && portIdx < p->devArray[devIdx].oPortCnt );
 
@@ -796,8 +802,11 @@ cw::rc_t  cw::midi::device::alsa::send( handle_t h, unsigned devIdx, unsigned po
   snd_seq_ev_set_direct(&ev);
   snd_seq_ev_set_fixed(&ev);
 
+  uint8_t status_wo_ch = status;
+  if( midi::isChStatus(status) )
+    status_wo_ch = status & 0xf0;
   
-  switch( status & 0xf0 )
+  switch( status_wo_ch )
   {
     case kNoteOffMdId:  
       ev.type = SND_SEQ_EVENT_NOTEOFF;    
@@ -854,8 +863,32 @@ cw::rc_t  cw::midi::device::alsa::send( handle_t h, unsigned devIdx, unsigned po
       }
       break;
 
+    case kSysRtClockMdId:
+      ev.type = SND_SEQ_EVENT_CLOCK;
+      break;
+
+    case kSysRtStartMdId:
+      ev.type =SND_SEQ_EVENT_START;
+      break;
+
+    case kSysRtContMdId:
+      ev.type = SND_SEQ_EVENT_CONTINUE;
+      break;
+
+    case kSysRtStopMdId:
+      ev.type = SND_SEQ_EVENT_STOP;
+      break;
+
+    case kSysRtSenseMdId:
+      ev.type = SND_SEQ_EVENT_SENSING;
+      break;
+
+    case kSysRtResetMdId:
+      ev.type = SND_SEQ_EVENT_RESET;
+      break;      
+
     default:
-      rc = _cmMpErrMsg1(kInvalidArgRC,0,"Cannot send an invalid MIDI status byte:0x%x.",status & 0xf0);
+      rc = _cmMpErrMsg1(kInvalidArgRC,0,"Cannot send an invalid MIDI status byte:0x%x.",status);
       goto errLabel;
   }
 

From 374d3ad8a8f5a1e88ccd3110842257e4575697f0 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 6 Apr 2024 16:04:42 -0400
Subject: [PATCH 018/101] 
 cwMidiDeviceTest.cpp,cwMidiFileDev.cpp,cwMidiParser.cpp : Updates to account
 for change of MIDI callback signature in cwMidiDecls.h.

---
 cwMidiDeviceTest.cpp |  4 ++--
 cwMidiFileDev.cpp    |  3 +--
 cwMidiParser.cpp     | 17 +++++++++++++----
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/cwMidiDeviceTest.cpp b/cwMidiDeviceTest.cpp
index 75049e4..174dcd3 100644
--- a/cwMidiDeviceTest.cpp
+++ b/cwMidiDeviceTest.cpp
@@ -86,7 +86,7 @@ namespace cw
         return kOkRC;
       }
       
-      void _test_callback( const packet_t* pktArray, unsigned pktCnt )
+      void _test_callback( void* cbArg, const packet_t* pktArray, unsigned pktCnt )
       {
         unsigned i,j;
         time::spec_t cur_time = time::current_time();
@@ -95,7 +95,7 @@ namespace cw
         {
           const packet_t* p = pktArray + i;
 
-          test_t* t = (test_t*)p->cbArg;
+          test_t* t = (test_t*)cbArg;
 
           for(j=0; j<p->msgCnt; ++j)
             if( p->msgArray != NULL )
diff --git a/cwMidiFileDev.cpp b/cwMidiFileDev.cpp
index ba4a064..9978e87 100644
--- a/cwMidiFileDev.cpp
+++ b/cwMidiFileDev.cpp
@@ -428,13 +428,12 @@ namespace cw
           if( p->cbFunc != nullptr )
           {
             packet_t pkt = {};
-            pkt.cbArg    = p->cbArg;
             pkt.devIdx   = p->base_dev_idx;
             pkt.portIdx  = file_idx;
             pkt.msgArray = msgA;
             pkt.msgCnt   = msgN;
             
-            p->cbFunc( &pkt, 1 );
+            p->cbFunc( p->cbArg, &pkt, 1 );
           }
         }
 
diff --git a/cwMidiParser.cpp b/cwMidiParser.cpp
index cfb0bb0..0ea317d 100644
--- a/cwMidiParser.cpp
+++ b/cwMidiParser.cpp
@@ -58,8 +58,8 @@ namespace cw
         cbRecd_t* c = p->cbChain;
         for(; c!=NULL; c=c->linkPtr)
         {
-          pkt->cbArg = c->cbDataPtr;
-          c->cbFunc( pkt, pktCnt );
+          //pkt->cbArg = c->cbDataPtr;
+          c->cbFunc( c->cbDataPtr, pkt, pktCnt );
         }
       }
 
@@ -102,10 +102,19 @@ namespace cw
         // get a pointer to the next msg in the buffer
         msg_t* msgPtr = (msg_t*)(p->buf + p->bufIdx);
 
+        if( midi::isChStatus(p->status) )
+        {
+          msgPtr->status  = p->status & 0xf0;
+          msgPtr->ch      = p->status & 0x0f;
+        }
+        else
+        {
+          msgPtr->status  = p->status;
+          msgPtr->ch      = 0;          
+        }
+
         // fill the buffer msg
         msgPtr->timeStamp = *timeStamp;
-        msgPtr->status  = p->status & 0xf0;
-        msgPtr->ch      = p->status & 0x0f;
         msgPtr->uid     = kInvalidId;
 
         switch( p->dataCnt )

From c4d518db47d0a4d51f97deead98e5ae180356bb3 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 6 Apr 2024 16:06:17 -0400
Subject: [PATCH 019/101] cwIo.h,cpp : Updates to include cwMidiDevice input
 device buffer. Added hardwareReport(). Updates to account for change to
 midi::cbFunc_t.

---
 cwIo.cpp | 37 +++++++++++++++++++++++++++++++++----
 cwIo.h   |  7 +++++++
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/cwIo.cpp b/cwIo.cpp
index 5a0ebc5..fa2d66e 100644
--- a/cwIo.cpp
+++ b/cwIo.cpp
@@ -611,7 +611,7 @@ namespace cw
     //
     // MIDI
     //
-    void _midiCallback( const midi::packet_t* pktArray, unsigned pktCnt )
+    void _midiCallback( void* cbArg, const midi::packet_t* pktArray, unsigned pktCnt )
     {
       unsigned i;
       for(i=0; i<pktCnt; ++i)
@@ -619,7 +619,7 @@ namespace cw
         msg_t                 m;
         midi_msg_t            mm;
         const midi::packet_t* pkt = pktArray + i;        
-        io_t*                 p   = reinterpret_cast<io_t*>(pkt->cbArg);
+        io_t*                 p   = reinterpret_cast<io_t*>(cbArg);
         rc_t                  rc  = kOkRC;
 
         
@@ -2114,10 +2114,12 @@ namespace cw
         rc = cwLogError(rc,"Audio device configuration failed.");
         goto errLabel;
       }
-
-      audio::device::report( p->audioH );
       
     errLabel:
+
+      if( rc != kOkRC && p->audioH.isValid()  )
+        audio::device::report( p->audioH );
+      
       return rc;
     }
 
@@ -2495,6 +2497,15 @@ void cw::io::report( handle_t h )
     printf("audio: %s\n", cwStringNullGuard(audioDeviceName(h,i)));  
 }
 
+
+void cw::io::hardwareReport( handle_t h )
+{
+  io_t* p = _handleToPtr(h);
+  audio::device::report( p->audioH );
+  midi::device::report(p->midiH);  
+}
+
+
 void cw::io::realTimeReport( handle_t h )
 {
   io_t* p = _handleToPtr(h);
@@ -2749,6 +2760,24 @@ cw::rc_t cw::io::midiDeviceSend( handle_t h, unsigned devIdx, unsigned portIdx,
   return midi::device::send( p->midiH, devIdx, portIdx, status, d0, d1 );
 }
 
+unsigned cw::io::midiDeviceMaxBufferMsgCount( handle_t h )
+{
+  io_t* p = _handleToPtr(h);
+  return midi::device::maxBufferMsgCount(p->midiH );
+}
+
+const cw::midi::ch_msg_t* cw::io::midiDeviceBuffer(      handle_t h, unsigned& msgCntRef )
+{
+  io_t* p = _handleToPtr(h);
+  return midi::device::getBuffer(p->midiH, msgCntRef );
+}
+
+cw::rc_t                  cw::io::midiDeviceClearBuffer( handle_t h, unsigned msgCnt )
+{
+  io_t* p = _handleToPtr(h);
+  return midi::device::clearBuffer(p->midiH, msgCnt );
+}
+
 cw::rc_t  cw::io::midiOpenMidiFile( handle_t h, unsigned devIdx, unsigned portIdx, const char* fname )
 {
   return midi::device::openMidiFile( _handleToPtr(h)->midiH, devIdx, portIdx, fname );
diff --git a/cwIo.h b/cwIo.h
index ec4a8e1..9251dac 100644
--- a/cwIo.h
+++ b/cwIo.h
@@ -172,7 +172,9 @@ namespace cw
     
     bool isShuttingDown( handle_t h );
     void report( handle_t h );
+    void hardwareReport( handle_t h );
     void realTimeReport( handle_t h );
+    
 
     //----------------------------------------------------------------------------------------------------------
     //
@@ -229,6 +231,11 @@ namespace cw
     const char* midiDevicePortName(  handle_t h, unsigned devIdx, bool inputFl, unsigned portIdx );
     unsigned    midiDevicePortIndex( handle_t h, unsigned devIdx, bool inputFl, const char* portName );    
     rc_t        midiDeviceSend(      handle_t h, unsigned devIdx, unsigned portIdx, uint8_t status, uint8_t d0, uint8_t d1 );
+
+    unsigned              midiDeviceMaxBufferMsgCount( handle_t h );
+    const midi::ch_msg_t* midiDeviceBuffer(      handle_t h, unsigned& msgCntRef );
+    rc_t                  midiDeviceClearBuffer( handle_t h, unsigned msgCnt ); 
+
     
     rc_t        midiOpenMidiFile(    handle_t h, unsigned devIdx, unsigned portIdx, const char* fname );
     rc_t        midiLoadMsgPacket(   handle_t h, const midi::packet_t& pkt ); // Note: Set devIdx/portIdx via pkt.devIdx/pkt.portIdx

From e49df496e6d861fe54c486ef94a34d427050fc12 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 6 Apr 2024 16:07:46 -0400
Subject: [PATCH 020/101] cwFlow* : Added MIDI input and output devices to
 'flow' framework.

---
 cwFlow.cpp      |  24 ++++-
 cwFlow.h        |  31 +++++-
 cwFlowCross.cpp |  66 ++++++++++---
 cwFlowProc.cpp  | 251 ++++++++++++++++++++++++++++++++++++++++++++++++
 cwFlowProc.h    |   2 +
 cwFlowTypes.cpp | 135 +++++++++++++++++++++++---
 cwFlowTypes.h   |  60 +++++++-----
 cwIoFlow.cpp    |  80 ++++++++++++---
 8 files changed, 577 insertions(+), 72 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index 09a1e6e..8f61939 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -8,6 +8,8 @@
 #include "cwVectOps.h"
 #include "cwMtx.h"
 #include "cwDspTypes.h" // real_t, sample_t
+#include "cwTime.h"
+#include "cwMidiDecls.h"
 #include "cwFlowDecl.h"
 #include "cwFlow.h"
 #include "cwFlowTypes.h"
@@ -24,6 +26,8 @@ namespace cw
     } library_t;
     
     library_t g_library[] = {
+      { "midi_in",         &midi_in::members },
+      { "midi_out",        &midi_out::members },
       { "audio_in",        &audio_in::members },
       { "audio_out",       &audio_out::members },
       { "audioFileIn",     &audioFileIn::members },
@@ -292,7 +296,7 @@ namespace cw
 
       if( src_var->value == nullptr )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The source value is null on the connection input:%s %s source:%s %s .", in_inst->label, in_var_label, src_inst->label, suffix);
+        rc = cwLogError(kSyntaxErrorRC,"The source value is null on the connection input:'%s' %s source:'%s' '%s' .", in_inst->label, in_var_label, src_inst->label, suffix);
         goto errLabel;
       }
 
@@ -1549,7 +1553,7 @@ void cw::flow::print_abuf( const abuf_t* abuf )
 
 void cw::flow::print_external_device( const external_device_t* dev )
 {
-  printf("Dev: %10s id:%3i type:%3i fl:0x%x : ", cwStringNullGuard(dev->label),dev->ioDevId,dev->typeId,dev->flags);
+  printf("Dev: %10s type:%3i fl:0x%x : ", cwStringNullGuard(dev->devLabel),dev->typeId,dev->flags);
   if( dev->typeId == kAudioDevTypeId )
     print_abuf(dev->u.a.abuf);
   printf("\n");
@@ -1603,6 +1607,19 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
     goto errLabel;
   }
 
+  for(unsigned i=0; i<deviceN; ++i)
+    if( deviceA[i].typeId == kAudioDevTypeId )
+    {
+      if( deviceA[i].u.a.abuf == NULL )
+      {
+        rc = cwLogError(kInvalidArgRC,"The audio '%s' device does not have a valid audio buffer.",cwStringNullGuard(deviceA[i].devLabel));
+        goto errLabel;
+      }
+      else
+        if( deviceA[i].u.a.abuf->frameN != p->framesPerCycle )
+          cwLogWarning("The audio frame count (%i) for audio device '%s' does not match the Flow framesPerCycle (%i).",deviceA[i].u.a.abuf->frameN,p->framesPerCycle);
+    }
+  
   // print the class dict
   if( printClassDictFl )
       class_dict_print( p );
@@ -1692,7 +1709,10 @@ cw::rc_t cw::flow::exec(    handle_t h )
     
     p->cycleIndex += 1;
     if( p->maxCycleCount > 0 && p->cycleIndex >= p->maxCycleCount )
+    {
+       cwLogInfo("'maxCycleCnt' reached: %i. Shutting down flow.",p->maxCycleCount);
       break;
+    }
   }
 
   return rc;
diff --git a/cwFlow.h b/cwFlow.h
index d45df47..945840b 100644
--- a/cwFlow.h
+++ b/cwFlow.h
@@ -31,17 +31,38 @@ namespace cw
                               // The audio_in/audio_out proc's locate and use these buffers.
     } audio_dev_cfg_t;
 
+    struct external_device_str;
+    
+    typedef rc_t (*send_midi_triple_func_t)( struct external_device_str* dev, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 );
+    
+    typedef struct midi_dev_cfg_str
+    {
+      // msgArray[] contains the current msgs for all devices NOT just the device that this record is embedded in.
+      // We do this so that the order of messages as they arrived is maintained.  Otherwise, to achieve this ordering,
+      // the messages for all devices would need to be collected and sorted by time.
+      const midi::ch_msg_t*   msgArray;  
+      unsigned                msgCnt;
+
+      unsigned                maxMsgCnt; // max possible value of msgCnt
+      send_midi_triple_func_t sendTripleFunc;
+    } midi_dev_cfg_t;
+
     // Generate external device record
     typedef struct external_device_str
     {
-      const char* label;   // IO framework device label
-      unsigned    ioDevId; // IO framework device id
-      unsigned    typeId;  // see ???DevTypeId above
-      unsigned    flags;   // see ???Fl above
+      void*       reserved;
+      const char* devLabel;   // IO framework device label
+      const char* portLabel;  // IO framework MIDI port label (only used by MIDI devices)
+      unsigned    typeId;     // see ???DevTypeId above
+      unsigned    flags;      // see ???Fl above
+      
+      unsigned    ioDevIdx;   // IO framework device index
+      unsigned    ioPortIdx;  // IO framework MIDI port index (only used by MIDI devices)
       
       union
       {
-        audio_dev_cfg_t a; // audio devices include this additional record
+        audio_dev_cfg_t a; // audio devices use this record
+        midi_dev_cfg_t  m; // MIDI     "     "   "     " 
       } u;
         
     } external_device_t;
diff --git a/cwFlowCross.cpp b/cwFlowCross.cpp
index 2839273..c47afc7 100644
--- a/cwFlowCross.cpp
+++ b/cwFlowCross.cpp
@@ -9,6 +9,8 @@
 #include "cwMtx.h"
 #include "cwDspTypes.h" // real_t, sample_t
 #include "cwDspTransforms.h"
+#include "cwTime.h"
+#include "cwMidiDecls.h"
 #include "cwFlowDecl.h"
 #include "cwFlow.h"
 #include "cwFlowTypes.h"
@@ -28,14 +30,15 @@ namespace cw
       kFadeOutStateId,
     };
 
+    // Each duplicated network is represented by a flow_netword_t record in flow_cross_t.netA[].
     typedef struct flow_network_str
     {
       dsp::recorder::obj_t*     recorder;
       
-      flow::external_device_t* deviceA;
+      flow::external_device_t* deviceA;  // deviceA[ deviceN ] - cloned exteranl device array
       unsigned                 deviceN;
-      flow::handle_t           flowH;
-      
+      flow::handle_t           flowH; 
+
       unsigned                 stateId;   // inactive, fade-in, fade-out
       double                   fadeGain;  //    0        0->1     1->0
       unsigned                 fadeSmpN;  //
@@ -47,7 +50,7 @@ namespace cw
     
     typedef struct flow_cross_str
     {
-      unsigned cur_idx;
+      unsigned cur_idx;  // index of the network currently receiving parameter updates 
       double   srate;
       
       unsigned        netN;
@@ -106,8 +109,21 @@ namespace cw
       memcpy(devA,srcDevA,devN * sizeof(flow::external_device_t));
       
       for(unsigned i=0; i<devN; ++i)
-        if( devA[i].typeId == flow::kAudioDevTypeId )
-          devA[i].u.a.abuf = _clone_abuf( srcDevA[i].u.a.abuf );
+      {
+        switch( devA[i].typeId )
+        {
+          case flow::kAudioDevTypeId:
+            devA[i].u.a.abuf = _clone_abuf( srcDevA[i].u.a.abuf );
+            break;
+
+          case flow::kMidiDevTypeId:
+            devA[i].u.m = srcDevA[i].u.m;
+            break;
+
+          default:
+            break;
+        }
+      }
       
       return devA;
     }
@@ -203,9 +219,20 @@ namespace cw
       
       if( net->stateId == kFadeOutStateId && ef == 0.0 )
         net->stateId = kInactiveStateId;
-      
     }
 
+    // Copy audio from the actual external audio device to a cloned audio device
+    void _update_midi_input( flow_cross_t* p, flow_network_t* net, unsigned devIdx )
+    {
+      flow::midi_dev_cfg_t& src = p->deviceA[devIdx].u.m;    // src MIDI device
+      flow::midi_dev_cfg_t& dst = net->deviceA[devIdx].u.m;  // dst MIDI device clone
+
+      // redirect the MIDI msg list array to the clones
+      dst.msgArray = src.msgArray; 
+      dst.msgCnt   = src.msgCnt;
+    }
+    
+    // Copy audio from the actual external audio device to a cloned audio device
     void _update_audio_input( flow_cross_t* p, flow_network_t* net, unsigned devIdx )
     {
       flow::abuf_t* src = p->deviceA[devIdx].u.a.abuf;
@@ -216,6 +243,7 @@ namespace cw
       //_fade_audio( src, dst, net );
     }
 
+    
     void _zero_audio_output( flow_cross_t* p, flow_network_t* net, unsigned devIdx )
     {
       flow::abuf_t* dst = net->deviceA[devIdx].u.a.abuf;
@@ -378,13 +406,27 @@ cw::rc_t cw::flow_cross::exec_cycle( handle_t h )
   {
     flow_network_t* net = p->netA + i;
 
-    // We generally don't want to fade the input because the state
-    // of the network delay lines would then be invalid when the
-    // network is eventually made active again 
     for(unsigned j=0; j<p->deviceN; ++j)
-      if( p->deviceA[j].typeId == flow::kAudioDevTypeId && cwIsFlag(p->deviceA[j].flags, flow::kInFl ) )
-        _update_audio_input( p, p->netA + i, j );
+      if( cwIsFlag(p->deviceA[j].flags, flow::kInFl ) )        
+      {
+        switch( p->deviceA[j].typeId)
+        {
+          case flow::kAudioDevTypeId:
+            // We generally don't want to fade the input because the state
+            // of the network delay lines would then be invalid when the
+            // network is eventually made active again 
+                        
+            // copy audio from the actual audio device to the cloned audio devices
+            _update_audio_input( p, p->netA + i, j );
+            break;
 
+          case flow::kMidiDevTypeId:
+            // update the cloned MIDI devices from the master device
+            _update_midi_input( p, p->netA + i, j );          
+
+      }
+    }
+    
     // zero the audio device output buffers because we are about to sum into them
     for(unsigned j=0; j<p->deviceN; ++j)
       if( p->deviceA[j].typeId == flow::kAudioDevTypeId && cwIsFlag(p->deviceA[j].flags, flow::kOutFl ) )
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 0e25254..5eff84e 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -2,12 +2,18 @@
 #include "cwLog.h"
 #include "cwCommonImpl.h"
 #include "cwMem.h"
+#include "cwText.h"
 #include "cwObject.h"
 #include "cwAudioFile.h"
 #include "cwVectOps.h"
 #include "cwMtx.h"
 
 #include "cwDspTypes.h" // real_t, sample_t
+
+#include "cwTime.h"
+#include "cwMidiDecls.h"
+
+
 #include "cwFlowDecl.h"
 #include "cwFlow.h"
 #include "cwFlowTypes.h"
@@ -164,6 +170,251 @@ namespace cw
       
     }    
 
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // midi_in
+    //
+    
+    namespace midi_in
+    {
+      enum
+      {
+        kDevLabelPId,
+        kPortLabelPId,
+        kOutPId
+      };
+      
+      typedef struct
+      {
+        midi::ch_msg_t*    buf;
+        unsigned           bufN;
+        bool               dev_filt_fl;
+        bool               port_filt_fl;        
+        external_device_t* ext_dev;
+      } inst_t;
+      
+      rc_t create( instance_t* ctx )
+      {
+        rc_t        rc         = kOkRC;
+        const char* dev_label  = nullptr;
+        const char* port_label = nullptr;        
+        inst_t*     inst       = mem::allocZ<inst_t>();
+        
+        ctx->userPtr = inst;
+
+        // Register variable and get their current value
+        if((rc = var_register_and_get( ctx, kAnyChIdx,
+                                       kDevLabelPId,  "dev_label",  dev_label,
+                                       kPortLabelPId, "port_label", port_label )) != kOkRC )
+          
+        {
+          goto errLabel;
+        }
+
+        if((rc = var_register( ctx, kAnyChIdx,kOutPId, "out")) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+
+        inst->dev_filt_fl = true;
+        inst->port_filt_fl = true;
+        
+        if( textIsEqual(dev_label,"<all>") )
+        {
+          inst->dev_filt_fl = false;
+          dev_label = nullptr;
+        }
+          
+        if( textIsEqual(dev_label,"<all>") )
+        {
+          inst->port_filt_fl = false;
+          port_label = nullptr;
+        }
+        
+        
+        
+        if((inst->ext_dev = external_device_find( ctx->ctx, dev_label, kMidiDevTypeId, kInFl, port_label )) == nullptr )
+        {
+          rc = cwLogError(kOpFailRC,"The MIDI input device '%s' port '%s' could not be found.", cwStringNullGuard(dev_label), cwStringNullGuard(port_label));
+          goto errLabel;
+        }
+
+        // Allocate a buffer large enough to hold the max. number of messages arriving on a single call to exec().
+        inst->bufN = inst->ext_dev->u.m.maxMsgCnt;
+        inst->buf = mem::allocZ<midi::ch_msg_t>( inst->bufN );
+
+        // create one output audio buffer
+        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, nullptr, 0  );
+
+
+      errLabel: 
+        return rc;
+      }
+
+      rc_t destroy( instance_t* ctx )
+      {
+        rc_t rc = kOkRC;
+
+        inst_t* inst = (inst_t*)ctx->userPtr;
+        mem::release(inst->buf);
+
+        mem::release(inst);
+        
+        return rc;
+      }
+
+      rc_t value( instance_t* ctx, variable_t* var )
+      { return kOkRC; }
+      
+      rc_t exec( instance_t* ctx )
+      {
+        rc_t     rc           = kOkRC;
+
+        inst_t*  inst         = (inst_t*)ctx->userPtr;
+        mbuf_t*  mbuf         = nullptr;
+
+
+        // get the output variable
+        if((rc = var_get(ctx,kOutPId,kAnyChIdx,mbuf)) != kOkRC )
+        {
+          rc = cwLogError(kInvalidStateRC,"The MIDI file instance '%s' does not have a valid MIDI output buffer.",ctx->label);
+        }
+        else
+        {
+          // if the device filter is not set
+          if( !inst->dev_filt_fl)
+          {
+            mbuf->msgA = inst->ext_dev->u.m.msgArray;
+            mbuf->msgN = inst->ext_dev->u.m.msgCnt;
+          }
+          else // the device filter is set
+          {
+            const midi::ch_msg_t* m = inst->ext_dev->u.m.msgArray;
+            unsigned j = 0;
+            for(unsigned i=0; i<inst->ext_dev->u.m.msgCnt && j<inst->bufN; ++i)
+              if( m->devIdx == inst->ext_dev->ioDevIdx && (!inst->port_filt_fl || m->portIdx == inst->ext_dev->ioPortIdx) )
+                inst->buf[j++] = m[i];
+
+            mbuf->msgN = j;
+            mbuf->msgA = inst->buf;
+          }
+
+          
+        }
+        
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }
+
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // midi_out
+    //
+    
+    namespace midi_out
+    {
+      enum
+      {
+        kInPId,
+        kDevLabelPId,
+        kPortLabelPId
+      };
+      
+      typedef struct
+      {
+        external_device_t* ext_dev;
+      } inst_t;
+      
+      rc_t create( instance_t* ctx )
+      {
+        rc_t        rc         = kOkRC; //
+        inst_t*     inst       = mem::allocZ<inst_t>(); //
+        const char* dev_label  = nullptr;
+        const char* port_label = nullptr;
+        mbuf_t*     mbuf       = nullptr;
+        
+        ctx->userPtr = inst;
+        
+        // Register variables and get their current value
+        if((rc = var_register_and_get( ctx, kAnyChIdx,
+                                       kDevLabelPId, "dev_label", dev_label,
+                                       kPortLabelPId,"port_label", port_label,
+                                       kInPId,       "in",         mbuf)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        if((inst->ext_dev = external_device_find( ctx->ctx, dev_label, kMidiDevTypeId, kOutFl, port_label )) == nullptr )
+        {
+          rc = cwLogError(kOpFailRC,"The audio output device description '%s' could not be found.", cwStringNullGuard(dev_label));
+          goto errLabel;
+        }        
+
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* ctx )
+      {
+        rc_t    rc   = kOkRC;
+        inst_t* inst = (inst_t*)ctx->userPtr;
+
+        mem::release(inst);
+
+        return rc;
+      }
+
+      rc_t value( instance_t* ctx, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        return rc;
+      }
+      
+      rc_t exec( instance_t* ctx )
+      {
+        rc_t          rc     = kOkRC;
+        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        const mbuf_t* src_mbuf = nullptr;
+
+        if((rc = var_get(ctx,kInPId,kAnyChIdx,src_mbuf)) != kOkRC )
+          rc = cwLogError(kInvalidStateRC,"The MIDI output instance '%s' does not have a valid input connection.",ctx->label);
+        else
+        {
+          for(unsigned i=0; i<src_mbuf->msgN; ++i)
+          {            
+            const midi::ch_msg_t* m = src_mbuf->msgA + i;
+            inst->ext_dev->u.m.sendTripleFunc( inst->ext_dev, m->ch, m->status, m->d0, m->d1 );
+          }
+        }
+        
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }
+
+
+
+    
     
     //------------------------------------------------------------------------------------------------------------------
     //
diff --git a/cwFlowProc.h b/cwFlowProc.h
index 15fee86..026bbed 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -2,6 +2,8 @@ namespace cw
 {
   namespace flow
   {
+    namespace midi_in         { extern class_members_t members;  }
+    namespace midi_out        { extern class_members_t members;  }
     namespace audio_in        { extern class_members_t members;  }
     namespace audio_out       { extern class_members_t members;  }
     namespace audioFileIn     { extern class_members_t members;  }
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 02ccf1f..477b5f1 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -7,6 +7,8 @@
 #include "cwVectOps.h"
 #include "cwMtx.h"
 #include "cwDspTypes.h" // real_t, sample_t
+#include "cwTime.h"
+#include "cwMidiDecls.h"
 #include "cwFlowDecl.h"
 #include "cwFlow.h"
 #include "cwFlowTypes.h"
@@ -18,21 +20,22 @@ namespace cw
   {
     idLabelPair_t typeLabelFlagsA[] = {
       
-      { kBoolTFl, "bool" },
-      { kUIntTFl, "uint" },
-      { kIntTFl,  "int", },
-      { kFloatTFl,  "float"},
-      { kRealTFl,   "real"},
-      { kDoubleTFl,  "double"},
+      { kBoolTFl,  "bool" },
+      { kUIntTFl,  "uint" },
+      { kIntTFl,   "int", },
+      { kFloatTFl, "float"},
+      { kRealTFl,  "real"},
+      { kDoubleTFl,"double"},
       
-      { kBoolMtxTFl, "bool_mtx" },
-      { kUIntMtxTFl, "uint_mtx" },
-      { kIntMtxTFl,  "int_mtx"  },
-      { kFloatMtxTFl,  "float_mtx" },
-      { kDoubleMtxTFl,  "double_mtx" },
+      { kBoolMtxTFl,  "bool_mtx" },
+      { kUIntMtxTFl,  "uint_mtx" },
+      { kIntMtxTFl,   "int_mtx"  },
+      { kFloatMtxTFl, "float_mtx" },
+      { kDoubleMtxTFl,"double_mtx" },
       
       { kABufTFl,   "audio" },
       { kFBufTFl,   "spectrum" },
+      { kMBufTFl,   "midi" },
       { kStringTFl, "string" },
       { kTimeTFl,   "time" },
       { kInvalidTFl, nullptr }
@@ -73,6 +76,9 @@ namespace cw
           fbuf_destroy( v->u.fbuf );
           break;
 
+        case kMBufTFl:
+          mbuf_destroy( v->u.mbuf );
+          break;
           
         case kBoolMtxTFl:
         case kUIntMtxTFl:
@@ -99,8 +105,7 @@ namespace cw
     }
 
     void _value_duplicate( value_t& dst, const value_t& src )
-    {
-        
+    {        
       switch( src.flags & kTypeMask )
       {
         case kInvalidTFl:
@@ -125,6 +130,10 @@ namespace cw
           dst.flags = src.flags;
           break;
 
+        case kMBufTFl:
+          dst.u.mbuf = src.u.mbuf == nullptr ? nullptr : mbuf_duplicate(src.u.mbuf);
+          dst.flags = src.flags;
+          break;
           
         case kBoolMtxTFl:
         case kUIntMtxTFl:
@@ -182,6 +191,15 @@ namespace cw
               printf("(binN:%i hopSmpN:%i) ", v->u.fbuf->binN_V[i], v->u.fbuf->hopSmpN_V[i] );
           }
           break;
+
+        case kMBufTFl:
+          if( v->u.mbuf == nullptr )
+            printf("mbuf: <null>");
+          else
+          {
+            printf("mbuf: cnt: %i", v->u.mbuf->msgN );
+          }
+          break;
           
         case kBoolMtxTFl:
         case kUIntMtxTFl:
@@ -345,6 +363,28 @@ namespace cw
       return rc;        
     }
 
+    rc_t _val_get( value_t* val, mbuf_t*& valRef )
+    {
+      rc_t rc = kOkRC;
+      if( cwIsFlag(val->flags & kTypeMask, kMBufTFl) )
+        valRef = val->u.mbuf;
+      else
+      {
+        valRef = nullptr;
+        rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to an mbuf_t.",val->flags);
+      }
+      return rc;
+    }
+    
+    rc_t _val_get( value_t* val, const mbuf_t*& valRef )
+    {
+      mbuf_t* non_const_val;
+      rc_t rc = kOkRC;
+      if((rc = _val_get(val,non_const_val)) == kOkRC )
+        valRef = non_const_val;
+      return rc;        
+    }
+    
 
     template< typename T >
     rc_t _val_get_driver( const variable_t* var, T& valRef )
@@ -492,6 +532,14 @@ namespace cw
       var->local_value[ local_value_idx ].flags = kABufTFl;
       cwLogMod("%s.%s ch:%i %s (abuf).",var->inst->label,var->label,var->chIdx,abuf==nullptr ? "null" : "valid");
     }
+
+    template<>
+    void _var_setter<mbuf_t*>( variable_t* var, unsigned local_value_idx, mbuf_t* val )
+    {
+      var->local_value[ local_value_idx ].u.mbuf   = val;
+      var->local_value[ local_value_idx ].flags = kMBufTFl;
+      cwLogMod("%s.%s ch:%i %s (abuf).",var->inst->label,var->label,var->chIdx,mbuf==nullptr ? "null" : "valid");
+    }
     
     template<>
     void _var_setter<fbuf_t*>( variable_t* var, unsigned local_value_idx, fbuf_t* val )
@@ -609,6 +657,19 @@ namespace cw
       return rc;
     }
 
+    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, mbuf_t* mbuf )
+    {
+      rc_t rc;
+      variable_t* var = nullptr;
+      if((rc = var_register_and_set( inst, var_label, vid, chIdx, var)) != kOkRC )
+        return rc;
+
+      if( var != nullptr )
+        _var_set_driver( var, kMBufTFl, mbuf );
+
+      return rc;
+    }
+    
     rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, fbuf_t* fbuf )
     {
       rc_t rc;
@@ -1010,6 +1071,25 @@ cw::flow::fbuf_t*  cw::flow::fbuf_duplicate( const fbuf_t* src )
 }
 
 
+cw::flow::mbuf_t* cw::flow::mbuf_create( const midi::ch_msg_t* msgA, unsigned msgN )
+{
+  mbuf_t* m = mem::allocZ<mbuf_t>();
+  m->msgA = msgA;
+  m->msgN = msgN;
+  return m;
+}
+
+void cw::flow::mbuf_destroy( mbuf_t*& buf )
+{
+  mem::release(buf);
+}
+
+cw::flow::mbuf_t* cw::flow::mbuf_duplicate( const mbuf_t* src )
+{
+  return mbuf_create(src->msgA,src->msgN);
+}
+
+
 unsigned cw::flow::value_type_label_to_flag( const char* s )
 {
   unsigned flags = labelToId(typeLabelFlagsA,s,kInvalidTFl);
@@ -1089,10 +1169,13 @@ cw::rc_t cw::flow::instance_find( flow_t* p, const char* inst_label, instance_t*
   return cwLogError(kInvalidArgRC,"The instance '%s' was not found.", inst_label );
 }
 
-cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl )
+cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel )
 {
   for(unsigned i=0; i<p->deviceN; ++i)
-    if( cw::textIsEqual(p->deviceA[i].label,device_label) && p->deviceA[i].typeId==typeId && cwIsFlag(p->deviceA[i].flags,inOrOutFl ))
+    if( (device_label==nullptr || cw::textIsEqual(p->deviceA[i].devLabel,device_label))
+        && p->deviceA[i].typeId==typeId
+        && cwIsFlag(p->deviceA[i].flags,inOrOutFl)
+        && (midiPortLabel==nullptr || cw::textIsEqual(p->deviceA[i].portLabel,midiPortLabel)) )
       return p->deviceA + i;
   
   cwLogError(kInvalidArgRC,"The %s device named '%s' could not be found.", cwIsFlag(inOrOutFl,kInFl) ? "in" : "out", device_label );
@@ -1381,6 +1464,21 @@ cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label
   return rc;
 }
 
+cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, midi::ch_msg_t* msgA, unsigned msgN  )
+{
+  rc_t rc = kOkRC;
+  mbuf_t* mbuf;
+  
+  if((mbuf = mbuf_create(msgA,msgN)) == nullptr )
+    return cwLogError(kOpFailRC,"mbuf create failed on instance:'%s' variable:'%s'.", inst->label, var_label);
+
+  if((rc = _var_register_and_set( inst, var_label, vid, chIdx, mbuf )) != kOkRC )
+    mbuf_destroy(mbuf);
+
+  return rc;
+}
+
+
 cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
 {
   unsigned maxBinN_V[ chN ];
@@ -1423,6 +1521,13 @@ cw::rc_t  cw::flow::var_get( const variable_t* var, const fbuf_t*& valRef )
 cw::rc_t  cw::flow::var_get( variable_t* var, fbuf_t*& valRef )
 { return _val_get_driver(var,valRef); }
 
+cw::rc_t  cw::flow::var_get( const variable_t* var, const mbuf_t*& valRef )
+{ return _val_get_driver(var,valRef); }
+
+cw::rc_t  cw::flow::var_get( variable_t* var, mbuf_t*& valRef )
+{ return _val_get_driver(var,valRef); }
+
+
 cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool val )
 {
   rc_t        rc  = kOkRC;
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index eb1ffbf..0fe4ce5 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -4,16 +4,22 @@ namespace cw
   {
 
     #define kRealTFl kFloatTFl
-    typedef dsp::real_t   real_t;
-    typedef dsp::sample_t sample_t;
+    typedef dsp::real_t    real_t;
+    typedef dsp::sample_t  sample_t;
     typedef dsp::fd_real_t fd_real_t;
-    typedef dsp::srate_t  srate_t;
-    typedef unsigned      uint_t;
-    typedef int           int_t;
+    typedef dsp::srate_t   srate_t;
+    typedef unsigned       uint_t;
+    typedef int            int_t;
     
     
     typedef unsigned vid_t;
 
+    enum {
+      kFbufVectN = 3,  // count of signal vectors in fbuf (mag,phs,hz)
+      kAnyChIdx = kInvalidIdx,
+      kLocalValueN = 2
+    };
+        
     typedef struct abuf_str
     {
       struct value_str*  base;
@@ -24,12 +30,6 @@ namespace cw
     } abuf_t;
 
 
-    enum {
-      kFbufVectN = 3,  // count of signal vectors in fbuf (mag,phs,hz)
-      kAnyChIdx = kInvalidIdx,
-      kLocalValueN = 2
-    };
-    
     typedef struct fbuf_str
     {      
       struct value_str* base;
@@ -39,13 +39,20 @@ namespace cw
       unsigned*         maxBinN_V; // max value that binN_V[i] is allowed to take
       unsigned*         binN_V;    // binN_V[ chN ] count of sample frames per channel
       unsigned*         hopSmpN_V; // hopSmpN_V[ chN ] hop sample count 
-      fd_real_t**        magV;      // magV[ chN ][ binN ]
-      fd_real_t**        phsV;      // phsV[ chN ][ binN ]
-      fd_real_t**        hzV;       // hzV[ chN ][ binN ]
+      fd_real_t**       magV;      // magV[ chN ][ binN ]
+      fd_real_t**       phsV;      // phsV[ chN ][ binN ]
+      fd_real_t**       hzV;       // hzV[ chN ][ binN ]
       bool*             readyFlV;  // readyFlV[chN] true if this channel is ready to be processed (used to sync. fbuf rate to abuf rate)
-      fd_real_t*         buf;       // memory used by this buffer (or NULL if magV,phsV,hzV point are proxied to another buffer)      
+      fd_real_t*        buf;       // memory used by this buffer (or NULL if magV,phsV,hzV point are proxied to another buffer)      
     } fbuf_t;
 
+    typedef struct mbuf_str
+    {
+      struct value_str*     base;
+      const midi::ch_msg_t* msgA;
+      unsigned              msgN;
+    } mbuf_t;
+
     enum
     {
       kInvalidTFl  = 0x00000000,
@@ -64,10 +71,11 @@ namespace cw
       
       kABufTFl     = 0x00000800,
       kFBufTFl     = 0x00001000,
-      kStringTFl   = 0x00002000,
-      kTimeTFl     = 0x00004000,
+      kMBufTFl     = 0x00002000,
+      kStringTFl   = 0x00004000,
+      kTimeTFl     = 0x00008000,
 
-      kTypeMask    = 0x00007fff,
+      kTypeMask    = 0x0000ffff,
 
     };
 
@@ -96,6 +104,7 @@ namespace cw
         
         abuf_t*   abuf;
         fbuf_t*   fbuf;
+        mbuf_t*   mbuf;
         
         char*     s;
         char*     fname;
@@ -115,11 +124,11 @@ namespace cw
         
     typedef rc_t (*member_func_t)( struct instance_str* ctx );
     typedef rc_t (*member_value_func_t)( struct instance_str* ctx, struct variable_str* var );
+    
     enum
     {
-      kSrcVarFl = 0x01,
-      kSrcOptVarFl = 0x02
-      
+      kSrcVarFl    = 0x01,
+      kSrcOptVarFl = 0x02 
     };
     
     typedef struct class_members_str
@@ -242,6 +251,10 @@ namespace cw
     fbuf_t*        fbuf_create( srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
     void           fbuf_destroy( fbuf_t*& buf );
     fbuf_t*        fbuf_duplicate( const fbuf_t* src );
+
+    mbuf_t*        mbuf_create( const midi::ch_msg_t* msgA=nullptr, unsigned msgN=0 );
+    void           mbuf_destroy( mbuf_t*& buf );
+    mbuf_t*        mbuf_duplicate( const mbuf_t* src );
     
     inline bool    value_is_abuf( const value_t* v ) { return v->flags & kABufTFl; }
     inline bool    value_is_fbuf( const value_t* v ) { return v->flags & kFBufTFl; }
@@ -274,7 +287,7 @@ namespace cw
     
     instance_t*        instance_find( flow_t* p, const char* inst_label );
     rc_t               instance_find( flow_t* p, const char* inst_label, instance_t*& instPtrRef );
-    external_device_t* external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl );
+    external_device_t* external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel=nullptr );
 
     void               instance_print( instance_t* inst );
 
@@ -374,6 +387,7 @@ namespace cw
     rc_t           var_register_and_set( instance_t* inst, const char* label,     unsigned vid, unsigned chIdx, variable_t*& varRef );
     
     rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
     rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
     rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
 
@@ -427,6 +441,8 @@ namespace cw
     rc_t           var_get(       variable_t* var, abuf_t*&       valRef );    
     rc_t           var_get( const variable_t* var, const fbuf_t*& valRef );
     rc_t           var_get(       variable_t* var, fbuf_t*&       valRef );
+    rc_t           var_get( const variable_t* var, const mbuf_t*& valRef );
+    rc_t           var_get(       variable_t* var, mbuf_t*&       valRef );
 
     template< typename T>
     rc_t var_get( instance_t* inst, unsigned vid, unsigned chIdx, T& valRef)
diff --git a/cwIoFlow.cpp b/cwIoFlow.cpp
index 7d3bf79..2ac38b1 100644
--- a/cwIoFlow.cpp
+++ b/cwIoFlow.cpp
@@ -8,6 +8,8 @@
 #include "cwTime.h"
 #include "cwVectOps.h"
 #include "cwMtx.h"
+#include "cwTime.h"
+#include "cwMidiDecls.h"
 
 #include "cwDspTypes.h"
 #include "cwFlowDecl.h"
@@ -87,7 +89,7 @@ namespace cw
 
       mem::release(p->audioGroupA);
       mem::release(p);
-      
+       
       return kOkRC;
     }
 
@@ -95,10 +97,13 @@ namespace cw
     {
       unsigned devN = 0;
       
-      //devN += midiDeviceCount(p->ioH);
       devN += socketCount(p->ioH);
       devN += serialDeviceCount(p->ioH);
 
+      unsigned midiDevN = midiDeviceCount(p->ioH);
+      for(unsigned i=0; i<midiDevN; ++i)
+        devN += midiDevicePortCount(p->ioH,i,true) + midiDevicePortCount(p->ioH,i,false);
+      
       for(unsigned i=0; i<p->audioGroupN; ++i)
         devN +=  p->audioGroupA[i].iDeviceN + p->audioGroupA[i].oDeviceN;
       
@@ -146,23 +151,38 @@ namespace cw
       }
     }
 
-
-    void _setup_device_cfg( flow::external_device_t* d, const char* devLabel, unsigned ioDevId, unsigned typeId, unsigned flags )
+    rc_t _send_midi_triple( flow::external_device_t* dev, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 )
     {
-      d->label   = devLabel;
-      d->ioDevId = ioDevId;
-      d->typeId  = typeId;
-      d->flags   = flags;
+      return midiDeviceSend(((io_flow_t*)dev->reserved)->ioH, dev->ioDevIdx, dev->ioPortIdx, status |= ch, d0, d1);
     }
 
+    void _setup_device_cfg( io_flow_t* p, flow::external_device_t* d, const char* devLabel, unsigned ioDevIdx, unsigned typeId, unsigned flags, const char* midiPortLabel=nullptr, unsigned midiPortIdx=kInvalidIdx )
+    {
+      d->reserved  = p;
+      d->devLabel  = devLabel;
+      d->portLabel = midiPortLabel;
+      d->typeId    = typeId;
+      d->flags     = flags;
+      d->ioDevIdx  = ioDevIdx;
+      d->ioPortIdx = midiPortIdx;
+    }
+
+    void _setup_midi_device_cfg( io_flow_t* p, flow::external_device_t* d, const char* devLabel, unsigned ioDevIdx, unsigned flags, unsigned ioMidiPortIdx  )
+    {
+      const char* midiPortLabel = io::midiDevicePortName(p->ioH,ioDevIdx, flags & flow::kInFl ? true : false,ioMidiPortIdx);
+      _setup_device_cfg( p, d, devLabel, ioDevIdx, flow::kMidiDevTypeId, flags, midiPortLabel, ioMidiPortIdx );
+      d->u.m.maxMsgCnt = io::midiDeviceMaxBufferMsgCount(p->ioH);
+      d->u.m.sendTripleFunc = _send_midi_triple; 
+    }
+    
     void _setup_audio_device_cfg( io_flow_t* p, flow::external_device_t* d, audio_group_t* ag, audio_dev_t* ad, unsigned flags )
     {
-      _setup_device_cfg( d, io::audioDeviceLabel(p->ioH,ad->ioDevIdx), ad->ioDevId, flow::kAudioDevTypeId, flags );
+      _setup_device_cfg( p, d, io::audioDeviceLabel(p->ioH,ad->ioDevIdx), ad->ioDevIdx, flow::kAudioDevTypeId, flags );
 
       // Each audio device is given a flow::abuf to hold incoming or outgoing audio.
       // This buffer also allows the 'audio_in' and 'audio_out' flow procs to configure themselves.
       d->u.a.abuf = &ad->abuf;
-    }
+    }    
 
     void _setup_generic_device_array( io_flow_t* p )
     {
@@ -175,17 +195,27 @@ namespace cw
 
       // get serial devices
       for(unsigned di=0; i<p->deviceN && di<serialDeviceCount(p->ioH); ++di,++i)
-        _setup_device_cfg( p->deviceA + i, io::serialDeviceLabel(p->ioH,di), io::serialDeviceId(p->ioH,di), flow::kSerialDevTypeId, flow::kInFl | flow::kOutFl );
-
-      // get midi devices
-      //for(unsigned di=0; i<p->deviceN && di<midiDeviceCount(p->ioH); ++di,++i)
-      //  _setup_device_cfg( p->deviceA + i, io::midiDeviceLabel(p->ioH,di), di, flow::kMidiDevTypeId, flow::kInFl | flow::kOutFl );
+        _setup_device_cfg( p, p->deviceA + i, io::serialDeviceLabel(p->ioH,di), di, flow::kSerialDevTypeId, flow::kInFl | flow::kOutFl );
 
       // get sockets
       for(unsigned di=0; i<p->deviceN && di<socketCount(p->ioH); ++di,++i)
-        _setup_device_cfg( p->deviceA + i, io::socketLabel(p->ioH,di), io::socketUserId(p->ioH,di), flow::kSocketDevTypeId, flow::kInFl | flow::kOutFl );
+        _setup_device_cfg( p, p->deviceA + i, io::socketLabel(p->ioH,di), di, flow::kSocketDevTypeId, flow::kInFl | flow::kOutFl );
         
 
+      // get midi devices
+      for(unsigned di=0; i<p->deviceN && di<midiDeviceCount(p->ioH); ++di)
+      {
+        // input port setup
+        for(unsigned pi=0; pi<midiDevicePortCount(p->ioH,di,true); ++pi,++i)
+          _setup_midi_device_cfg( p, p->deviceA + i, io::midiDeviceName(p->ioH,di), di, flow::kInFl, pi);
+
+        // output port setup
+        for(unsigned pi=0; pi<midiDevicePortCount(p->ioH,di,false); ++pi,++i)
+          _setup_midi_device_cfg( p, p->deviceA + i, io::midiDeviceName(p->ioH,di), di, flow::kOutFl, pi);
+        
+      }
+      
+      
       // get the audio devices
       for(unsigned gi=0; gi<p->audioGroupN; ++gi)
       {
@@ -198,6 +228,9 @@ namespace cw
           _setup_audio_device_cfg( p, p->deviceA + i, ag, ag->oDeviceA + di, flow::kOutFl );
       }
 
+
+      assert( i == p->deviceN );
+
     }
 
     rc_t _device_index_to_abuf( io_flow_t* p, unsigned ioGroupIdx, unsigned ioDevIdx, unsigned inOrOutFl, flow::abuf_t*& abuf_ref )
@@ -254,6 +287,18 @@ namespace cw
       rc_t rc = kOkRC;
       flow::abuf_t* abuf = nullptr;
 
+      // Get an array of incoming MIDI events which have occurred since the last call to 'io::midiDeviceBuffer()'
+      unsigned midiBufMsgCnt        = 0;
+      const midi::ch_msg_t* midiBuf = midiDeviceBuffer(p->ioH,midiBufMsgCnt);
+
+      // Give each MIDI input device a pointer to the incoming MIDI msgs
+      for(unsigned i=0; i<p->deviceN; ++i)
+        if( p->deviceA[i].typeId == flow::kMidiDevTypeId && cwIsFlag(p->deviceA[i].flags,flow::kInFl) )
+        {
+          p->deviceA[i].u.m.msgArray = midiBuf;
+          p->deviceA[i].u.m.msgCnt   = midiBufMsgCnt;
+        }
+
       // if there is incoming (recorded) audio 
       if( m.iBufChCnt > 0 )
       {
@@ -318,6 +363,9 @@ namespace cw
       }
         
     errLabel:
+      // Drop the MIDI messages that were processed on this call.
+      midiDeviceClearBuffer(p->ioH,midiBufMsgCnt);
+        
       return rc;
     }
 

From a3012db1653b1f247b93169d2244fe5b7741c6df Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 22 Apr 2024 15:56:11 -0400
Subject: [PATCH 021/101] cwText.h/cpp : Added first/lastMatchChar() for
 non-const strings.

---
 cwText.cpp | 16 +++++++++++++---
 cwText.h   |  3 +++
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/cwText.cpp b/cwText.cpp
index f6b4e7a..2ae2f89 100644
--- a/cwText.cpp
+++ b/cwText.cpp
@@ -146,7 +146,7 @@ const char* cw::nextNonWhiteChar( const char* s )
 const char* cw::nextNonWhiteCharEOS( const char* s )
 { return _nextNonWhiteChar(s,true); }
 
-const char* cw::firstMatchChar( const char* s, char c )
+char* cw::firstMatchChar( char* s, char c )
 {
   if( s == nullptr )
     return nullptr;
@@ -157,7 +157,12 @@ const char* cw::firstMatchChar( const char* s, char c )
   return nullptr;
 }
 
-const char* cw::lastMatchChar( const char* s, char c )
+const char* cw::firstMatchChar( const char* s, char c )
+{
+  return firstMatchChar((char*)s,c);
+}
+
+char* cw::lastMatchChar( char* s, char c )
 {
   unsigned sn;
   
@@ -168,13 +173,18 @@ const char* cw::lastMatchChar( const char* s, char c )
   if( sn == 0 )
     return nullptr;
   
-  for(const char* s1=s+(sn-1); s<=s1; --s1)
+  for(char* s1=s+(sn-1); s<=s1; --s1)
     if( *s1 == c )
       return s1;
     
   return nullptr;
 }
 
+const char* cw::lastMatchChar( const char* s, char c )
+{
+  return lastMatchChar((char*)s,c);
+}
+
 bool cw::isInteger( const char* s )
 {
   for(; *s; ++s)
diff --git a/cwText.h b/cwText.h
index cc44f06..9c4b7de 100644
--- a/cwText.h
+++ b/cwText.h
@@ -65,8 +65,11 @@ namespace cw
 
   // Return a pointer to the first occurrence of 'c' in s[] or nullptr
   // if 'c' does not occur in s[]
+  char*       firstMatchChar( char* s, char c );
   const char* firstMatchChar( const char* s, char c );
+  
   // Find the last occurrent of 'c' in s[]. 
+  char*       lastMatchChar( char* s, char c ); 
   const char* lastMatchChar( const char* s, char c ); 
   
   bool isInteger( const char* );        // text contains only [0-9]

From 1c373f8d03db0ba2460ca29d3213a6ab335e79d9 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 22 Apr 2024 15:57:59 -0400
Subject: [PATCH 022/101] cwObject.cpp : All non-quoted-string string are now
 considered identifiers in objectFromString().

---
 cwObject.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwObject.cpp b/cwObject.cpp
index a84a6c8..6fabd0b 100644
--- a/cwObject.cpp
+++ b/cwObject.cpp
@@ -907,7 +907,7 @@ cw::rc_t cw::objectFromString( const char* s, object_t*& objRef )
           s[n] = 0;
           
           //char*    v       = mem::duplStr(lex::tokenText(lexH),lex::tokenCharCount(lexH));
-          unsigned identFl = lexId == lex::kIdentLexTId ? kIdentFl    : 0;          
+          unsigned identFl = lexId != lex::kQStrLexTId ? kIdentFl    : 0;          
           
           _objCreateValueNode<char*>( cnp, s, "string", identFl );
         }

From 1b649124a6ae7094962e8f5988da5bd7ed32aa08 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 22 Apr 2024 16:02:40 -0400
Subject: [PATCH 023/101] cwFlow*,cwPresetSel.cpp: Many changes to implement
 'poly' networks. cwFlowNet.h/cpp : Initial commit.

---
 Makefile.am     |    4 +-
 cwFlow.cpp      | 1665 ++--------------------------------
 cwFlow.h        |   62 +-
 cwFlowDecl.h    |   61 ++
 cwFlowNet.cpp   | 2279 +++++++++++++++++++++++++++++++++++++++++++++++
 cwFlowNet.h     |   82 ++
 cwFlowProc.cpp  |  617 ++++++++++---
 cwFlowProc.h    |    3 +
 cwFlowTypes.cpp |  220 ++---
 cwFlowTypes.h   |  104 ++-
 cwPresetSel.cpp |    3 +-
 11 files changed, 3183 insertions(+), 1917 deletions(-)
 create mode 100644 cwFlowNet.cpp
 create mode 100644 cwFlowNet.h

diff --git a/Makefile.am b/Makefile.am
index ac568fd..a94f6e6 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -34,8 +34,8 @@ libcwSRC += src/libcw/cwAudioFile.cpp   src/libcw/cwMidiFile.cpp
 libcwHDR += src/libcw/cwAudioFileOps.h    src/libcw/cwAudioTransforms.h   src/libcw/cwDspTransforms.h   src/libcw/cwAudioFileProc.h    src/libcw/cwPvAudioFileProc.h
 libcwSRC += src/libcw/cwAudioFileOps.cpp  src/libcw/cwAudioTransforms.cpp src/libcw/cwDspTransforms.cpp src/libcw/cwAudioFileProc.cpp  src/libcw/cwPvAudioFileProc.cpp
 
-libcwHDR += src/libcw/cwFlow.h    src/libcw/cwFlowDecl.h src/libcw/cwFlowTypes.h     src/libcw/cwFlowProc.h     src/libcw/cwFlowCross.h
-libcwSRC += src/libcw/cwFlow.cpp                         src/libcw/cwFlowTypes.cpp   src/libcw/cwFlowProc.cpp   src/libcw/cwFlowCross.cpp
+libcwHDR += src/libcw/cwFlow.h    src/libcw/cwFlowDecl.h src/libcw/cwFlowTypes.h     src/libcw/cwFlowNet.h   src/libcw/cwFlowProc.h     src/libcw/cwFlowCross.h
+libcwSRC += src/libcw/cwFlow.cpp                         src/libcw/cwFlowTypes.cpp   src/libcw/cwFlowNet.cpp src/libcw/cwFlowProc.cpp   src/libcw/cwFlowCross.cpp
 
 if cwWEBSOCK
 libcwHDR += src/libcw/cwWebSock.h   src/libcw/cwWebSockSvr.h
diff --git a/cwFlow.cpp b/cwFlow.cpp
index 8f61939..ceea17f 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -3,7 +3,9 @@
 #include "cwCommonImpl.h"
 #include "cwMem.h"
 #include "cwText.h"
+#include "cwNumericConvert.h"
 #include "cwObject.h"
+
 #include "cwAudioFile.h"
 #include "cwVectOps.h"
 #include "cwMtx.h"
@@ -13,6 +15,7 @@
 #include "cwFlowDecl.h"
 #include "cwFlow.h"
 #include "cwFlowTypes.h"
+#include "cwFlowNet.h"
 #include "cwFlowProc.h"
 
 namespace cw
@@ -26,6 +29,7 @@ namespace cw
     } library_t;
     
     library_t g_library[] = {
+      { "poly",            &poly::members },
       { "midi_in",         &midi_in::members },
       { "midi_out",        &midi_out::members },
       { "audio_in",        &audio_in::members },
@@ -48,6 +52,8 @@ namespace cw
       { "balance",         &balance::members },
       { "audio_meter",     &audio_meter::members },
       { "audio_marker",    &audio_marker::members },
+      { "xfade_ctl",       &xfade_ctl::members },
+      { "poly_mixer",      &poly_mixer::members },
       { nullptr, nullptr }
     };
 
@@ -113,7 +119,8 @@ namespace cw
         
         // get the variable description 
         if((rc = cd->cfg->getv_opt("vars",  varD,
-                                   "presets", presetD )) != kOkRC )
+                                   "presets", presetD,
+                                   "poly_limit_cnt", cd->polyLimitN)) != kOkRC )
         {
           rc = cwLogError(rc,"Parsing failed while parsing class desc:'%s'", cwStringNullGuard(cd->label) );
           goto errLabel;                      
@@ -229,19 +236,9 @@ namespace cw
       return rc;
     }
 
-    void _connect_vars( variable_t* src_var, variable_t* in_var )
-    {
-      // connect in_var into src_var's outgoing var chain
-      in_var->connect_link  = src_var->connect_link;
-      src_var->connect_link = in_var;
 
-      assert( src_var->value != nullptr );
-          
-      in_var->value    = src_var->value;
-      in_var->src_var = src_var;
-    }
-
-    rc_t _setup_input( flow_t* p, instance_t* in_inst, const char* in_var_label, const char* src_label_arg )
+    /*
+    rc_t _setup_input( flow_t* p, instance_t* in_inst, const char* in_var_label, const char* src_proc_label, const char* src_var_label )
     {
       rc_t        rc        = kOkRC;
       unsigned    src_charN = textLength(src_label_arg);
@@ -267,21 +264,21 @@ namespace cw
       }
 
       // locate source instance
-      if((rc = instance_find(p, sbuf, src_inst )) != kOkRC )
+      if((rc = instance_find(p, sbuf, kBaseSfxId, src_inst )) != kOkRC )
       {
         rc = cwLogError(kSyntaxErrorRC,"The source instance '%s' was not found.", cwStringNullGuard(sbuf) );
         goto errLabel;
       }
 
       // locate source value
-      if((rc = var_find( src_inst, suffix, kAnyChIdx, src_var)) != kOkRC )
+      if((rc = var_find( src_inst, suffix, kBaseSfxId, kAnyChIdx, src_var)) != kOkRC )
       {
         rc = cwLogError(rc,"The source var '%s' was not found on the source instance '%s'.", cwStringNullGuard(suffix), cwStringNullGuard(sbuf));
         goto errLabel;
       }
 
       // locate input value
-      if((rc = var_find( in_inst, in_var_label, kAnyChIdx, in_var )) != kOkRC )
+      if((rc = var_find( in_inst, in_var_label, kBaseSfxId, kAnyChIdx, in_var )) != kOkRC )
       {
         rc = cwLogError(rc,"The input value '%s' was not found on the instance '%s'.", cwStringNullGuard(in_var_label), cwStringNullGuard(in_inst->label));
         goto errLabel;        
@@ -307,853 +304,12 @@ namespace cw
     errLabel:
       return rc;
     }
+    */
 
 
-    void _destroy_inst( instance_t* inst )
-    {
-      if( inst == nullptr )
-        return;
-      
-      if( inst->class_desc->members->destroy != nullptr && inst->userPtr != nullptr )
-        inst->class_desc->members->destroy( inst );
 
-      // destroy the instance variables
-      variable_t* var0 = inst->varL;
-      variable_t* var1 = nullptr;      
-      while( var0 != nullptr )
-      {
-        var1 = var0->var_link;
-        _var_destroy(var0);
-        var0 = var1;
-      }
-
-      
-      mem::release(inst->varMapA);
-      mem::release(inst);
-    }
-
-    rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef );
-
-    rc_t _create_instance_var_map( instance_t* inst )
-    {
-      rc_t        rc        = kOkRC;
-      unsigned    max_vid   = kInvalidId;
-      unsigned    max_chIdx = 0;
-      variable_t* var       = inst->varL;
-      //variable_t* v0        = nullptr;
-      
-      // determine the max variable vid and max channel index value among all variables
-      for(; var!=nullptr; var = var->var_link )
-      {
-        if( var->vid != kInvalidId )
-        {
-          if( max_vid == kInvalidId || var->vid > max_vid )
-            max_vid = var->vid;
-
-          if( var->chIdx != kAnyChIdx && (var->chIdx+1) > max_chIdx )
-            max_chIdx = (var->chIdx + 1);
-
-        }
-      }
-
-      // If there are any variables
-      if( max_vid != kInvalidId )
-      {
-        // create the variable map array
-        inst->varMapChN = max_chIdx + 1;
-        inst->varMapIdN = max_vid + 1;
-        inst->varMapN   = inst->varMapIdN * inst->varMapChN;
-        inst->varMapA   = mem::allocZ<variable_t*>( inst->varMapN );
-
-        // assign each variable to a location in the map
-        for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
-          if( var->vid != kInvalidId )
-          {
-            unsigned idx = kInvalidIdx;
-
-            if((rc = _var_map_id_to_index( inst, var->vid, var->chIdx, idx )) != kOkRC )
-              goto errLabel;
-
-          
-            // verify that there are not multiple variables per map position          
-            if( inst->varMapA[ idx ] != nullptr )
-            {
-              variable_t* v0 = inst->varMapA[idx];
-              rc = cwLogError(kInvalidStateRC,"The variable '%s' id:%i ch:%i and '%s' id:%i ch:%i share the same variable map position on instance: %s. This is usually cased by duplicate variable id's.",
-                              v0->label,v0->vid,v0->chIdx, var->label,var->vid,var->chIdx,inst->label);
-
-              goto errLabel;
-            }
-
-            // assign this variable to a map position
-            inst->varMapA[ idx ] = var;
-
-            if( var->chIdx != kAnyChIdx && var->value == nullptr )
-            {
-              rc = cwLogError(kInvalidStateRC,"The value of the variable '%s' ch:%i on instance:'%s' has not been set.",var->label,var->chIdx,inst->label);
-              goto errLabel;
-            }
-
-          }
-        
-      }
-
-    errLabel:
-      return rc;
-      
-    }
-
-    void _complete_input_connections( instance_t* inst )
-    {
-      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
-        if(var->chIdx == kAnyChIdx && is_connected_to_external_proc(var) )
-        {
-
-          variable_t* base_src_var = var->src_var;
-
-          // since 'var' is on the 'any' channel the 'src' var must also be on the 'any' channel
-          assert( base_src_var->chIdx == kAnyChIdx );
-          
-          //printf("%s %s\n",inst->label,var->label);
-          
-          // for each var channel in the input var
-          for(variable_t* in_var = var->ch_link; in_var != nullptr; in_var=in_var->ch_link)
-          {
-            // locate the matching channel on the 'src' var
-            variable_t* svar = base_src_var;
-            for(; svar!=nullptr; svar=svar->ch_link)
-              if( svar->chIdx == in_var->chIdx )
-                break;
-
-            // connect the src->input var
-            _connect_vars( svar==nullptr ? base_src_var : svar, in_var);
-          }
-        }
-    }
     
-    rc_t _call_value_func_on_all_variables( instance_t* inst )
-    {
-      rc_t rc  = kOkRC;
-      rc_t rc1 = kOkRC;
-      
-      for(unsigned i=0; i<inst->varMapN; ++i)
-        if( inst->varMapA[i] != nullptr && inst->varMapA[i]->vid != kInvalidId )
-        {
-          variable_t* var = inst->varMapA[i];
-          
-          if((rc = var->inst->class_desc->members->value( var->inst, var )) != kOkRC )
-            rc1 = cwLogError(rc,"The proc instance '%s' reported an invalid valid on variable:%s chIdx:%i.", var->inst->label, var->label, var->chIdx );
-        }
-      
-      return rc1;
-    }
-
-    rc_t _var_channelize( instance_t* inst, const char* preset_label,  const char* type_src_label, const char* value_label, const object_t* value )
-    {
-      rc_t rc = kOkRC;
-      
-      variable_t*     dummy       = nullptr;
-
-      // verify that a valid value exists
-      if( value == nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"Unexpected missig value on %s preset '%s' instance '%s' variable '%s'.", type_src_label, preset_label, inst->label, cwStringNullGuard(value_label) );
-        goto errLabel;
-      }
-
-      // if a list of values was given
-      if( value->is_list() )
-      {
-        for(unsigned chIdx=0; chIdx<value->child_count(); ++chIdx)
-          if((rc = var_channelize( inst, value_label, chIdx, value->child_ele(chIdx), kInvalidId, dummy )) != kOkRC )
-            goto errLabel;
-      }
-      else // otherwise a single value was given
-      {          
-        if((rc = var_channelize( inst, value_label, kAnyChIdx, value, kInvalidId, dummy )) != kOkRC )
-          goto errLabel;
-      }
-
-    errLabel:
-      return rc;
-    }
     
-    rc_t _preset_channelize_vars( instance_t* inst, const char* type_src_label, const char* preset_label, const object_t* preset_cfg )
-    {
-      rc_t rc = kOkRC;
-
-      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), inst->label );
-      
-      // validate the syntax of the preset record
-      if( !preset_cfg->is_dict() )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", preset_label, type_src_label, inst->class_desc->label );
-        goto errLabel;
-      }
-
-
-      // for each preset variable
-      for(unsigned i=0; i<preset_cfg->child_count(); ++i)
-      {
-        const object_t* value       = preset_cfg->child_ele(i)->pair_value();
-        const char*     value_label = preset_cfg->child_ele(i)->pair_label();
-        if((rc = _var_channelize( inst, preset_label, type_src_label, value_label, value )) != kOkRC )
-          goto errLabel;
-        
-        
-      }
-
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(rc,"Apply %s preset failed on instance:%s class:%s preset:%s.", type_src_label, inst->label, inst->class_desc->label, preset_label );
-
-      return rc;
-    }
-
-
-    template< typename T >
-    T _interp_dual_value( T v0, T v1, double coeff )
-    {
-      T y;
-      if( v0 == v1 )
-        y = v0;
-      else
-        y = (T)(v0 + (v1-v0)*coeff );
-
-      //printf("%f %f -> %f\n",(double)v0,(double)v1,(double)y);
-      return y;
-    }
-
-    rc_t _set_var_from_dual_preset_scalar_scalar( instance_t* inst, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff, unsigned chIdx )
-    {
-      rc_t rc = kOkRC;
-      object_t interped_value;
-      variable_t* dummy = nullptr;
-
-      // one of the input values must exist
-      if( scalar_0==nullptr && scalar_1==nullptr )
-      {
-        rc = cwLogError(kInvalidArgRC,"The numeric types of both operands of a dual value are null.");
-        goto errLabel;
-      }
-
-      // It's possible that one or the other input value does not exist
-      if( scalar_0 == nullptr )
-        scalar_0 = scalar_1;
-      else
-      {
-        if( scalar_1 == nullptr )
-          scalar_1 = scalar_0;
-      }
-
-      // verify that the input values are the same type
-      if( scalar_0->type->id != scalar_1->type->id )
-      {
-        rc = cwLogError(kInvalidArgRC,"The numeric types of both operands of a dual value preset must match. (%s != %s).",cwStringNullGuard(scalar_0->type->label),cwStringNullGuard(scalar_1->type->label));
-        goto errLabel;
-      }
-
-      printf("%s:%s :",inst->label,var_label);
-      
-      switch( scalar_0->type->id )
-      {
-        case kInt32TId:
-          interped_value.set_value( _interp_dual_value(scalar_0->u.i32,scalar_1->u.i32,coeff) );
-          break;
-        case kUInt32TId:
-          interped_value.set_value( _interp_dual_value(scalar_0->u.u32,scalar_1->u.u32,coeff) );
-          break;
-        case kInt64TId:
-          assert(0);
-          //interped_value.set_value( _interp_dual_value(scalar_0->u.i64,scalar_1->u.i64,coeff) );          
-          break;
-        case kUInt64TId:
-          assert(0);
-          //interped_value.set_value( _interp_dual_value(scalar_0->u.u64,scalar_1->u.u64,coeff) );          
-          break;
-        case kFloatTId:
-          interped_value.set_value( _interp_dual_value(scalar_0->u.f,scalar_1->u.f,coeff) );          
-          break;
-        case kDoubleTId:
-          interped_value.set_value( _interp_dual_value(scalar_0->u.d,scalar_1->u.d,coeff) );          
-          break;
-          
-        default:
-          rc = cwLogError(kInvalidStateRC,"Preset dual values of type '%s' cannot be interpolated.",cwStringNullGuard(scalar_0->type->label));
-          goto errLabel;
-      }
-
-      
-      if((rc = var_channelize( inst, var_label, chIdx, &interped_value, kInvalidId, dummy )) != kOkRC )
-      {
-        rc = cwLogError(kInvalidArgRC,"Dual value preset application failed.");
-        goto errLabel;
-      }
-
-    errLabel:
-      return rc;
-    }
-
-    rc_t _set_var_from_dual_preset_list_list( instance_t* inst, const char* var_label, const object_t* list_0, const object_t* list_1, double coeff )
-    {
-      rc_t rc = kOkRC;
-      
-      if( list_0->child_count() != list_1->child_count() )
-        return cwLogError(kInvalidArgRC,"If two lists are to be applied as a dual preset they must be the same length.");
-
-      for(unsigned chIdx=0; chIdx<list_0->child_count(); ++chIdx)
-        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,list_0->child_ele(chIdx),list_1->child_ele(chIdx),coeff,chIdx)) != kOkRC )
-          goto errLabel;
-
-    errLabel:
-      return rc;
-    }
-
-    rc_t _set_var_from_dual_preset_scalar_list( instance_t* inst, const char* var_label, const object_t* scalar, const object_t* list, double coeff )
-    {
-      rc_t rc = kOkRC;
-      for(unsigned chIdx=0; chIdx<list->child_count(); ++chIdx)
-        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,scalar,list->child_ele(chIdx),coeff,chIdx)) != kOkRC )
-          goto errLabel;
-      
-    errLabel:
-      return rc;
-    }
-
-    rc_t _set_var_from_dual_preset_list_scalar( instance_t* inst, const char* var_label, const object_t* list, const object_t* scalar, double coeff )
-    {
-      rc_t rc = kOkRC;
-      for(unsigned chIdx=0; chIdx<list->child_count(); ++chIdx)
-        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,list->child_ele(chIdx),scalar,coeff,chIdx)) != kOkRC )
-          goto errLabel;
-      
-    errLabel:
-      return rc;
-    }
-    
-    rc_t _set_var_from_dual_preset_scalar_scalar( instance_t* inst, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff )
-    {
-      return _set_var_from_dual_preset_scalar_scalar(inst,var_label,scalar_0,scalar_1,coeff,kAnyChIdx);
-    }
-    
-
-    rc_t _is_legal_dual_value( const object_t* value )
-    {
-      rc_t rc = kOkRC;
-      
-      if( value->is_list() )
-      {
-        if( value->child_count() == 0 )
-        {
-          rc = cwLogError(kInvalidArgRC,"Empty lists values cannot be applied as part of a dual value preset.");
-          goto errLabel;
-        }
-
-      }
-      else
-      {
-        switch( value->type->id )
-        {
-          case kInt32TId:
-          case kUInt32TId:
-          case kInt64TId:
-          case kUInt64TId:
-          case kFloatTId:
-          case kDoubleTId:
-            break;
-          default:
-            rc = cwLogError(kInvalidArgRC,"Objects of type '%s' cannot be applied as part of a dual value preset.",cwStringNullGuard(value->type->label));
-        }
-      }
-      
-    errLabel:
-      return rc;
-      
-    }
-    
-    rc_t _set_var_from_dual_preset( instance_t* inst, const char* var_label, const object_t* value_0, const object_t* value_1, double coeff )
-    {
-      rc_t rc = kOkRC;
-
-      // dual values must be either numeric scalars or lists
-      if((rc = _is_legal_dual_value(value_0)) != kOkRC || (rc = _is_legal_dual_value(value_1)) != kOkRC)
-         goto errLabel;
-              
-      
-      // if both values are lists then they must be the same length
-      if( value_0->is_list() && value_1->is_list() )
-      {
-        rc = _set_var_from_dual_preset_list_list( inst, var_label, value_0, value_1, coeff );
-        goto errLabel;
-      }
-      else
-      {
-        // if value_0 is a list and value_1 is a scalar
-        if( value_0->is_list() )
-        {
-          rc = _set_var_from_dual_preset_list_scalar( inst, var_label, value_0, value_1, coeff );
-          goto errLabel;
-        }
-        else
-        {
-          // if value_1 is a list and value_0 is a scalar
-          if( value_1->is_list() )
-          {
-            rc = _set_var_from_dual_preset_scalar_list( inst, var_label, value_0, value_1, coeff );
-            goto errLabel;
-          }
-          else // both values are scalars
-          {
-            rc = _set_var_from_dual_preset_scalar_scalar( inst, var_label, value_0, value_1, coeff );
-            goto errLabel;
-          }
-        }
-      }
-
-    errLabel:
-      return rc;
-    }
-    
-    rc_t _multi_preset_channelize_vars( instance_t* inst, const char* type_src_label, const char** presetLabelA, const object_t** preset_cfgA, unsigned presetN, double coeff )
-    {
-      rc_t rc = kOkRC;
-
-      const char* preset_label_0 = "<None>";
-      const char* preset_label_1 = "<None>";
-
-      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), inst->label );
-
-      if( presetN < 2 )
-      {
-        rc = cwLogError(kInvalidArgRC,"There must be at least 2 presets selected to interpolate between preset variable dictionaries.");
-        goto errLabel;
-      }
-
-      if( presetN > 2 )
-      {
-        cwLogWarning("More than two presets dictionaries were specified for interpolation. Only the first two will be used.");
-        goto errLabel;
-      }
-
-      preset_label_0 = presetLabelA[0];
-      preset_label_1 = presetLabelA[1];
-      
-      // validate each of the preset records is a dict
-      for(unsigned i=0; i<presetN; ++i)
-        if( !preset_cfgA[i]->is_dict() )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", presetLabelA[i], type_src_label, inst->class_desc->label );
-          goto errLabel;
-        }
-
-
-      // for each preset variable in the first preset var dict
-      for(unsigned i=0; i<preset_cfgA[0]->child_count(); ++i)
-      {
-        const char*     var_label   = preset_cfgA[0]->child_ele(i)->pair_label();
-        const object_t* value_0     = preset_cfgA[0]->child_ele(i)->pair_value();
-
-        const object_t* value_1     = preset_cfgA[1]->find_child(var_label);
-
-        if( value_0 == nullptr && value_1 == nullptr )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"Unexpected missig values on %s preset '%s' instance '%s' variable '%s'.", type_src_label, presetLabelA[0], inst->label, cwStringNullGuard(var_label) );
-          goto errLabel;
-        }
-
-        if( value_0 == nullptr )
-        {
-          cwLogWarning("The preset variable '%s' was not found for the preset: '%s'. Falling back to single value assign.",cwStringNullGuard(var_label),cwStringNullGuard(presetLabelA[0]));
-
-          rc = _var_channelize( inst, preset_label_1, "dual class", var_label, value_1 );
-          goto errLabel;
-        }
-        
-        if( value_1 == nullptr )
-        {
-          cwLogWarning("The preset variable '%s' was not found for the preset: '%s'. Falling back to single value assign.",cwStringNullGuard(var_label),cwStringNullGuard(presetLabelA[1]));
-          
-          rc = _var_channelize( inst, preset_label_0, "dual class", var_label, value_0 );
-          goto errLabel;
-        }
-
-
-        if((rc = _set_var_from_dual_preset( inst, var_label, value_0, value_1, coeff )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Multi preset application failed on variable:%s.",cwStringNullGuard(var_label));
-          goto errLabel;
-        }
-      }
-
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(rc,"Apply %s multi-preset failed on instance:%s class:%s presetA:%s presetB:%s.", type_src_label, inst->label, inst->class_desc->label, preset_label_0, preset_label_1 );
-
-      return rc;
-    }
-
-
-    rc_t _class_multi_preset_channelize_vars(instance_t* inst, const char** class_preset_labelA, unsigned presetN, double coeff )
-    {
-      rc_t            rc = kOkRC;
-      const object_t* presetCfgA[ presetN ];
-      const char*     presetLabelA[ presetN ];
-      unsigned        presetCfgN = 0;
-      
-      for(unsigned i=0; i<presetN; ++i)
-      {
-        if( class_preset_labelA[i] != nullptr )
-        {
-          const preset_t* pr;
-          
-          // locate the requestd preset record
-          if((pr = class_preset_find(inst->class_desc, class_preset_labelA[i])) == nullptr )
-          {
-            rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the instance '%s'.", class_preset_labelA[i], inst->label);
-            goto errLabel;
-          }
-
-          if( pr->cfg == nullptr )
-          {
-            rc = cwLogError(kInvalidIdRC,"The value of preset '%s' was empty in instance '%s'.", class_preset_labelA[i], inst->label);
-            goto errLabel;            
-          }
-
-          presetCfgA[  presetCfgN] = pr->cfg;
-          presetLabelA[presetCfgN] = class_preset_labelA[i];
-          presetCfgN++;
-        }
-      }
-
-      // dispatch based on the count of presets located
-      switch( presetCfgN )
-      {
-        case 0:
-          rc = cwLogError(kInvalidArgRC,"No valid class preset records were found while attempting apply a multi-preset.");
-          break;
-          
-        case 1:
-          // only one valid preset was located - apply it directly
-          rc = _preset_channelize_vars( inst, "class", presetLabelA[0], presetCfgA[0]);
-          break;
-          
-        default:
-          // more than one preset was located - apply it's interpolated values
-          rc = _multi_preset_channelize_vars( inst, "class", presetLabelA, presetCfgA, presetCfgN, coeff);
-      }
-      
-      
-    errLabel:                  
-      return rc;
-      
-    }
-    
-    rc_t _class_preset_channelize_vars( instance_t* inst, const char* preset_label )
-    {
-      rc_t            rc = kOkRC;
-      const preset_t* pr;
-
-      if( preset_label == nullptr )
-        return kOkRC;
-      
-      // locate the requestd preset record
-      if((pr = class_preset_find(inst->class_desc, preset_label)) == nullptr )
-      {
-        rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the instance '%s'.", preset_label, inst->label);
-        goto errLabel;
-      }
-      
-      rc = _preset_channelize_vars( inst, "class", preset_label, pr->cfg);
-      
-    errLabel:                  
-      return rc;
-    }
-
-
-    rc_t _class_apply_presets( instance_t* inst, const object_t* preset_labels )
-    {
-      rc_t        rc = kOkRC;
-      const char* s  = nullptr;
-      
-      // if preset_labels is a string
-      if( preset_labels->is_string() && preset_labels->value(s)==kOkRC )
-        return _class_preset_channelize_vars(inst,s);
-
-      // if the preset_labels is not a list
-      if( !preset_labels->is_list() )
-        rc = cwLogError(kSyntaxErrorRC,"The preset list on instance '%s' is neither a list nor a string.",inst->label);
-      else        
-      {
-        // preset_labels is a list.
-        
-        // for each label listed in the preset label list
-        for(unsigned i=0; i<preset_labels->child_count(); ++i)
-        {
-          const object_t* label_obj = preset_labels->child_ele(i);
-
-          // verify that the label is a strng
-          if( !label_obj->is_string() || label_obj->value(s) != kOkRC )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The preset list does not contain string on instance '%s'.",inst->label);
-            goto errLabel;
-          }
-
-          // apply a preset label
-          if((rc = _class_preset_channelize_vars( inst, s)) != kOkRC )
-            goto errLabel;          
-        }
-      }
-      
-    errLabel:
-      return rc;
-    }
-                               
-                                 
-    
-
-    rc_t _inst_args_channelize_vars( instance_t* inst, const char* arg_label, const object_t* arg_cfg )
-    {
-      rc_t rc = kOkRC;
-      
-      if( arg_cfg == nullptr )
-        return rc;
-
-      return _preset_channelize_vars( inst, "instance", arg_label, arg_cfg );
-      
-    }
-
-    typedef struct inst_parse_vars_str
-    {
-      const char*     inst_label;
-      const char*     inst_clas_label;
-      const object_t* in_dict;
-      const char*     arg_label;
-      const object_t* preset_labels;
-      const object_t* arg_cfg;
-    } inst_parse_vars_t;
-
-    rc_t _parse_instance_cfg( flow_t* p, const object_t* inst_cfg, inst_parse_vars_t& pvars )
-    {
-      rc_t            rc       = kOkRC;
-      const object_t* arg_dict = nullptr;
-      
-      // validate the syntax of the inst_cfg pair
-      if( inst_cfg == nullptr || !inst_cfg->is_pair() || inst_cfg->pair_label()==nullptr || inst_cfg->pair_value()==nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. is not a valid pair. No instance label could be parsed.");
-        goto errLabel;
-      }
-      
-      pvars.inst_label = inst_cfg->pair_label();
-
-      // verify that the instance label is unique
-      if( instance_find(p,pvars.inst_label) != nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The instance label '%s' has already been used.",pvars.inst_label);
-        goto errLabel;
-      }
-      
-      // get the instance class label
-      if((rc = inst_cfg->pair_value()->getv("class",pvars.inst_clas_label)) != kOkRC )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. %s is missing: 'type'.",pvars.inst_label);
-        goto errLabel;        
-      }
-      
-      // parse the optional args
-      if((rc = inst_cfg->pair_value()->getv_opt("args",     arg_dict,
-                                                "in",       pvars.in_dict,
-                                                "argLabel", pvars.arg_label,
-                                                "preset",   pvars.preset_labels)) != kOkRC )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. '%s' missing: 'type'.",pvars.inst_label);
-        goto errLabel;        
-      }
-
-      // if an argument dict was given in the instanec cfg
-      if( arg_dict != nullptr  )
-      {
-        bool rptErrFl = true;
-
-        // verify the arg. dict is actually a dict.
-        if( !arg_dict->is_dict() )
-        {
-          cwLogError(kSyntaxErrorRC,"The instance argument dictionary on instance '%s' is not a dictionary.",pvars.inst_label);
-          goto errLabel;
-        }
-        
-        // if no label was given then try 'default'
-        if( pvars.arg_label == nullptr)
-        {
-          pvars.arg_label = "default";
-          rptErrFl = false;
-        }
-
-        // locate the specified argument record
-        if((pvars.arg_cfg = arg_dict->find_child(pvars.arg_label)) == nullptr )
-        {
-
-          // if an explicit arg. label was given but it was not found
-          if( rptErrFl )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on instance cfg. '%s'.",pvars.arg_label,pvars.inst_label);
-            goto errLabel;
-          }
-
-          // no explicit arg. label was given - make arg_dict the instance arg cfg.
-          pvars.arg_cfg = arg_dict;
-          pvars.arg_label = nullptr;
-        }        
-      }
-
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on instance: '%s'.", cwStringNullGuard(pvars.inst_label) );
-      
-      return rc;
-    }
-    
-    rc_t _create_instance( flow_t* p, const object_t* inst_cfg )
-    {
-      rc_t              rc         = kOkRC;
-      inst_parse_vars_t pvars      = {};
-      instance_t*       inst       = nullptr;
-      class_desc_t*     class_desc = nullptr;      
-
-      // parse the instance configuration 
-      if((rc = _parse_instance_cfg( p, inst_cfg, pvars )) != kOkRC )
-        goto errLabel;
-        
-      // locate the class desc
-      if(( class_desc = class_desc_find(p,pvars.inst_clas_label)) == nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pvars.inst_clas_label));
-        goto errLabel;
-      }
-
-      // instantiate the instance
-      inst = mem::allocZ<instance_t>();
-
-      inst->ctx          = p;
-      inst->label        = pvars.inst_label;
-      inst->inst_cfg     = inst_cfg;
-      inst->arg_label    = pvars.arg_label;
-      inst->arg_cfg      = pvars.arg_cfg;
-      inst->class_desc   = class_desc;
-      
-      // Instantiate all the variables in the class description
-      for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
-      {
-        variable_t* var = nullptr;        
-        if((rc = var_create( inst, vd->label, kInvalidId, kAnyChIdx, vd->val_cfg, var )) != kOkRC )
-          goto errLabel;
-      }
-
-      // All the variables that can be used by this instance have now been created
-      // and the chIdx of each variable is set to 'any'.
-
-      // If a 'preset' field was included in the instance cfg then apply the specified class preset
-      if( pvars.preset_labels != nullptr )      
-        if((rc = _class_apply_presets(inst, pvars.preset_labels )) != kOkRC )
-          goto errLabel;
-
-      // All the class presets values have now been set and those variables
-      // that were expressed with a list have numeric channel indexes assigned.
-
-      // Apply the instance preset values.
-      if( pvars.arg_cfg != nullptr )
-        if((rc = _inst_args_channelize_vars( inst, pvars.arg_label, pvars.arg_cfg )) != kOkRC )
-          goto errLabel;
-
-      // All the instance arg values have now been set and those variables
-      // that were expressed with a list have numeric channel indexes assigned.
-
-
-      // TODO: Should the 'all' variable be removed for variables that have numeric channel indexes?
-
-      // connect the variable lists in the instance 'in' dictionary
-      if( pvars.in_dict != nullptr )
-      {
-        if( !pvars.in_dict->is_dict() )
-        {
-          cwLogError(kSyntaxErrorRC,"The 'in' dict in instance '%s' is not a valid dictionary.",inst->label);
-          goto errLabel;
-        }
-        
-        // for each input variable in the 'in' set
-        for(unsigned i=0; i<pvars.in_dict->child_count(); ++i)
-        {
-          const object_t*   in_pair      = pvars.in_dict->child_ele(i);
-          const char*       in_var_label = in_pair->pair_label();
-          const char*       src_label    = nullptr;
-          const var_desc_t* vd           = nullptr;
-
-          // locate the var desc of the associated variable
-          if((vd = var_desc_find( class_desc, in_var_label)) == nullptr )
-          {
-            cwLogError(kSyntaxErrorRC,"The value description for the 'in' value '%s' was not found on instance '%s'. Maybe '%s' is not marked as a 'src' attribute in the class variable descripiton.",in_var_label,inst->label,in_var_label);
-            goto errLabel;
-          }
-
-          // Note that all variable's found by the above call to var_desc_find() should be 'src' variables.
-          //assert( cwIsFlag(vd->flags,kSrcVarFl) );
-
-          // if this value is a 'src' value then it must be setup prior to the instance being instantiated
-          //if( cwIsFlag(vd->flags,kSrcVarFl) )
-          //{
-            in_pair->pair_value()->value(src_label);
-
-            // locate the pointer to the referenced output abuf and store it in inst->srcABuf[i]
-            if((rc = _setup_input( p, inst, in_var_label, src_label )) != kOkRC )
-            {
-              rc = cwLogError(kSyntaxErrorRC,"The 'in' variable at index %i is not valid on instance '%s'.", i, inst->label );
-              goto errLabel;
-            }
-            //}
-        }
-      }
-
-      // Complete the instantiation
-
-      // Call the custom instance create() function.
-      if((rc = class_desc->members->create( inst )) != kOkRC )
-      {
-        rc = cwLogError(kInvalidArgRC,"Instantiation failed on instance '%s'.", inst->label );
-        goto errLabel;
-      }
-
-      // Create the instance->varMap[] lookup array
-      if((rc =_create_instance_var_map( inst )) != kOkRC )
-        goto errLabel;
-
-      // 
-      _complete_input_connections(inst);
-
-      // call the 'value()' function to inform the instance of the current value of all of it's variables.
-      if((rc = _call_value_func_on_all_variables( inst )) != kOkRC )
-        goto errLabel;
-      
-      // insert an instance in the network
-      if( p->network_tail == nullptr )
-      {
-        p->network_head = inst;
-        p->network_tail = inst;
-      }
-      else
-      {
-        p->network_tail->link = inst;
-        p->network_tail       = inst;
-      }      
-
-      
-    errLabel:
-      if( rc != kOkRC )
-        _destroy_inst(inst);
-      
-      return rc;      
-    }
-
-
     rc_t _destroy( flow_t* p)
     {
       rc_t rc = kOkRC;
@@ -1161,17 +317,8 @@ namespace cw
       if( p == nullptr )
         return rc;
 
-      instance_t* i0=p->network_head;
-      instance_t* i1=nullptr;
-
-      // destroy the instances
-      while(i0!=nullptr)
-      {
-        i1 = i0->link;
-        _destroy_inst(i0);
-        i0 = i1;
-      }
-
+      network_destroy(p->net);
+      
       // release the class records
       for(unsigned i=0; i<p->classDescN; ++i)
       {
@@ -1199,350 +346,14 @@ namespace cw
       }
 
       mem::release(p->classDescA);
+
+      
       mem::release(p);
       
       return rc;
     }
 
-    const object_t* _find_network_preset( flow_t* p, const char* presetLabel )
-    {
-      const object_t* preset_value = nullptr;
-      
-      if( p->presetCfg != nullptr )
-      {
-        rc_t rc;
-        
-        if((rc = p->presetCfg->getv_opt( presetLabel, preset_value )) != kOkRC )
-          cwLogError(rc,"Search for network preset named '%s' failed.", cwStringNullGuard(presetLabel));
-      }
-
-      return preset_value;
-      
-    }
-
-    rc_t _exec_cycle( flow_t* p )
-    {
-      rc_t rc = kOkRC;
-      
-      for(instance_t* inst = p->network_head; inst!=nullptr; inst=inst->link)
-      {
-        if((rc = inst->class_desc->members->exec(inst)) != kOkRC )
-        {          
-          break;
-        }
-      }
-      
-      return rc;
-    }
-
-    rc_t _get_variable( flow_t* p, const char* inst_label, const char* var_label, unsigned chIdx, instance_t*& instPtrRef, variable_t*& varPtrRef )
-    {
-      rc_t        rc   = kOkRC;
-      instance_t* inst = nullptr;
-      variable_t* var  = nullptr;
-
-      varPtrRef = nullptr;
-      instPtrRef = nullptr;
-
-      // locate the proc instance
-      if((inst = instance_find(p,inst_label)) == nullptr )
-      {
-        rc = cwLogError(kInvalidIdRC,"Unknown proc instance label '%s'.", cwStringNullGuard(inst_label));
-        goto errLabel;
-      }
-
-      // locate the variable
-      if((rc = var_find( inst, var_label, chIdx, var)) != kOkRC )
-      {
-        rc = cwLogError(kInvalidArgRC,"The variable '%s' could not be found on the proc instance '%s'.",cwStringNullGuard(var_label),cwStringNullGuard(inst_label));
-        goto errLabel;
-      }
-
-      instPtrRef = inst;
-      varPtrRef = var;
-      
-    errLabel:
-      return rc;
-    }
     
-    template< typename T >
-    rc_t _set_variable_value( flow_t* p, const char* inst_label, const char* var_label, unsigned chIdx, T value )
-    {
-      rc_t rc = kOkRC;
-      instance_t* inst = nullptr;
-      variable_t* var = nullptr;
-
-      // get the variable
-      if((rc = _get_variable(p,inst_label,var_label,chIdx,inst,var)) != kOkRC )
-        goto errLabel;
-      
-      // set the variable value
-      if((rc = var_set( inst, var->vid, chIdx, value )) != kOkRC )
-      {
-        rc = cwLogError(kOpFailRC,"The variable set failed on instance:'%s' variable:'%s'.",cwStringNullGuard(inst_label),cwStringNullGuard(var_label));
-        goto errLabel;
-      }
-
-    errLabel:
-      return rc;
-    }
-
-    template< typename T >
-    rc_t _get_variable_value( flow_t* p, const char* inst_label, const char* var_label, unsigned chIdx, T& valueRef )
-    {
-      rc_t rc = kOkRC;
-      instance_t* inst = nullptr;
-      variable_t* var = nullptr;
-
-      // get the variable 
-      if((rc = _get_variable(p,inst_label,var_label,chIdx,inst,var)) != kOkRC )
-        goto errLabel;
-      
-      // get the variable value
-      if((rc = var_get( inst, var->vid, chIdx, valueRef )) != kOkRC )
-      {
-        rc = cwLogError(kOpFailRC,"The variable get failed on instance:'%s' variable:'%s'.",cwStringNullGuard(inst_label),cwStringNullGuard(var_label));
-        goto errLabel;
-      }
-
-    errLabel:
-      return rc;
-    }
-
-    unsigned _select_ranked_ele_by_rank_prob( const preset_order_t* presetA, const bool* selV , unsigned presetN )
-    {
-
-      // get a count of the candidate presets
-      unsigned rankN = selV==nullptr ? presetN : std::count_if(selV,selV+presetN,[](const bool& x){ return x; });
-
-      if( rankN == 0 )
-      {
-        cwLogWarning("All preset candidates have been eliminated.");
-        return kInvalidIdx;
-      }
-
-      unsigned rankV[  rankN ];
-      unsigned idxMapA[ rankN ];
-
-      // fill rankV[] with candidates 'order' value
-      for(unsigned i=0,j=0; i<presetN; ++i)
-        if( selV==nullptr || selV[i] )
-        {
-          assert( j < rankN );
-          rankV[j]   = presetA[i].order;
-          idxMapA[j] = i;
-          ++j;
-        }
-
-      // if only one element remains to be selected
-      if( rankN == 1 )
-        return idxMapA[0];
-
-      assert( rankN > 1 );
-      
-      unsigned threshV[ rankN ];
-      unsigned uniqueRankV[ rankN ];      
-      unsigned uniqueRankN = 0;
-      unsigned sel_idx = rankN - 1; //
-
-      // for each possible rank value
-      for(unsigned i=0; i<rankN; ++i)
-      {
-        // locate the rank in the uniqueRankV[]
-        unsigned j=0;
-        for(; j<uniqueRankN; ++j)
-          if( uniqueRankV[j]==rankV[i] )
-            break;
-
-        // if the rank was not found then include it here
-        if( j == uniqueRankN )
-          uniqueRankV[uniqueRankN++] = rankV[i];
-
-      }
-
-      // uniqueRankV[] now includes the set of possible rank values
-      
-      // Take the product of all possible values.
-      // (this will be evenly divisible by all values)
-      unsigned prod = vop::prod(uniqueRankV,uniqueRankN);
-
-      unsigned thresh = 0;
-      for(unsigned i=0; i<rankN; ++i)
-        threshV[i] = (thresh += rankV[i] * prod);
-
-      // Thresh is now set to the max possible random value.
-      
-      // Generate a random number between 0 and thresh
-      double   fval = (double)std::rand() * thresh / RAND_MAX;
-
-      unsigned thresh0 = 0;
-      for(unsigned i=0; i<rankN; ++i)
-      {
-        if( thresh0 <= fval && fval < threshV[i] )
-        {
-          sel_idx = i;
-          break;
-        }
-      }
-
-      assert( sel_idx < rankN );
-      
-      return idxMapA[sel_idx];
-    }
-
-    /*
-    unsigned _select_ranked_ele_by_rank_prob( const preset_order_t* rankV, unsigned rankN )
-    {     
-      unsigned threshV[ rankN ];
-      unsigned uniqueRankV[ rankN ];      
-      unsigned uniqueRankN = 0;
-      unsigned sel_idx = rankN - 1; //
-
-      if( rankN == 0 )
-        return kInvalidIdx;
-
-      if( rankN == 1 )
-        return 0;
-
-      // for each possible rank value
-      for(unsigned i=0; i<rankN; ++i)
-      {
-        // locate the rank in the uniqueRankV[]
-        unsigned j=0;
-        for(; j<uniqueRankN; ++j)
-          if( uniqueRankV[j]==rankV[i].order )
-            break;
-
-        // if the rank was not found then include it here
-        if( j == uniqueRankN )
-          uniqueRankV[uniqueRankN++] = rankV[i].order;
-
-      }
-
-      // uniqueRankV[] now includes the set of possible rank values
-      
-      // Take the product of all possible values.
-      // (this will be evenly divisible by all values)
-      unsigned prod = vop::prod(uniqueRankV,uniqueRankN);
-
-      unsigned thresh = 0;
-      for(unsigned i=0; i<rankN; ++i)
-        threshV[i] = (thresh += rankV[i].order * prod);
-
-      // Thresh is now set to the max possible random value.
-      
-      // Generate a random number between 0 and thresh
-      double   fval = (double)std::rand() * thresh / RAND_MAX;
-
-      unsigned thresh0 = 0;
-      for(unsigned i=0; i<rankN; ++i)
-      {
-        if( thresh0 <= fval && fval < threshV[i] )
-        {
-          sel_idx = i;
-          break;
-        }
-      }
-
-      return sel_idx;
-    }
-    */
-    
-    const char* _select_ranked_ele_label_by_rank_prob( const preset_order_t* rankV, const bool* selA, unsigned rankN )
-    {
-      unsigned sel_idx;
-
-      if((sel_idx = _select_ranked_ele_by_rank_prob( rankV, selA, rankN )) == kInvalidIdx )
-      {
-        cwLogWarning("The multi-preset select function failed. Selecting preset 0.");
-        sel_idx = 0;
-      }
-
-      return rankV[sel_idx].preset_label;
-
-    }
-    
-
-    double _calc_multi_preset_dual_coeff( const multi_preset_selector_t& mps )
-    {
-      double result = 0;
-      unsigned resultN = 0;
-      
-      if( mps.coeffN == 0 )
-      {
-        result = 0.5;
-      }
-      else
-      {  
-        for(unsigned i=0; i<mps.coeffN; ++i)
-        {
-          /*
-
-            Temporarily commented out because coeffV[] values
-            have already been normalized.
-            
-          double norm_factor = (mps.coeffMaxV[i] - mps.coeffMinV[i]);
-          
-          if( norm_factor <= 0 )
-            cwLogWarning("Invalid normalization factor in aggregated distance measurement.");
-          else
-            norm_factor = 1;
-          
-          
-          result += std::max( mps.coeffMinV[i], std::min( mps.coeffMaxV[i], mps.coeffV[i] ) ) / norm_factor;
-          */
-
-          // WOULD DISTANCE BE BETTER THAN AVERAGE????
-          
-          if( mps.coeffV[i] != 0 )
-          {
-            result += mps.coeffV[i];
-            resultN += 1;
-          }
-        }
-
-        if( resultN <= 0 )
-            cwLogWarning("Invalid normalization factor in aggregated distance measurement.");
-        else
-          result = std::min(1.0,std::max(0.0,result/mps.coeffN));
-      }
-      
-      
-      return result;
-    }
-    
-    rc_t _find_network_preset_instance_pair( flow_t* p, const char* preset_label, const char* instance_label, const object_t*& preset_val_ref )
-    {
-      rc_t rc = kOkRC;
-      const object_t* net_preset_pair = nullptr;
-      
-      preset_val_ref = nullptr;
-  
-      // locate the cfg of the requested preset
-      if((net_preset_pair = _find_network_preset(p, preset_label )) == nullptr )
-      {
-        rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", cwStringNullGuard(preset_label) );
-        goto errLabel;
-      }
-
-      // locate the instance matching 'instance_label'.
-      for(unsigned i=0; i<net_preset_pair->child_count(); ++i)
-      {
-        const object_t* inst_pair;
-        if((inst_pair = net_preset_pair->child_ele(i)) != nullptr && inst_pair->is_pair() && textIsEqual(inst_pair->pair_label(),instance_label) )
-        {      
-
-          preset_val_ref = inst_pair->pair_value();
-
-          goto errLabel;
-        }
-      }
-  
-      rc = cwLogError(kInvalidArgRC,"The preset instance label '%s' was not found.",cwStringNullGuard(preset_label));
-  
-    errLabel:
-      return rc;
-    }
   }
 }
 
@@ -1560,14 +371,15 @@ void cw::flow::print_external_device( const external_device_t* dev )
 }
 
 
+
 cw::rc_t cw::flow::create( handle_t&          hRef,
                            const object_t&    classCfg,
-                           const object_t&    networkCfg,
+                           const object_t&    flowCfg,
                            external_device_t* deviceA,
                            unsigned           deviceN )
 {
   rc_t            rc               = kOkRC;
-  const object_t* network          = nullptr; 
+  const object_t* networkCfg       = nullptr; 
   bool            printClassDictFl = false;
   bool            printNetworkFl   = false;
   
@@ -1575,7 +387,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
     return rc;
 
   flow_t* p   = mem::allocZ<flow_t>();
-  p->networkCfg = &networkCfg;   // TODO: duplicate cfg?
+  p->flowCfg    = &flowCfg;   // TODO: duplicate cfg?
   p->deviceA    = deviceA;
   p->deviceN    = deviceN;
 
@@ -1587,21 +399,20 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   }
 
   // parse the main audio file processor cfg record
-  if((rc = networkCfg.getv("framesPerCycle",      p->framesPerCycle,
-                           "multiPriPresetProbFl", p->multiPriPresetProbFl,
-                           "multiSecPresetProbFl", p->multiSecPresetProbFl,
-                           "multiPresetInterpFl", p->multiPresetInterpFl,
-                           "network",             network)) != kOkRC )
+  if((rc = flowCfg.getv("framesPerCycle",      p->framesPerCycle,
+                        "multiPriPresetProbFl", p->multiPriPresetProbFl,
+                        "multiSecPresetProbFl", p->multiSecPresetProbFl,
+                        "multiPresetInterpFl", p->multiPresetInterpFl,
+                        "network",             networkCfg)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the required flow configuration parameters.");
     goto errLabel;
   }
 
   // parse the optional args
-  if((rc = networkCfg.getv_opt("maxCycleCount",    p->maxCycleCount,
-                               "printClassDictFl", printClassDictFl,
-                               "printNetworkFl",   printNetworkFl,
-                               "presets",          p->presetCfg)) != kOkRC )
+  if((rc = flowCfg.getv_opt("maxCycleCount",    p->maxCycleCount,
+                            "printClassDictFl", printClassDictFl,
+                            "printNetworkFl",   printNetworkFl)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the optional flow configuration parameters.");
     goto errLabel;
@@ -1624,22 +435,15 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   if( printClassDictFl )
       class_dict_print( p );
 
-  // build the network
-  for(unsigned i=0; i<network->child_count(); ++i)
+  // instantiate the network
+  if((rc = network_create(p,networkCfg,p->net)) != kOkRC )
   {
-    const object_t* inst_cfg = network->child_ele(i);
-
-    // create the instance
-    if( (rc= _create_instance( p, inst_cfg ) ) != kOkRC )
-    {
-      rc = cwLogError(rc,"The instantiation at proc index %i is invalid.",i);
-      goto errLabel;
-      
-    }
+    rc = cwLogError(rc,"Network creation failed.");
+    goto errLabel;
   }
 
   if( printNetworkFl )
-    network_print(p);
+    network_print(p->net);
 
   hRef.set(p);
   
@@ -1689,7 +493,7 @@ unsigned cw::flow::preset_cfg_flags( handle_t h )
 
 cw::rc_t cw::flow::exec_cycle( handle_t h )
 {
-  return _exec_cycle(_handleToPtr(h));
+  return exec_cycle(_handleToPtr(h)->net);
 }
 
 cw::rc_t cw::flow::exec(    handle_t h )
@@ -1699,7 +503,7 @@ cw::rc_t cw::flow::exec(    handle_t h )
 
   while( true )
   {  
-    rc = _exec_cycle(p);
+    rc = exec_cycle(p->net);
 
     if( rc == kEofRC )
     {
@@ -1720,418 +524,53 @@ cw::rc_t cw::flow::exec(    handle_t h )
 
 cw::rc_t cw::flow::apply_preset( handle_t h, const char* presetLabel )
 {
-  rc_t    rc = kOkRC;
   flow_t* p  = _handleToPtr(h);
-  const object_t* net_preset_value;
-  const object_t* preset_pair;
-
-  // locate the cfg of the requested preset
-  if((net_preset_value = _find_network_preset(p, presetLabel )) == nullptr )
-  {
-    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", presetLabel );
-    goto errLabel;
-  }
-
-  // for each instance in the preset
-  for(unsigned i=0; i<net_preset_value->child_count(); ++i)
-  {
-    // get the instance label/value pair
-    if((preset_pair = net_preset_value->child_ele(i)) != nullptr && preset_pair->is_pair() )
-    {
-      const char* inst_label = preset_pair->pair_label();
-      const object_t* preset_value_cfg = preset_pair->pair_value();
-      instance_t* inst;
-
-      // locate the instance
-      if((inst = instance_find(p,inst_label)) == nullptr )
-      {
-        rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel);
-        goto errLabel;
-      }
-
-      // if the preset value is a string then look it up in the class dictionary
-      if( preset_value_cfg->is_string() )
-      {
-        const char* class_preset_label;
-        preset_value_cfg->value(class_preset_label);
-        _class_preset_channelize_vars(inst, class_preset_label );
-      }
-      else
-      {
-        // if the preset value is a dict then apply it directly
-        if( preset_value_cfg->is_dict() )
-        {
-          if((rc =  _preset_channelize_vars( inst, "network", presetLabel, preset_value_cfg )) != kOkRC )
-          {
-            rc = cwLogError(rc,"The preset  '%s' application failed on instance '%s'.", presetLabel, inst_label );
-            goto errLabel;
-          }
-          
-        }
-        else
-        {
-          rc = cwLogError(kSyntaxErrorRC,"The network preset '%s' instance '%s' does not have a string or dictionary value.", presetLabel, inst_label );
-          goto errLabel;
-        }
-      }
-    }
-    else
-    {
-      rc = cwLogError(kSyntaxErrorRC,"The network preset '%s' is malformed.",presetLabel);
-      goto errLabel;        
-    }      
-  }
-
-  cwLogInfo("Activated preset:%s",presetLabel);
- errLabel:
-  return rc;
+  return network_apply_preset(p->net,presetLabel);
 }
 
 cw::rc_t cw::flow::apply_dual_preset( handle_t h, const char* presetLabel_0, const char* presetLabel_1, double coeff )
 {
-  rc_t    rc = kOkRC;
   flow_t* p  = _handleToPtr(h);
-  const object_t* net_preset_value_0;
-
-  cwLogInfo("*** Applying dual: %s %s : %f",presetLabel_0, presetLabel_1, coeff );
-  
-  // locate the cfg of the requested preset
-  if((net_preset_value_0 = _find_network_preset(p, presetLabel_0 )) == nullptr )
-  {
-    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", presetLabel_0 );
-    goto errLabel;
-  }
-
-  // for each instance in the preset
-  for(unsigned i=0; i<net_preset_value_0->child_count(); ++i)
-  {
-    const object_t* preset_pair_0      = net_preset_value_0->child_ele(i);
-    const char*     inst_label         = preset_pair_0->pair_label(); 
-    const object_t* preset_value_cfg_0 = preset_pair_0->pair_value();
-    instance_t*     inst               = nullptr;
-    const object_t* preset_value_cfg_1 = nullptr;
-    const int two = 2;
-    const char* class_preset_labelA[two];
-    
-    // get the instance label/value pair
-    if((preset_pair_0 = net_preset_value_0->child_ele(i)) == nullptr || !preset_pair_0->is_pair() )
-    {
-      rc = cwLogError(kSyntaxErrorRC,"An invalid preset value pair was encountered in '%s'.",presetLabel_0);
-      goto errLabel;
-    }
-
-    // verify that the preset value is a string or dict
-    if( preset_pair_0->pair_value()==nullptr || (!preset_value_cfg_0->is_dict() && !preset_value_cfg_0->is_string() ))
-    {
-      rc = cwLogError(kSyntaxErrorRC,"The preset value pair for instance '%s' in '%s' is not a 'dict' or 'string'.",inst_label,presetLabel_0);
-      goto errLabel;
-    }
-
-    // locate the instance associated with the primary and secondary preset
-    if((inst = instance_find(p,inst_label)) == nullptr )
-    {
-      rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",cwStringNullGuard(inst_label),cwStringNullGuard(presetLabel_0));
-      goto errLabel;
-    }
-            
-    // locate the second instance/preset value pair 
-    if((rc = _find_network_preset_instance_pair( p, presetLabel_1, inst_label, preset_value_cfg_1 )) != kOkRC )
-    {
-      rc = cwLogError(kInvalidIdRC,"The second network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel_1);
-      goto errLabel;
-    }
-    
-    // TODO: We require that the instance presets both be of the same type: string or dict.
-    // There's no good reason for this, as string's resolve to class dict presets anyway.
-    // Fix this!
-    if( !(preset_value_cfg_0->is_dict() == preset_value_cfg_1->is_dict() && preset_value_cfg_0->is_string() == preset_value_cfg_1->is_string()) )
-    {
-      rc = cwLogError(kInvalidIdRC,"The value type (string or dict) of dual network presets must match. (%s != %s)",preset_value_cfg_0->type->label,preset_value_cfg_1->type->label);
-      goto errLabel;
-    }
-
-    preset_value_cfg_0->value(class_preset_labelA[0]);
-    preset_value_cfg_1->value(class_preset_labelA[1]);
-    
-    
-    // if the preset value is a string then look it up in the class dictionary
-    if( preset_value_cfg_0->is_string() )
-    {
-      rc = _class_multi_preset_channelize_vars(inst, class_preset_labelA, two, coeff );        
-    }
-    else
-    {
-      assert( preset_value_cfg_1->is_dict() );
-        
-      const object_t* preset_value_cfgA[] = { preset_value_cfg_0, preset_value_cfg_1};
-                  
-      if((rc =  _multi_preset_channelize_vars( inst, "network", class_preset_labelA, preset_value_cfgA, two, coeff )) != kOkRC )
-      {
-        rc = cwLogError(rc,"The dual preset  '%s':'%s' application failed on instance '%s'.", cwStringNullGuard(class_preset_labelA[0]), cwStringNullGuard(class_preset_labelA[1]), inst_label );
-        goto errLabel;
-      }
-    }
-  }
-
-  
- errLabel:
-
-  if( rc != kOkRC )
-    rc = cwLogError(rc,"The dual preset  '%s':'%s' application failed.", cwStringNullGuard(presetLabel_0), cwStringNullGuard(presetLabel_1) );
-
-  return rc;
+  return network_apply_dual_preset(p->net,presetLabel_0, presetLabel_1, coeff );
 }
 
 cw::rc_t cw::flow::apply_preset( handle_t h, const multi_preset_selector_t& mps )
 {
-  rc_t        rc        = kOkRC;
-  const char* label0    = nullptr;
-  const char* label1    = nullptr;
-  bool        priProbFl = cwIsFlag(mps.flags, kPriPresetProbFl );
-  bool        secProbFl = cwIsFlag(mps.flags, kSecPresetProbFl );
-  bool        interpFl  = cwIsFlag(mps.flags, kInterpPresetFl );
-
-  //printf("preset flags: pri:%i sec:%i interp:%i\n",priProbFl,secProbFl,interpFl);
-  
- // verify that the set of candidate presets is not empty
-  if( mps.presetN == 0 )
-  {
-    cwLogError(kInvalidArgRC,"A multi-preset application was requested but no presets were provided.");
-    goto errLabel;    
-  }
-
-  // if only a single candidate preset exists or needs to be selected
-  if( interpFl==false || mps.presetN==1 )
-  {
-    // if only a single candidate preset is available or pri. probablity is not enabled 
-    if( mps.presetN == 1 || priProbFl==false )
-      label0 = mps.presetA[0].preset_label;
-    else
-    {
-      if( priProbFl )
-        label0 = _select_ranked_ele_label_by_rank_prob( mps.presetA, nullptr, mps.presetN );
-      else
-        label0 = mps.presetA[0].preset_label;
-    }
-  }
-  else  // interpolation has been selected and at least 2 presets exist
-  {    
-    unsigned pri_sel_idx = 0;
-        
-    // select the primary preset
-    if( priProbFl )
-      pri_sel_idx = _select_ranked_ele_by_rank_prob( mps.presetA, nullptr, mps.presetN );
-    else
-    {
-      // select all presets assigned to order == 1
-      bool selA[ mps.presetN ];
-      for(unsigned i=0; i<mps.presetN; ++i)
-        selA[i]= mps.presetA[i].order==1;
-
-      // select the preset among all presets marked as 1
-      pri_sel_idx = _select_ranked_ele_by_rank_prob( mps.presetA, selA, mps.presetN );
-    }
-
-    if( pri_sel_idx == kInvalidIdx )
-      pri_sel_idx    = 0;
-    
-    // the primary preset has now been selected
-
-    // if there is only one candidate secondary preset
-    if( mps.presetN == 2)
-    {
-      assert( pri_sel_idx <= 1 );
-      label1  = mps.presetA[ pri_sel_idx == 0 ? 1 : 0 ].preset_label;
-    }
-    else                        // at least two remaining presets exist to select between
-    {
-      // mark the selected primary preset as not-available
-      bool selA[ mps.presetN ];
-      vop::fill(selA,mps.presetN,true);
-      selA[pri_sel_idx] = false;
-
-      // if the second preset should be selected probabilistically
-      if( secProbFl )
-        label1 = _select_ranked_ele_label_by_rank_prob( mps.presetA, selA, mps.presetN );
-      else 
-      {
-        // select the best preset that is not the primary preset
-        for(unsigned i=0; i<mps.presetN; ++i)
-          if( i != pri_sel_idx )
-          {
-            label1 = mps.presetA[i].preset_label;
-            break;
-          }
-        
-      }
-    }
-    
-    assert( pri_sel_idx != kInvalidIdx );
-    label0               = mps.presetA[ pri_sel_idx ].preset_label;
-  }
-    
-  assert(label0 != nullptr );
-  
-  if( label1 == nullptr )
-  {
-    rc = apply_preset( h, label0 );
-  }
-  else
-  {
-    double coeff = _calc_multi_preset_dual_coeff(mps);
-    rc = apply_dual_preset( h, label0, label1, coeff );
-  }
-  
-
-errLabel:
-  return rc;
+  flow_t* p  = _handleToPtr(h);
+  return network_apply_preset(p->net,mps);
 }
 
 
-/*
-cw::rc_t cw::flow::apply_preset( handle_t h, const multi_preset_selector_t& multi_preset_sel )
-{
-  rc_t        rc                   = kOkRC;
-  const char* label0               = nullptr;
-  const char* label1               = nullptr;
-  const char* prob_label           = nullptr;
-  bool        multiPriPresetProbFl = cwIsFlag(multi_preset_sel.flags, kPriPresetProbFl );
-  bool        multiSecPresetProbFl = cwIsFlag(multi_preset_sel.flags, kSecPresetProbFl );
-  bool        multiPresetInterpFl  = cwIsFlag(multi_preset_sel.flags, kInterpPresetFl );
-
-  // verify that the set of presets to select from is not empty
-  if( multi_preset_sel.presetN == 0 )
-  {
-    cwLogError(kInvalidArgRC,"A multi-preset application was requested but no presets were provided.");
-    goto errLabel;    
-  }
-
-  // if probabistic selection was requested and is possible
-  if( multiPresetProbFl && multi_preset_sel.presetN > 1 )
-  {    
-    auto presetA  = multi_preset_sel.presetA;
-    auto presetN = multi_preset_sel.presetN;
-
-    // if we are interpolating then the base preset is always the first one in presetA[]
-    // so do not include it as a candidate for probabilistic selection
-    if( multiPresetInterpFl  )
-    {
-      presetA += 1;
-      presetN -= 1;
-      
-      // if only one preset remains in the list then prob. selection is not possible
-      if( presetN == 1 )
-        prob_label = presetA[0].preset_label;
-    }
-
-    // select a preset based using the ranked-prob. algorithm.
-    if( prob_label == nullptr )
-    {
-      unsigned prob_sel_idx;
-      
-      if((prob_sel_idx = _select_ranked_ele_by_rank_prob( presetA, presetN )) == kInvalidIdx )
-        rc = cwLogWarning("The multi-preset select function failed. Selecting preset 0.");
-      else
-      {
-        prob_label = presetA[prob_sel_idx].preset_label;
-        
-        cwLogInfo("Multi-preset prob. select:%s :  %i from %i",
-                  cwStringNullGuard(prob_label),
-                  prob_sel_idx,
-                  multi_preset_sel.presetN );
-        
-      }
-    }
-  }
-
-  // prob_label now holds a probablistically selected preset label
-  // or null if prob. sel. was not requested or failed
-  
-  switch( multi_preset_sel.presetN )
-  {
-    case 0:
-      assert(0); // we avoided this case at the top of the function
-      break;
-      
-    case 1:
-      // if there is only one preset to select from 
-      label0 = multi_preset_sel.presetA[0].preset_label;
-      break;
-
-    default:
-      // There are at least two presets ...
-      // ... and prob. select was not requested or failed
-      if( prob_label  == nullptr )
-      {
-        label0 = multi_preset_sel.presetA[0].preset_label;
-        label1 = multiPresetInterpFl ? multi_preset_sel.presetA[1].preset_label : nullptr;
-      }
-      else // ... and a prob. selection exists
-      {
-        // if we need two presets 
-        if( multiPresetInterpFl )
-        {
-          label0 = multi_preset_sel.presetA[0].preset_label; 
-          label1 = prob_label;
-        }          
-        else // otherwise we need only one
-        {
-          label0 = prob_label;
-          label1 = nullptr;
-        }        
-      }      
-  }
-  
-  if( label0 == nullptr )
-  {
-    rc = cwLogError(kInvalidStateRC,"The selected multi-preset label is empty.");
-    goto errLabel;
-  }
-
-  if( label1 == nullptr )
-  {
-    rc = apply_preset( h, label0 );
-  }
-  else
-  {
-    double coeff = _calc_multi_preset_dual_coeff(multi_preset_sel);
-    rc = apply_dual_preset( h, label0, label1, coeff );
-  }
-  
-errLabel:  
-  return rc;
-}
-*/
 
 cw::rc_t cw::flow::set_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, bool value )
-{ return _set_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, value ); }
+{ return set_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, value ); }
 
 cw::rc_t cw::flow::set_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, int value )
-{ return _set_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, value ); }
+{ return set_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, value ); }
 
 cw::rc_t cw::flow::set_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, unsigned value )
-{ return _set_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, value ); }
+{ return set_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, value ); }
 
 cw::rc_t cw::flow::set_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, float value )
-{ return _set_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, value ); }
+{ return set_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, value ); }
 
 cw::rc_t cw::flow::set_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, double value )
-{ return _set_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, value ); }
+{ return set_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, value ); }
 
 cw::rc_t cw::flow::get_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, bool& valueRef )
-{ return _get_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, valueRef ); }
+{ return get_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, valueRef ); }
 
 cw::rc_t cw::flow::get_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, int& valueRef )
-{ return _get_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, valueRef ); }
+{ return get_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, valueRef ); }
 
 cw::rc_t cw::flow::get_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, unsigned& valueRef )
-{ return _get_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, valueRef ); }
+{ return get_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, valueRef ); }
 
 cw::rc_t cw::flow::get_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, float& valueRef )
-{ return _get_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, valueRef ); }
+{ return get_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, valueRef ); }
 
 cw::rc_t cw::flow::get_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, double& valueRef )
-{ return _get_variable_value( _handleToPtr(h), inst_label, var_label, chIdx, valueRef ); }
+{ return get_variable_value( _handleToPtr(h)->net, inst_label, var_label, chIdx, valueRef ); }
 
 
 
@@ -2148,7 +587,7 @@ void cw::flow::print_network( handle_t h )
   for(unsigned i=0; i<p->deviceN; ++i)
     print_external_device( p->deviceA + i );
   
-  network_print(p);
+  network_print(p->net);
 }
 
 
diff --git a/cwFlow.h b/cwFlow.h
index 945840b..51a767c 100644
--- a/cwFlow.h
+++ b/cwFlow.h
@@ -8,64 +8,6 @@ namespace cw
 
     typedef handle<struct flow_str> handle_t;
 
-    enum
-    {
-      kAudioDevTypeId,
-      kMidiDevTypeId,
-      kSerialDevTypeId,
-      kSocketDevTypeId
-    };
-
-    enum
-    {
-      kInFl  = 0x01,
-      kOutFl = 0x02
-    };
-
-
-    struct abuf_str;
-
-    typedef struct audio_dev_cfg_str
-    {
-      struct abuf_str* abuf;  // Buffer to receive incoming or send outgoing audio for this device
-                              // The audio_in/audio_out proc's locate and use these buffers.
-    } audio_dev_cfg_t;
-
-    struct external_device_str;
-    
-    typedef rc_t (*send_midi_triple_func_t)( struct external_device_str* dev, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 );
-    
-    typedef struct midi_dev_cfg_str
-    {
-      // msgArray[] contains the current msgs for all devices NOT just the device that this record is embedded in.
-      // We do this so that the order of messages as they arrived is maintained.  Otherwise, to achieve this ordering,
-      // the messages for all devices would need to be collected and sorted by time.
-      const midi::ch_msg_t*   msgArray;  
-      unsigned                msgCnt;
-
-      unsigned                maxMsgCnt; // max possible value of msgCnt
-      send_midi_triple_func_t sendTripleFunc;
-    } midi_dev_cfg_t;
-
-    // Generate external device record
-    typedef struct external_device_str
-    {
-      void*       reserved;
-      const char* devLabel;   // IO framework device label
-      const char* portLabel;  // IO framework MIDI port label (only used by MIDI devices)
-      unsigned    typeId;     // see ???DevTypeId above
-      unsigned    flags;      // see ???Fl above
-      
-      unsigned    ioDevIdx;   // IO framework device index
-      unsigned    ioPortIdx;  // IO framework MIDI port index (only used by MIDI devices)
-      
-      union
-      {
-        audio_dev_cfg_t a; // audio devices use this record
-        midi_dev_cfg_t  m; // MIDI     "     "   "     " 
-      } u;
-        
-    } external_device_t;
 
 
     void print_abuf( const struct abuf_str* abuf );
@@ -86,11 +28,11 @@ namespace cw
     rc_t exec_cycle( handle_t h );
 
     // Run the network to completion.
-    rc_t exec(    handle_t h );
+    rc_t exec(    handle_t h ); 
 
     rc_t apply_preset( handle_t h, const char* presetLabel );
-    rc_t apply_preset( handle_t h, const multi_preset_selector_t& multi_preset_sel );
     rc_t apply_dual_preset( handle_t h, const char* presetLabel_0, const char* presetLabel_1, double coeff );
+    rc_t apply_preset( handle_t h, const multi_preset_selector_t& multi_preset_sel );
 
         
     rc_t set_variable_value( handle_t h, const char* inst_label, const char* var_label, unsigned chIdx, bool value     );
diff --git a/cwFlowDecl.h b/cwFlowDecl.h
index 7303f99..044cf24 100644
--- a/cwFlowDecl.h
+++ b/cwFlowDecl.h
@@ -5,6 +5,67 @@ namespace cw
 {
   namespace flow
   {
+
+    enum
+    {
+      kAudioDevTypeId,
+      kMidiDevTypeId,
+      kSerialDevTypeId,
+      kSocketDevTypeId
+    };
+
+    enum
+    {
+      kInFl  = 0x01,
+      kOutFl = 0x02
+    };
+
+
+    struct abuf_str;
+
+    typedef struct audio_dev_cfg_str
+    {
+      struct abuf_str* abuf;  // Buffer to receive incoming or send outgoing audio for this device
+                              // The audio_in/audio_out proc's locate and use these buffers.
+    } audio_dev_cfg_t;
+
+    struct external_device_str;
+    
+    typedef rc_t (*send_midi_triple_func_t)( struct external_device_str* dev, uint8_t ch, uint8_t status, uint8_t d0, uint8_t d1 );
+    
+    typedef struct midi_dev_cfg_str
+    {
+      // msgArray[] contains the current msgs for all devices NOT just the device that this record is embedded in.
+      // We do this so that the order of messages as they arrived is maintained.  Otherwise, to achieve this ordering,
+      // the messages for all devices would need to be collected and sorted by time.
+      const midi::ch_msg_t*   msgArray;  
+      unsigned                msgCnt;
+
+      unsigned                maxMsgCnt; // max possible value of msgCnt
+      send_midi_triple_func_t sendTripleFunc;
+    } midi_dev_cfg_t;
+
+    // Generate external device record
+    typedef struct external_device_str
+    {
+      void*       reserved;
+      const char* devLabel;   // IO framework device label
+      const char* portLabel;  // IO framework MIDI port label (only used by MIDI devices)
+      unsigned    typeId;     // see ???DevTypeId above
+      unsigned    flags;      // see ???Fl above
+      
+      unsigned    ioDevIdx;   // IO framework device index
+      unsigned    ioPortIdx;  // IO framework MIDI port index (only used by MIDI devices)
+      
+      union
+      {
+        audio_dev_cfg_t a; // audio devices use this record
+        midi_dev_cfg_t  m; // MIDI     "     "   "     " 
+      } u;
+        
+    } external_device_t;
+
+    
     enum {
       kPriPresetProbFl   = 0x01,
       kSecPresetProbFl   = 0x02,
diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
new file mode 100644
index 0000000..19be4ec
--- /dev/null
+++ b/cwFlowNet.cpp
@@ -0,0 +1,2279 @@
+#include "cwCommon.h"
+#include "cwLog.h"
+#include "cwCommonImpl.h"
+#include "cwMem.h"
+#include "cwText.h"
+#include "cwNumericConvert.h"
+#include "cwObject.h"
+
+#include "cwAudioFile.h"
+#include "cwVectOps.h"
+#include "cwMtx.h"
+#include "cwDspTypes.h" // real_t, sample_t
+#include "cwTime.h"
+#include "cwMidiDecls.h"
+#include "cwFlowDecl.h"
+#include "cwFlowTypes.h"
+#include "cwFlowNet.h"
+#include "cwFlowProc.h"
+
+namespace cw
+{
+  namespace flow
+  {
+
+    void _destroy_inst( instance_t* inst )
+    {
+      if( inst == nullptr )
+        return;
+      
+      if( inst->class_desc->members->destroy != nullptr && inst->userPtr != nullptr )
+        inst->class_desc->members->destroy( inst );
+
+      // destroy the instance variables
+      variable_t* var0 = inst->varL;
+      variable_t* var1 = nullptr;      
+      while( var0 != nullptr )
+      {
+        var1 = var0->var_link;
+        _var_destroy(var0);
+        var0 = var1;
+      }
+      
+      inst->varL = nullptr;
+      
+      mem::release(inst->label);
+      mem::release(inst->varMapA);
+      mem::release(inst);
+    }
+
+    rc_t _network_destroy( network_t& net )
+    {
+      rc_t rc = kOkRC;
+
+      for(unsigned i=0; i<net.proc_arrayN; ++i)
+        _destroy_inst(net.proc_array[i]);
+
+      mem::release(net.proc_array);
+      net.proc_arrayAllocN = 0;
+      net.proc_arrayN = 0;
+      
+      return rc;
+    }
+
+    rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef );
+
+    void _connect_vars( variable_t* src_var, variable_t* in_var )
+    {
+      // connect in_var into src_var's outgoing var chain
+      in_var->connect_link  = src_var->connect_link;
+      src_var->connect_link = in_var;
+
+      assert( src_var->value != nullptr );
+          
+      in_var->value    = src_var->value;
+      in_var->src_var = src_var;
+    }
+
+    rc_t _create_instance_var_map( instance_t* inst )
+    {
+      rc_t        rc        = kOkRC;
+      unsigned    max_vid   = kInvalidId;
+      unsigned    max_chIdx = 0;
+      variable_t* var       = inst->varL;
+      //variable_t* v0        = nullptr;
+      
+      // determine the max variable vid and max channel index value among all variables
+      for(; var!=nullptr; var = var->var_link )
+      {
+        if( var->vid != kInvalidId )
+        {
+          if( max_vid == kInvalidId || var->vid > max_vid )
+            max_vid = var->vid;
+
+          if( var->chIdx != kAnyChIdx && (var->chIdx+1) > max_chIdx )
+            max_chIdx = (var->chIdx + 1);
+
+        }
+      }
+
+      // If there are any variables
+      if( max_vid != kInvalidId )
+      {
+        // create the variable map array
+        inst->varMapChN = max_chIdx + 1;
+        inst->varMapIdN = max_vid + 1;
+        inst->varMapN   = inst->varMapIdN * inst->varMapChN;
+        inst->varMapA   = mem::allocZ<variable_t*>( inst->varMapN );
+
+        // assign each variable to a location in the map
+        for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+          if( var->vid != kInvalidId )
+          {
+            unsigned idx = kInvalidIdx;
+
+            if((rc = _var_map_id_to_index( inst, var->vid, var->chIdx, idx )) != kOkRC )
+              goto errLabel;
+
+          
+            // verify that there are not multiple variables per map position          
+            if( inst->varMapA[ idx ] != nullptr )
+            {
+              variable_t* v0 = inst->varMapA[idx];
+              rc = cwLogError(kInvalidStateRC,"The variable '%s' id:%i ch:%i and '%s' id:%i ch:%i share the same variable map position on instance: %s. This is usually cased by duplicate variable id's.",
+                              v0->label,v0->vid,v0->chIdx, var->label,var->vid,var->chIdx,inst->label);
+
+              goto errLabel;
+            }
+
+            // assign this variable to a map position
+            inst->varMapA[ idx ] = var;
+
+            if( var->chIdx != kAnyChIdx && var->value == nullptr )
+            {
+              rc = cwLogError(kInvalidStateRC,"The value of the variable '%s' ch:%i on instance:'%s' has not been set.",var->label,var->chIdx,inst->label);
+              goto errLabel;
+            }
+
+          }
+        
+      }
+
+    errLabel:
+      return rc;
+      
+    }
+
+    void _complete_input_connections( instance_t* inst )
+    {
+      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+        if(var->chIdx == kAnyChIdx && is_connected_to_external_proc(var) )
+        {
+
+          variable_t* base_src_var = var->src_var;
+
+          // since 'var' is on the 'any' channel the 'src' var must also be on the 'any' channel
+          assert( base_src_var->chIdx == kAnyChIdx );
+          
+          //printf("%s %s\n",inst->label,var->label);
+          
+          // for each var channel in the input var
+          for(variable_t* in_var = var->ch_link; in_var != nullptr; in_var=in_var->ch_link)
+          {
+            // locate the matching channel on the 'src' var
+            variable_t* svar = base_src_var;
+            for(; svar!=nullptr; svar=svar->ch_link)
+              if( svar->chIdx == in_var->chIdx )
+                break;
+
+            // connect the src->input var
+            _connect_vars( svar==nullptr ? base_src_var : svar, in_var);
+          }
+        }
+    }
+    
+    rc_t _call_value_func_on_all_variables( instance_t* inst )
+    {
+      rc_t rc  = kOkRC;
+      rc_t rc1 = kOkRC;
+      
+      for(unsigned i=0; i<inst->varMapN; ++i)
+        if( inst->varMapA[i] != nullptr && inst->varMapA[i]->vid != kInvalidId )
+        {
+          variable_t* var = inst->varMapA[i];
+          
+          if((rc = var->inst->class_desc->members->value( var->inst, var )) != kOkRC )
+            rc1 = cwLogError(rc,"The proc instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->inst->label, var->inst->label_sfx_id, var->label, var->chIdx );
+        }
+      
+      return rc1;
+    }
+
+    rc_t _var_channelize( instance_t* inst, const char* preset_label,  const char* type_src_label, const char* value_label, const object_t* value )
+    {
+      rc_t rc = kOkRC;
+      
+      variable_t*     dummy       = nullptr;
+
+      // verify that a valid value exists
+      if( value == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"Unexpected missig value on %s preset '%s' instance '%s' variable '%s'.", type_src_label, preset_label, inst->label, cwStringNullGuard(value_label) );
+        goto errLabel;
+      }
+
+      // if a list of values was given
+      if( value->is_list() )
+      {
+        for(unsigned chIdx=0; chIdx<value->child_count(); ++chIdx)
+          if((rc = var_channelize( inst, value_label, kBaseSfxId, chIdx, value->child_ele(chIdx), kInvalidId, dummy )) != kOkRC )
+            goto errLabel;
+      }
+      else // otherwise a single value was given
+      {          
+        if((rc = var_channelize( inst, value_label, kBaseSfxId, kAnyChIdx, value, kInvalidId, dummy )) != kOkRC )
+          goto errLabel;
+      }
+
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _preset_channelize_vars( instance_t* inst, const char* type_src_label, const char* preset_label, const object_t* preset_cfg )
+    {
+      rc_t rc = kOkRC;
+
+      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), inst->label );
+      
+      // validate the syntax of the preset record
+      if( !preset_cfg->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", preset_label, type_src_label, inst->class_desc->label );
+        goto errLabel;
+      }
+
+
+      // for each preset variable
+      for(unsigned i=0; i<preset_cfg->child_count(); ++i)
+      {
+        const object_t* value       = preset_cfg->child_ele(i)->pair_value();
+        const char*     value_label = preset_cfg->child_ele(i)->pair_label();
+        if((rc = _var_channelize( inst, preset_label, type_src_label, value_label, value )) != kOkRC )
+          goto errLabel;
+        
+        
+      }
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(rc,"Apply %s preset failed on instance:%s class:%s preset:%s.", type_src_label, inst->label, inst->class_desc->label, preset_label );
+
+      return rc;
+    }
+
+
+    template< typename T >
+    T _interp_dual_value( T v0, T v1, double coeff )
+    {
+      T y;
+      if( v0 == v1 )
+        y = v0;
+      else
+        y = (T)(v0 + (v1-v0)*coeff );
+
+      //printf("%f %f -> %f\n",(double)v0,(double)v1,(double)y);
+      return y;
+    }
+
+    rc_t _set_var_from_dual_preset_scalar_scalar( instance_t* inst, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff, unsigned chIdx )
+    {
+      rc_t rc = kOkRC;
+      object_t interped_value;
+      variable_t* dummy = nullptr;
+
+      // one of the input values must exist
+      if( scalar_0==nullptr && scalar_1==nullptr )
+      {
+        rc = cwLogError(kInvalidArgRC,"The numeric types of both operands of a dual value are null.");
+        goto errLabel;
+      }
+
+      // It's possible that one or the other input value does not exist
+      if( scalar_0 == nullptr )
+        scalar_0 = scalar_1;
+      else
+      {
+        if( scalar_1 == nullptr )
+          scalar_1 = scalar_0;
+      }
+
+      // verify that the input values are the same type
+      if( scalar_0->type->id != scalar_1->type->id )
+      {
+        rc = cwLogError(kInvalidArgRC,"The numeric types of both operands of a dual value preset must match. (%s != %s).",cwStringNullGuard(scalar_0->type->label),cwStringNullGuard(scalar_1->type->label));
+        goto errLabel;
+      }
+
+      printf("%s:%s :",inst->label,var_label);
+      
+      switch( scalar_0->type->id )
+      {
+        case kInt32TId:
+          interped_value.set_value( _interp_dual_value(scalar_0->u.i32,scalar_1->u.i32,coeff) );
+          break;
+        case kUInt32TId:
+          interped_value.set_value( _interp_dual_value(scalar_0->u.u32,scalar_1->u.u32,coeff) );
+          break;
+        case kInt64TId:
+          assert(0);
+          //interped_value.set_value( _interp_dual_value(scalar_0->u.i64,scalar_1->u.i64,coeff) );          
+          break;
+        case kUInt64TId:
+          assert(0);
+          //interped_value.set_value( _interp_dual_value(scalar_0->u.u64,scalar_1->u.u64,coeff) );          
+          break;
+        case kFloatTId:
+          interped_value.set_value( _interp_dual_value(scalar_0->u.f,scalar_1->u.f,coeff) );          
+          break;
+        case kDoubleTId:
+          interped_value.set_value( _interp_dual_value(scalar_0->u.d,scalar_1->u.d,coeff) );          
+          break;
+          
+        default:
+          rc = cwLogError(kInvalidStateRC,"Preset dual values of type '%s' cannot be interpolated.",cwStringNullGuard(scalar_0->type->label));
+          goto errLabel;
+      }
+
+      
+      if((rc = var_channelize( inst, var_label, kBaseSfxId, chIdx, &interped_value, kInvalidId, dummy )) != kOkRC )
+      {
+        rc = cwLogError(kInvalidArgRC,"Dual value preset application failed.");
+        goto errLabel;
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _set_var_from_dual_preset_list_list( instance_t* inst, const char* var_label, const object_t* list_0, const object_t* list_1, double coeff )
+    {
+      rc_t rc = kOkRC;
+      
+      if( list_0->child_count() != list_1->child_count() )
+        return cwLogError(kInvalidArgRC,"If two lists are to be applied as a dual preset they must be the same length.");
+
+      for(unsigned chIdx=0; chIdx<list_0->child_count(); ++chIdx)
+        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,list_0->child_ele(chIdx),list_1->child_ele(chIdx),coeff,chIdx)) != kOkRC )
+          goto errLabel;
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _set_var_from_dual_preset_scalar_list( instance_t* inst, const char* var_label, const object_t* scalar, const object_t* list, double coeff )
+    {
+      rc_t rc = kOkRC;
+      for(unsigned chIdx=0; chIdx<list->child_count(); ++chIdx)
+        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,scalar,list->child_ele(chIdx),coeff,chIdx)) != kOkRC )
+          goto errLabel;
+      
+    errLabel:
+      return rc;
+    }
+
+    rc_t _set_var_from_dual_preset_list_scalar( instance_t* inst, const char* var_label, const object_t* list, const object_t* scalar, double coeff )
+    {
+      rc_t rc = kOkRC;
+      for(unsigned chIdx=0; chIdx<list->child_count(); ++chIdx)
+        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,list->child_ele(chIdx),scalar,coeff,chIdx)) != kOkRC )
+          goto errLabel;
+      
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _set_var_from_dual_preset_scalar_scalar( instance_t* inst, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff )
+    {
+      return _set_var_from_dual_preset_scalar_scalar(inst,var_label,scalar_0,scalar_1,coeff,kAnyChIdx);
+    }
+    
+
+    rc_t _is_legal_dual_value( const object_t* value )
+    {
+      rc_t rc = kOkRC;
+      
+      if( value->is_list() )
+      {
+        if( value->child_count() == 0 )
+        {
+          rc = cwLogError(kInvalidArgRC,"Empty lists values cannot be applied as part of a dual value preset.");
+          goto errLabel;
+        }
+
+      }
+      else
+      {
+        switch( value->type->id )
+        {
+          case kInt32TId:
+          case kUInt32TId:
+          case kInt64TId:
+          case kUInt64TId:
+          case kFloatTId:
+          case kDoubleTId:
+            break;
+          default:
+            rc = cwLogError(kInvalidArgRC,"Objects of type '%s' cannot be applied as part of a dual value preset.",cwStringNullGuard(value->type->label));
+        }
+      }
+      
+    errLabel:
+      return rc;
+      
+    }
+    
+    rc_t _set_var_from_dual_preset( instance_t* inst, const char* var_label, const object_t* value_0, const object_t* value_1, double coeff )
+    {
+      rc_t rc = kOkRC;
+
+      // dual values must be either numeric scalars or lists
+      if((rc = _is_legal_dual_value(value_0)) != kOkRC || (rc = _is_legal_dual_value(value_1)) != kOkRC)
+         goto errLabel;
+              
+      
+      // if both values are lists then they must be the same length
+      if( value_0->is_list() && value_1->is_list() )
+      {
+        rc = _set_var_from_dual_preset_list_list( inst, var_label, value_0, value_1, coeff );
+        goto errLabel;
+      }
+      else
+      {
+        // if value_0 is a list and value_1 is a scalar
+        if( value_0->is_list() )
+        {
+          rc = _set_var_from_dual_preset_list_scalar( inst, var_label, value_0, value_1, coeff );
+          goto errLabel;
+        }
+        else
+        {
+          // if value_1 is a list and value_0 is a scalar
+          if( value_1->is_list() )
+          {
+            rc = _set_var_from_dual_preset_scalar_list( inst, var_label, value_0, value_1, coeff );
+            goto errLabel;
+          }
+          else // both values are scalars
+          {
+            rc = _set_var_from_dual_preset_scalar_scalar( inst, var_label, value_0, value_1, coeff );
+            goto errLabel;
+          }
+        }
+      }
+
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _multi_preset_channelize_vars( instance_t* inst, const char* type_src_label, const char** presetLabelA, const object_t** preset_cfgA, unsigned presetN, double coeff )
+    {
+      rc_t rc = kOkRC;
+
+      const char* preset_label_0 = "<None>";
+      const char* preset_label_1 = "<None>";
+
+      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), inst->label );
+
+      if( presetN < 2 )
+      {
+        rc = cwLogError(kInvalidArgRC,"There must be at least 2 presets selected to interpolate between preset variable dictionaries.");
+        goto errLabel;
+      }
+
+      if( presetN > 2 )
+      {
+        cwLogWarning("More than two presets dictionaries were specified for interpolation. Only the first two will be used.");
+        goto errLabel;
+      }
+
+      preset_label_0 = presetLabelA[0];
+      preset_label_1 = presetLabelA[1];
+      
+      // validate each of the preset records is a dict
+      for(unsigned i=0; i<presetN; ++i)
+        if( !preset_cfgA[i]->is_dict() )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", presetLabelA[i], type_src_label, inst->class_desc->label );
+          goto errLabel;
+        }
+
+
+      // for each preset variable in the first preset var dict
+      for(unsigned i=0; i<preset_cfgA[0]->child_count(); ++i)
+      {
+        const char*     var_label   = preset_cfgA[0]->child_ele(i)->pair_label();
+        const object_t* value_0     = preset_cfgA[0]->child_ele(i)->pair_value();
+
+        const object_t* value_1     = preset_cfgA[1]->find_child(var_label);
+
+        if( value_0 == nullptr && value_1 == nullptr )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Unexpected missig values on %s preset '%s' instance '%s' variable '%s'.", type_src_label, presetLabelA[0], inst->label, cwStringNullGuard(var_label) );
+          goto errLabel;
+        }
+
+        if( value_0 == nullptr )
+        {
+          cwLogWarning("The preset variable '%s' was not found for the preset: '%s'. Falling back to single value assign.",cwStringNullGuard(var_label),cwStringNullGuard(presetLabelA[0]));
+
+          rc = _var_channelize( inst, preset_label_1, "dual class", var_label, value_1 );
+          goto errLabel;
+        }
+        
+        if( value_1 == nullptr )
+        {
+          cwLogWarning("The preset variable '%s' was not found for the preset: '%s'. Falling back to single value assign.",cwStringNullGuard(var_label),cwStringNullGuard(presetLabelA[1]));
+          
+          rc = _var_channelize( inst, preset_label_0, "dual class", var_label, value_0 );
+          goto errLabel;
+        }
+
+
+        if((rc = _set_var_from_dual_preset( inst, var_label, value_0, value_1, coeff )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Multi preset application failed on variable:%s.",cwStringNullGuard(var_label));
+          goto errLabel;
+        }
+      }
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(rc,"Apply %s multi-preset failed on instance:%s class:%s presetA:%s presetB:%s.", type_src_label, inst->label, inst->class_desc->label, preset_label_0, preset_label_1 );
+
+      return rc;
+    }
+
+
+    rc_t _class_multi_preset_channelize_vars(instance_t* inst, const char** class_preset_labelA, unsigned presetN, double coeff )
+    {
+      rc_t            rc = kOkRC;
+      const object_t* presetCfgA[ presetN ];
+      const char*     presetLabelA[ presetN ];
+      unsigned        presetCfgN = 0;
+      
+      for(unsigned i=0; i<presetN; ++i)
+      {
+        if( class_preset_labelA[i] != nullptr )
+        {
+          const preset_t* pr;
+          
+          // locate the requestd preset record
+          if((pr = class_preset_find(inst->class_desc, class_preset_labelA[i])) == nullptr )
+          {
+            rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the instance '%s'.", class_preset_labelA[i], inst->label);
+            goto errLabel;
+          }
+
+          if( pr->cfg == nullptr )
+          {
+            rc = cwLogError(kInvalidIdRC,"The value of preset '%s' was empty in instance '%s'.", class_preset_labelA[i], inst->label);
+            goto errLabel;            
+          }
+
+          presetCfgA[  presetCfgN] = pr->cfg;
+          presetLabelA[presetCfgN] = class_preset_labelA[i];
+          presetCfgN++;
+        }
+      }
+
+      // dispatch based on the count of presets located
+      switch( presetCfgN )
+      {
+        case 0:
+          rc = cwLogError(kInvalidArgRC,"No valid class preset records were found while attempting apply a multi-preset.");
+          break;
+          
+        case 1:
+          // only one valid preset was located - apply it directly
+          rc = _preset_channelize_vars( inst, "class", presetLabelA[0], presetCfgA[0]);
+          break;
+          
+        default:
+          // more than one preset was located - apply it's interpolated values
+          rc = _multi_preset_channelize_vars( inst, "class", presetLabelA, presetCfgA, presetCfgN, coeff);
+      }
+      
+      
+    errLabel:                  
+      return rc;
+      
+    }
+    
+    rc_t _class_preset_channelize_vars( instance_t* inst, const char* preset_label )
+    {
+      rc_t            rc = kOkRC;
+      const preset_t* pr;
+
+      if( preset_label == nullptr )
+        return kOkRC;
+      
+      // locate the requestd preset record
+      if((pr = class_preset_find(inst->class_desc, preset_label)) == nullptr )
+      {
+        rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the instance '%s'.", preset_label, inst->label);
+        goto errLabel;
+      }
+      
+      rc = _preset_channelize_vars( inst, "class", preset_label, pr->cfg);
+      
+    errLabel:                  
+      return rc;
+    }
+
+
+    rc_t _class_apply_presets( instance_t* inst, const object_t* preset_labels )
+    {
+      rc_t        rc = kOkRC;
+      const char* s  = nullptr;
+      
+      // if preset_labels is a string
+      if( preset_labels->is_string() && preset_labels->value(s)==kOkRC )
+        return _class_preset_channelize_vars(inst,s);
+
+      // if the preset_labels is not a list
+      if( !preset_labels->is_list() )
+        rc = cwLogError(kSyntaxErrorRC,"The preset list on instance '%s' is neither a list nor a string.",inst->label);
+      else        
+      {
+        // preset_labels is a list.
+        
+        // for each label listed in the preset label list
+        for(unsigned i=0; i<preset_labels->child_count(); ++i)
+        {
+          const object_t* label_obj = preset_labels->child_ele(i);
+
+          // verify that the label is a strng
+          if( !label_obj->is_string() || label_obj->value(s) != kOkRC )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The preset list does not contain string on instance '%s'.",inst->label);
+            goto errLabel;
+          }
+
+          // apply a preset label
+          if((rc = _class_preset_channelize_vars( inst, s)) != kOkRC )
+            goto errLabel;          
+        }
+      }
+      
+    errLabel:
+      return rc;
+    }
+                               
+                                 
+    
+
+    rc_t _proc_inst_args_channelize_vars( instance_t* inst, const char* arg_label, const object_t* arg_cfg )
+    {
+      rc_t rc = kOkRC;
+      
+      if( arg_cfg == nullptr )
+        return rc;
+
+      return _preset_channelize_vars( inst, "instance", arg_label, arg_cfg );
+      
+    }
+
+
+    //=======================================================================================================
+    //
+    // network creation
+    //
+    
+    enum {
+      kInVarTypeId   = 0x01,
+      kSrcProcTypeId = 0x02,
+      kSrcVarTypeId  = 0x04
+    };
+    
+    typedef struct in_ele_str
+    {
+      unsigned typeId;          // See k???_InFl above
+      char*    label;           // label of in or src id
+      unsigned base_sfx_id;     // literal base_sfx_id or kInvalidId if the base_sfx_id was not given or 'is_iter_fl' is false
+      unsigned sfx_id_count;    // literal sfx_id_count or kInvalidCnt if not given
+      unsigned is_iter_fl;      // this id included an '_'
+    } in_ele_t;
+    
+    typedef struct in_stmt_str
+    {
+      in_ele_t    in_var_ele;       // in-var element
+      char*       src_net_label;    // src-net label  (null=in-var net, '_'=root net, string=named net)
+      network_t*  src_net;          // network containing the src-proc
+      in_ele_t    src_proc_ele;     // src-proc element
+      in_ele_t    src_var_ele;      // src-var element
+      var_desc_t* in_var_desc;      // Pointer to the in-var var_desc.
+      bool        create_in_fl;     // True if the in_var needs to be created with an sfx_id, false create the var by the default process (w/o sfx_id)
+      in_ele_t*   iter_cnt_ctl_ele; // Pointer to the ele which is controlling the iteration count (or null if in-var is non-iterating)
+      unsigned    iter_cnt;         // Count of iterations or 0 if in-var is non-iterating.
+    } in_stmt_t;
+
+    typedef struct proc_inst_parse_statestr
+    {
+      const char*     inst_label;       // 
+      const char*     inst_clas_label;  //
+      const char*     arg_label;        //
+      const object_t* preset_labels;    //
+      const object_t* arg_cfg;          //
+      const object_t* in_dict;          // cfg. node to the in-list
+      in_stmt_t*      in_array;         // in_array[ in_arrayN ] in-stmt array
+      unsigned        in_arrayN;        // count of in-stmt's in the in-list.
+    } proc_inst_parse_state_t;
+
+    bool _is_non_null_pair( const object_t* cfg )
+    { return cfg != nullptr && cfg->is_pair() && cfg->pair_label()!=nullptr && cfg->pair_value()!=nullptr; }
+
+    
+    rc_t _parse_in_ele( const char* id_str, in_ele_t& r  )
+    {
+      rc_t rc = kOkRC;
+      unsigned bufN;
+
+      r.base_sfx_id  = kInvalidId;
+      r.sfx_id_count = kInvalidCnt;
+      
+      if((bufN = textLength(id_str)) == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"A blank connection id string was encountered.");
+        goto errLabel;
+      }
+      else
+      {
+        char* underscore = nullptr;
+        char* digit      = nullptr;
+        char  buf[ bufN+1 ];
+
+        // copy the id string into a non-const scratch buffer 
+        textCopy(buf,bufN+1,id_str);
+
+        // locate the last underscore
+        if((underscore = lastMatchChar(buf,'_')) != nullptr )
+        {
+          *underscore  = 0;   // terminate the string prior to the underscore
+          
+          for(digit  = underscore + 1; *digit; digit++)
+            if( !isdigit(*digit) )
+              break;
+
+          // if the underscore was followed by a number
+          // or if the underscore was the last char
+          // in the string - then digit will point to
+          // the terminating zero - otherwise the
+          // underscore did not indicate an iterating id
+          if( *digit != 0 )
+          {
+            *underscore = '_';  // replace the underscore - its part of the label
+            underscore = nullptr;
+          }
+          else
+          {
+            r.is_iter_fl = true;
+
+            // if there is a number following the underscore then this is the secInt
+            if( textLength(underscore + 1) )
+            {
+              // a literal iteration count was given - parse it into an integer
+              if((rc = string_to_number(underscore + 1,r.sfx_id_count)) != kOkRC )
+              {
+                rc = cwLogError(rc,"Unable to parse the secondary integer in the connection label '%s'.",cwStringNullGuard(id_str));
+                goto errLabel;
+              }
+            }              
+          }
+        }
+
+        // verify that some content remains in the id string
+        if( textLength(buf) == 0 )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Unable to parse the connection id string '%s'.",cwStringNullGuard(id_str));
+          goto errLabel;
+        }
+
+        // go backward from the last char until the begin-of-string or a non-digit is found
+        for(digit=buf + textLength(buf)-1; digit>buf; --digit)
+          if(!isdigit(*digit) )
+          {
+            ++digit; // advance to the first digit in the number
+            break;
+          }
+
+        // if a digit was found then this is the 'priInt'
+        if( textLength(digit) )
+        {
+          assert( buf <= digit-1 && digit-1 <= buf + bufN );
+          
+          // a literal base-sfx-id was given - parse it into an integer
+          if((rc = string_to_number(digit,r.base_sfx_id)) != kOkRC )
+          {
+            rc = cwLogError(rc,"Unable to parse the primary integer in the connection label '%s'.",cwStringNullGuard(id_str));
+            goto errLabel;            
+          }
+
+          *digit = 0; // zero terminate the label
+
+        }
+
+        // verify that some content remains in the id string
+        if( textLength(buf) == 0 )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Unexpected invalid connection id string '%s'.",cwStringNullGuard(id_str));
+          goto errLabel;
+
+        }
+        else
+        {
+          // store the label
+          r.label = mem::duplStr(buf);
+        }
+      }
+      
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _calc_src_proc_ele_count(network_t& net, in_ele_t& src_proc_ele, unsigned& cnt_ref)
+    {
+      rc_t rc = kOkRC;
+      cnt_ref = 0;
+      
+      // if a literal proc sfx_id was given then use it otherwise use the default base-sfx-id (0)
+      unsigned sfx_id = src_proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_proc_ele.base_sfx_id;
+      unsigned n;
+      for(n=0; instance_find(net, src_proc_ele.label, sfx_id ) != nullptr; ++n )
+        sfx_id += 1;
+
+      if( n == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The src-proc '%s:%i' was not found.",cwStringNullGuard(src_proc_ele.label),sfx_id);
+        goto errLabel;        
+      }
+
+      cnt_ref = n;
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _calc_src_var_ele_count(network_t& net, const in_ele_t& src_proc_ele, const in_ele_t& src_var_ele, unsigned& cnt_ref)
+    {
+      rc_t              rc          = kOkRC;
+      instance_t*       src_proc    = nullptr;
+      unsigned          proc_sfx_id = src_proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_proc_ele.base_sfx_id;
+
+      cnt_ref = 0;
+
+      // locate the parent proc of this var
+      if((src_proc = instance_find(net,src_proc_ele.label,proc_sfx_id)) == nullptr )
+      {
+        cwLogError(kSyntaxErrorRC,"The src-proc instance '%s:%i' could not be found.",cwStringNullGuard(src_proc_ele.label),proc_sfx_id);
+        goto errLabel;
+      }
+      else
+      {
+        // if a starting var sfx_id was given by the id then use it otherwise use the default base-sfx-id (0)
+        unsigned sfx_id = src_var_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_var_ele.base_sfx_id;
+        unsigned n;
+        for(n=0; var_exists(src_proc,src_var_ele.label, sfx_id, kAnyChIdx ); ++n )
+          sfx_id += 1;
+
+
+        if( n == 0 )
+        {
+          cwLogError(kSyntaxErrorRC,"The src-var '%s:%i' was not found.",cwStringNullGuard(src_var_ele.label),sfx_id);
+          goto errLabel;
+        }
+
+        cnt_ref = n;
+
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    // If the in-var is iterating then the count of iterations must be controlled by exactly one
+    // of the 3 parts of the in-stmt: in-var,src_proc, or src_var.  This function determines
+    // which element is used to determine the iteration count.
+    rc_t _determine_in_stmt_iter_count_ctl_ele(network_t& net, instance_t* inst, in_stmt_t& in_stmt )
+    {
+      assert( in_stmt.in_var_ele.is_iter_fl );
+      rc_t rc = kOkRC;
+
+      in_ele_t* iter_cnt_ctl_ele = nullptr;
+
+      // if the in-var gives a literal count - then it determines the count
+      if( in_stmt.in_var_ele.sfx_id_count != kInvalidCnt )
+      {
+        // if the in-var gives a literal count then the src-proc cannot give one
+        if( in_stmt.src_proc_ele.sfx_id_count != kInvalidCnt )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The in-var provided a literal iteration count therefore the src-proc cannot.");
+          goto errLabel;
+        }
+          
+        // if the in-var gives a literal count then the src-var cannot give one
+        if( in_stmt.src_var_ele.sfx_id_count != kInvalidCnt )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The in-var provided a literal iteration count therefore the src-var cannot.");
+          goto errLabel;
+        }
+
+        iter_cnt_ctl_ele = &in_stmt.in_var_ele;
+          
+      }
+      else // the src-proc or src-var must control the iter count
+      {
+        // if the src-proc gives a literal count - then it determines th count
+        if( in_stmt.src_proc_ele.sfx_id_count != kInvalidCnt )
+        {
+          // then the src-var cannot give a literal count
+          if( in_stmt.src_var_ele.sfx_id_count != kInvalidCnt )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The src-proc provided a literal iteration count therefore the src-var cannot.");
+            goto errLabel;
+          }
+
+          iter_cnt_ctl_ele = &in_stmt.src_proc_ele;
+            
+        }
+        else
+        {
+          // if the src-var gives a literal count - then it determines the count
+          if( in_stmt.src_var_ele.sfx_id_count != kInvalidCnt )
+          {
+            iter_cnt_ctl_ele = &in_stmt.src_var_ele;
+          }
+          else // no literal count was given - we need to get the implied count
+          {
+            // if the src-proc is iterating then it will provide the count
+            if( in_stmt.src_proc_ele.is_iter_fl )
+            {
+              // the src-var cannot be iterating if the src-proc is iterating
+              if( in_stmt.src_var_ele.is_iter_fl )
+              {
+                rc = cwLogError(kSyntaxErrorRC,"The src-proc is iterating therefore the src-var cannot.");
+                goto errLabel;
+              }
+                
+              iter_cnt_ctl_ele = &in_stmt.src_proc_ele;
+            }
+            else // the src-proc isn't iterating check the src-var
+            {
+              if( in_stmt.src_var_ele.is_iter_fl )
+              {
+                iter_cnt_ctl_ele = &in_stmt.src_var_ele;
+              }
+              else // no iteration count control was found
+              {
+                rc = cwLogError(kSyntaxErrorRC,"No iteration count control was specified.");
+                goto errLabel;                  
+              }
+            }
+          }
+        }
+      }               
+      
+    errLabel:
+      
+      if( rc == kOkRC )
+        in_stmt.iter_cnt_ctl_ele = iter_cnt_ctl_ele;
+      
+      return rc;
+    }
+    
+    rc_t _determine_in_stmt_iter_count( network_t& net,instance_t* inst, in_stmt_t& in_stmt )
+    {
+      rc_t rc = kOkRC;
+
+      // it has already been determined that this an iterating in-stmt
+      // and a iteration count control element has been identified.
+      assert( in_stmt.in_var_ele.is_iter_fl );
+      assert( in_stmt.iter_cnt_ctl_ele != nullptr );
+
+      switch( in_stmt.iter_cnt_ctl_ele->typeId )
+      {
+        case kInVarTypeId:
+            
+          assert( in_stmt.iter_cnt_ctl_ele->sfx_id_count != kInvalidCnt );
+            
+          if((in_stmt.iter_cnt = in_stmt.iter_cnt_ctl_ele->sfx_id_count) == 0 )
+            rc = cwLogError(rc,"The literal in-var iteration count on '%s:%i' must be greater than zero.", cwStringNullGuard(in_stmt.iter_cnt_ctl_ele->label),in_stmt.iter_cnt_ctl_ele->base_sfx_id);            
+          break;
+            
+        case kSrcProcTypeId:
+          if((rc = _calc_src_proc_ele_count( *in_stmt.src_net, in_stmt.src_proc_ele, in_stmt.iter_cnt )) != kOkRC )
+            rc = cwLogError(rc,"Unable to determine the in-stmt iteration count based on the iteration control src-proc '%s'.",cwStringNullGuard(in_stmt.src_proc_ele.label));
+          break;
+            
+        case kSrcVarTypeId:
+          if((rc = _calc_src_var_ele_count( *in_stmt.src_net, in_stmt.src_proc_ele, in_stmt.src_var_ele, in_stmt.iter_cnt )) != kOkRC )
+            rc = cwLogError(rc,"Unable to determine the in-stmt iteration count based on the iteration control src-var '%s'.",cwStringNullGuard(in_stmt.src_var_ele.label));
+
+          break;
+            
+        default:
+          rc = cwLogError(kInvalidStateRC,"An unknown in-stmt element type was encountered.");
+      }
+      
+      return rc;
+    }
+    
+    void _destroy_in_stmt( in_stmt_t& s )
+    {
+      mem::release(s.in_var_ele.label);
+      mem::release(s.src_net_label);
+      mem::release(s.src_proc_ele.label);
+      mem::release(s.src_var_ele.label);
+    }
+
+    rc_t _parse_in_stmt_src_net_proc_var_string( char* str, char*& src_net_label, const char*& src_proc_label, const char*& src_var_label )
+    {
+      rc_t rc = kOkRC;
+      char* period0 = nullptr;
+      char* period1 = nullptr;
+      
+      // locate the separator period on the src proc/var id
+      if((period0 = firstMatchChar(str,'.')) == nullptr )
+      {
+        cwLogError(kSyntaxErrorRC,"No period separator was found in the src net/proc/var for the src specifier:%s.",str);
+        goto errLabel;
+      }
+
+      *period0 = 0;
+      
+      if((period1 = firstMatchChar(period0+1,'.')) != nullptr )
+      {
+        *period1 = 0;
+        src_var_label = period1 + 1;  // Set a pointer to the src var label
+        src_proc_label = period0 + 1;
+        src_net_label = mem::duplStr(str);
+      }
+      else
+      {
+        src_var_label = period0 + 1;
+        src_proc_label = str;
+        src_net_label = nullptr;
+      }
+
+      if( textLength(src_var_label) == 0 )
+        rc = cwLogError(kSyntaxErrorRC,"The 'src-var' label has length 0.");
+
+      if( textLength(src_proc_label) == 0 )
+        rc = cwLogError(kSyntaxErrorRC,"The 'src-proc' label has length 0.");
+
+
+    errLabel:
+      return rc;
+    }
+
+
+    // Recursively search the tree of networks rooted on 'net' for the
+    // network named 'net_inst_label'.
+    network_t*  _find_labeled_network( network_t& net, const char* net_inst_label )
+    {
+      network_t* labeled_net = nullptr;
+
+      // for each instance in the network
+      for(unsigned i=0; i<net.proc_arrayN && labeled_net==nullptr; ++i)
+      {
+        instance_t* inst =  net.proc_array[i];
+          
+        // if this instance has an  internal network
+        if( inst->internal_net != nullptr )
+        {
+          // if the name of the network matches the key ...
+          if( textIsEqual(inst->label,net_inst_label) )            
+            labeled_net = inst->internal_net; // .. we are done
+          else
+          {
+            // ... otherwise recurse
+            labeled_net = _find_labeled_network(*inst->internal_net,net_inst_label);
+          }
+        }
+        
+      }
+      return labeled_net;
+    }
+
+    // Set  'in_stmt.src_net' based on 'in_stmt.src_net_label'
+    rc_t _locate_src_net(network_t& net,instance_t* inst, in_stmt_t& in_stmt)
+    {
+      rc_t rc = kOkRC;
+      network_t* src_net = nullptr;
+
+      in_stmt.src_net = nullptr;
+      
+      if( in_stmt.src_net_label == nullptr )
+        src_net = &net;
+      else
+      {        
+        if( textIsEqual(in_stmt.src_net_label,"_") )
+          src_net = &inst->ctx->net;
+        else
+        {
+          if((src_net = _find_labeled_network(inst->ctx->net,in_stmt.src_net_label)) == nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The source net '%s' was not found.",cwStringNullGuard(in_stmt.src_net_label));
+            goto errLabel;
+          }
+        } 
+      }
+    errLabel:
+      in_stmt.src_net = src_net;
+
+      if( in_stmt.src_net == nullptr )
+        rc = cwLogError(kSyntaxErrorRC,"No source net was found.");
+      
+      return rc;
+    }
+
+
+    rc_t _create_in_stmt( network_t& net, instance_t* inst, in_stmt_t& in_stmt, const char* in_var_str, const char* src_proc_var_str )
+    {
+      rc_t     rc          = kOkRC;
+      unsigned src_char_cnt = 0;
+
+      in_stmt.in_var_ele.typeId   = kInVarTypeId;
+      in_stmt.src_proc_ele.typeId = kSrcProcTypeId;
+      in_stmt.src_var_ele.typeId  = kSrcVarTypeId;
+      
+      // verify the src proc/var string is valid
+      if( (src_char_cnt = textLength(src_proc_var_str)) == 0 )
+      {
+        cwLogError(kSyntaxErrorRC,"No source variable was found for the input variable '%s'.",cwStringNullGuard(in_var_str));
+        goto errLabel;
+      }
+      else
+      {
+        const char* src_proc_label = nullptr;
+        const char* src_var_label = nullptr;
+        
+        char  str[ src_char_cnt+1 ];
+
+        // put the src proc/var string into a non-const scratch buffer
+        textCopy(str,src_char_cnt+1,src_proc_var_str);
+
+        // parse the src part into it's 3 parts
+        if((rc = _parse_in_stmt_src_net_proc_var_string(str, in_stmt.src_net_label, src_proc_label, src_var_label )) != kOkRC )          
+        {
+          cwLogError(rc,"Unable to parse the 'src' part of an 'in-stmt'.");
+          goto errLabel;
+        }
+
+        // parse the in-var
+        if((rc = _parse_in_ele( in_var_str, in_stmt.in_var_ele  )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_str));
+          goto errLabel;
+        }
+
+        // parse the src-proc
+        if((rc = _parse_in_ele( src_proc_label, in_stmt.src_proc_ele  )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_str));
+          goto errLabel;
+        }
+
+        // parse the src-var
+        if((rc = _parse_in_ele( src_var_label, in_stmt.src_var_ele )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_str));
+          goto errLabel;
+        }
+
+        // get the var class desc. for the in-var
+        if(( in_stmt.in_var_desc = var_desc_find(inst->class_desc,in_stmt.in_var_ele.label)) == nullptr )
+        {
+          rc = cwLogError(rc,"Unable to locate the var class desc for the in-var from '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label));
+          goto errLabel;
+        }
+
+        // get the src net
+        if((rc = _locate_src_net(net,inst,in_stmt)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to locate the src-net '%s'.",cwStringNullGuard(in_stmt.src_net_label));
+          goto errLabel;
+        }
+
+        // if the in-var has an sfx_id, or is iterating, then the var needs to be created (the dflt creation process assumes no sfx id)
+        if( in_stmt.in_var_ele.base_sfx_id != kInvalidId || in_stmt.in_var_ele.is_iter_fl )
+        {
+          in_stmt.create_in_fl = true;
+          if( in_stmt.in_var_ele.base_sfx_id == kInvalidId )
+            in_stmt.in_var_ele.base_sfx_id = kBaseSfxId;
+        }
+
+        // if the src-proc is not iterating and the src-proc was not given a literal sfx-id
+        if( in_stmt.src_proc_ele.is_iter_fl==false && in_stmt.src_proc_ele.base_sfx_id==kInvalidId && in_stmt.src_net==&net)
+          in_stmt.src_proc_ele.base_sfx_id = inst->label_sfx_id;
+
+        // if this is not an iterating in-stmt ... 
+        if( !in_stmt.in_var_ele.is_iter_fl )
+        {
+          in_stmt.iter_cnt = 1;  // ... then it must be a simple 1:1 connection
+        }
+        else
+        {
+          // if the in-stmt is iterating then determine the in-stmt element which controls the iteration count
+          if((rc = _determine_in_stmt_iter_count_ctl_ele(net,inst,in_stmt)) != kOkRC || in_stmt.iter_cnt_ctl_ele==nullptr)
+          {
+            rc = cwLogError(rc,"Unable to determine the iter count control ele.");
+            goto errLabel;
+          }
+
+          // if the in-stmt is iterating then determine the iteration count
+          if((rc = _determine_in_stmt_iter_count(net,inst,in_stmt)) != kOkRC )
+          {
+            cwLogError(rc,"Unable to determine the in-stmt iteration count.");
+            goto errLabel;
+          }
+        }
+      }
+      
+    errLabel:
+      if( rc != kOkRC )
+        _destroy_in_stmt(in_stmt);
+      
+      return rc;      
+    }
+    
+    rc_t _parse_in_list( network_t& net, instance_t* inst, proc_inst_parse_state_t& pstate )
+    {
+      rc_t            rc     = kOkRC;
+      
+      if( pstate.in_dict == nullptr )
+        goto errLabel;
+      
+      if( !pstate.in_dict->is_dict() )
+      {
+        cwLogError(kSyntaxErrorRC,"The 'in' dict in instance '%s' is not a valid dictionary.",inst->label);
+        goto errLabel;
+      }
+
+      if( pstate.in_dict->child_count() == 0 )
+        goto errLabel;
+
+      pstate.in_arrayN = pstate.in_dict->child_count();
+      pstate.in_array  = mem::allocZ<in_stmt_t>(pstate.in_arrayN);
+
+      // for each input variable in the 'in' set
+      for(unsigned i=0; i<pstate.in_arrayN; ++i)
+      {
+        in_stmt_t&      in_stmt          = pstate.in_array[i];
+        const object_t* in_pair          = pstate.in_dict->child_ele(i); // in:src pair
+        const char*     in_var_str       = in_pair->pair_label(); // 'in' var string
+        const char*     src_proc_var_str = nullptr;
+
+        // get the src net/proc/var string
+        if((rc = in_pair->pair_value()->value(src_proc_var_str)) != kOkRC )
+        {
+          cwLogError(rc,"Unable to access the source proc/var string for the input var '%s'.",cwStringNullGuard(in_var_str));
+          goto errLabel;
+        }
+
+        // 
+        if((rc= _create_in_stmt(net, inst, in_stmt, in_var_str, src_proc_var_str )) != kOkRC )
+        {
+          cwLogError(rc,"Parse failed on the in-connection '%s:%s'.",cwStringNullGuard(in_var_str),cwStringNullGuard(src_proc_var_str));
+          goto errLabel;
+        }
+
+        // create the var
+        if( in_stmt.create_in_fl )
+        {
+          for(unsigned i=0; i<in_stmt.iter_cnt; ++i)
+          {
+            variable_t* dum = nullptr;        
+
+            if((rc = var_create( inst, in_stmt.in_var_desc->label,
+                                 in_stmt.in_var_ele.base_sfx_id + i,
+                                 kInvalidId,
+                                 kAnyChIdx,
+                                 in_stmt.in_var_desc->val_cfg,
+                                 dum )) != kOkRC )
+            {
+              rc = cwLogError(rc,"in-stmt var create failed on '%s:%s'.",cwStringNullGuard(in_var_str),cwStringNullGuard(src_proc_var_str));
+              goto errLabel;
+            }
+          }
+        }
+        
+      }
+
+    errLabel:
+      
+      return rc;
+      
+    }
+
+    bool _is_var_inst_already_created( const char* var_label, const proc_inst_parse_state_t& pstate )
+    {
+      for(unsigned i=0; i<pstate.in_arrayN; ++i)
+        if( textIsEqual(pstate.in_array[i].in_var_ele.label,var_label) && pstate.in_array[i].create_in_fl )
+          return true;
+
+      return false;
+    }
+
+    rc_t _connect_in_vars(network_t& net, instance_t* inst, const proc_inst_parse_state_t& pstate)
+    {
+      rc_t rc = kOkRC;
+      
+      for(unsigned i=0; i<pstate.in_arrayN; ++i)
+      {
+        in_stmt_t& in_stmt = pstate.in_array[i];
+
+        for(unsigned j=0; j<in_stmt.iter_cnt; ++j)
+        {
+          variable_t* in_var    = nullptr;
+          network_t*  src_net   = in_stmt.src_net;
+          instance_t* src_proc  = nullptr;
+          variable_t* src_var   = nullptr;
+
+          const char* in_var_label   = in_stmt.in_var_ele.label;
+          const char* src_proc_label = in_stmt.src_proc_ele.label;
+          const char* src_var_label  = in_stmt.src_var_ele.label;
+
+          unsigned in_var_sfx_id   = (in_stmt.in_var_ele.base_sfx_id == kInvalidId ? kBaseSfxId : in_stmt.in_var_ele.base_sfx_id) + j;
+          unsigned src_proc_sfx_id = kInvalidId;
+          unsigned src_var_sfx_id  = kInvalidId;
+
+          // if a literal in-var sfx id was no given ...
+          if( in_stmt.in_var_ele.base_sfx_id == kInvalidId )
+            in_var_sfx_id = kBaseSfxId;
+          else
+            in_var_sfx_id = in_stmt.in_var_ele.base_sfx_id;
+
+          if( in_stmt.in_var_ele.is_iter_fl )
+            in_var_sfx_id += j;
+
+          // if a literal src-proc sfx id was not given ...
+          if( in_stmt.src_proc_ele.base_sfx_id == kInvalidId )
+            src_proc_sfx_id = kBaseSfxId; // ... then use the sfx_id of the in-var proc
+          else
+            src_proc_sfx_id = in_stmt.src_proc_ele.base_sfx_id; // ... otherwise use the given literal
+
+          if( in_stmt.src_proc_ele.is_iter_fl ) // if this is an iterating src
+            src_proc_sfx_id += j;
+
+          // if a literal src-var sfx id was not given ...
+          if( in_stmt.src_var_ele.base_sfx_id == kInvalidId )
+            src_var_sfx_id = kBaseSfxId; // ... then use the base-sfx-id
+          else
+            src_var_sfx_id = in_stmt.src_var_ele.base_sfx_id; // ... otherwise use the given literal
+
+          if( in_stmt.src_var_ele.is_iter_fl )  // if this is an iterating src
+            src_var_sfx_id += j;
+          
+          // locate input value
+          if((rc = var_find( inst, in_var_label, in_var_sfx_id, kAnyChIdx, in_var )) != kOkRC )
+          {
+            rc = cwLogError(rc,"The in-var '%s:%i' was not found.", in_stmt.in_var_ele.label, in_stmt.in_var_ele.base_sfx_id + j);
+            goto errLabel;        
+          }
+          
+          // locate source instance 
+          if((src_proc = instance_find(*src_net, src_proc_label, src_proc_sfx_id )) == nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The src-proc '%s:%i' was not found.", in_stmt.src_proc_ele.label, src_proc_sfx_id );
+            goto errLabel;
+          }
+
+          // locate source value
+          if((rc = var_find( src_proc, src_var_label, src_var_sfx_id, kAnyChIdx, src_var)) != kOkRC )
+          {
+            rc = cwLogError(rc,"The src-var '%s:i' was not found.", in_stmt.src_var_ele.label, src_var_sfx_id);
+            goto errLabel;
+          }
+
+          // verify that the src_value type is included in the in_value type flags
+          if( cwIsNotFlag(in_var->varDesc->type, src_var->varDesc->type) )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The type flags don't match on input:%s:%i source:%s:%i.%s:%i .", in_var_label, in_var_sfx_id, src_proc_label, src_proc_sfx_id, src_var_label, src_var_sfx_id);        
+            goto errLabel;                
+          }
+
+          // verify that the source exists
+          if( src_var->value == nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The source value is null on the connection input::%s:%i source:%s:%i.%s:%i .", in_var_label, in_var_sfx_id, src_proc_label, src_proc_sfx_id, src_var_label, src_var_sfx_id);        
+            goto errLabel;
+          }
+
+          //
+          _connect_vars( src_var, in_var );
+        }                
+      }
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(rc,"Connection failed on proc '%s:%i'.",inst->label,inst->label_sfx_id);
+      return rc;
+    }
+      
+    
+    rc_t _parse_proc_inst_cfg( network_t& net, const object_t* proc_inst_cfg, unsigned sfx_id, proc_inst_parse_state_t& pstate )
+    {
+      rc_t            rc       = kOkRC;
+      const object_t* arg_dict = nullptr;
+
+      // validate the syntax of the proc_inst_cfg pair
+      if( !_is_non_null_pair(proc_inst_cfg))
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. is not a valid pair. No instance label could be parsed.");
+        goto errLabel;
+      }
+      
+      pstate.inst_label = proc_inst_cfg->pair_label();
+
+      // verify that the instance label is unique
+      if( instance_find(net,pstate.inst_label,sfx_id) != nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance label '%s:%i' has already been used.",pstate.inst_label,sfx_id);
+        goto errLabel;
+      }
+      
+      // get the instance class label
+      if((rc = proc_inst_cfg->pair_value()->getv("class",pstate.inst_clas_label)) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. %s is missing: 'type'.",pstate.inst_label);
+        goto errLabel;        
+      }
+      
+      // parse the optional args
+      if((rc = proc_inst_cfg->pair_value()->getv_opt("args",     arg_dict,
+                                                "in",       pstate.in_dict,
+                                                "argLabel", pstate.arg_label,
+                                                "preset",   pstate.preset_labels)) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. '%s' missing: 'type'.",pstate.inst_label);
+        goto errLabel;        
+      }
+
+      // if an argument dict was given in the instance cfg
+      if( arg_dict != nullptr  )
+      {
+        bool rptErrFl = true;
+
+        // verify the arg. dict is actually a dict.
+        if( !arg_dict->is_dict() )
+        {
+          cwLogError(kSyntaxErrorRC,"The instance argument dictionary on instance '%s' is not a dictionary.",pstate.inst_label);
+          goto errLabel;
+        }
+        
+        // if no label was given then try 'default'
+        if( pstate.arg_label == nullptr)
+        {
+          pstate.arg_label = "default";
+          rptErrFl = false;
+        }
+
+        // locate the specified argument record
+        if((pstate.arg_cfg = arg_dict->find_child(pstate.arg_label)) == nullptr )
+        {
+
+          // if an explicit arg. label was given but it was not found
+          if( rptErrFl )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on instance cfg. '%s'.",pstate.arg_label,pstate.inst_label);
+            goto errLabel;
+          }
+
+          // no explicit arg. label was given - make arg_dict the instance arg cfg.
+          pstate.arg_cfg = arg_dict;
+          pstate.arg_label = nullptr;
+        }        
+      }
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on instance: '%s'.", cwStringNullGuard(pstate.inst_label) );
+      
+      return rc;
+    }
+
+    void _destroy_pstate( proc_inst_parse_state_t pstate )
+    {
+      for(unsigned i=0; i<pstate.in_arrayN; ++i)
+        _destroy_in_stmt(pstate.in_array[i]);
+      mem::release(pstate.in_array);
+    }
+
+    // Count of proc instances which exist in the network with a given class.
+    unsigned _poly_copy_count( const network_t& net, const char* proc_clas_label )
+    {
+      unsigned n = 0;
+      
+      for(unsigned i=0; i<net.proc_arrayN; ++i)
+        if( textIsEqual(net.proc_array[i]->class_desc->label,proc_clas_label) )
+          ++n;
+      return n;
+    }
+
+    rc_t _create_instance( flow_t* p, const object_t* proc_inst_cfg, unsigned sfx_id, network_t& net, instance_t*& inst_ref )
+    {
+      rc_t                    rc         = kOkRC;
+      proc_inst_parse_state_t pstate     = {};
+      instance_t*             inst       = nullptr;
+      class_desc_t*           class_desc = nullptr;
+
+      inst_ref = nullptr;
+
+      // parse the instance configuration 
+      if((rc = _parse_proc_inst_cfg( net, proc_inst_cfg, sfx_id, pstate )) != kOkRC )
+        goto errLabel;
+      
+      // locate the class desc
+      if(( class_desc = class_desc_find(p,pstate.inst_clas_label)) == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pstate.inst_clas_label));
+        goto errLabel;
+      }
+
+      // if the poly instance count has been exceeded for this proc inst class ...
+      if(class_desc->polyLimitN > 0 && _poly_copy_count(net,pstate.inst_clas_label) >= class_desc->polyLimitN )
+      {
+        // ... then silently skip this instantiation
+        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.inst_label,sfx_id);
+        goto errLabel;
+      }
+      
+      // instantiate the instance
+      inst = mem::allocZ<instance_t>();
+
+      inst->ctx           = p;
+      inst->label         = mem::duplStr(pstate.inst_label);
+      inst->label_sfx_id  = sfx_id;
+      inst->proc_cfg      = proc_inst_cfg->pair_value();
+      inst->arg_label     = pstate.arg_label;
+      inst->arg_cfg       = pstate.arg_cfg;
+      inst->class_desc    = class_desc;
+      inst->net           = &net;
+
+      // parse the in-list ,fill in pstate.in_array, and create var instances for var's referenced by in-list
+      if((rc = _parse_in_list( net, inst, pstate )) != kOkRC )
+      {
+        rc = cwLogError(rc,"in-list parse failed on proc instance '%s:%i'.",cwStringNullGuard(inst->label),sfx_id);
+        goto errLabel;
+      }
+
+      // Instantiate all the variables in the class description - that were not already created in _parse_in_list()
+      for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
+        if( !_is_var_inst_already_created( vd->label, pstate ) )
+        {
+          variable_t* var = nullptr;        
+          if((rc = var_create( inst, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, var )) != kOkRC )
+            goto errLabel;
+        }
+
+      // All the variables that can be used by this instance have now been created
+      // and the chIdx of each variable is set to 'any'.
+
+      // If a 'preset' field was included in the class cfg then apply the specified class preset
+      if( pstate.preset_labels != nullptr )      
+        if((rc = _class_apply_presets(inst, pstate.preset_labels )) != kOkRC )
+          goto errLabel;
+
+      // All the class presets values have now been set and those variables
+      // that were expressed with a list have numeric channel indexes assigned.
+
+      // Apply the proc instance preset values.
+      if( pstate.arg_cfg != nullptr )
+        if((rc = _proc_inst_args_channelize_vars( inst, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
+          goto errLabel;
+
+      // All the instance arg values have now been set and those variables
+      // that were expressed with a list have numeric channel indexes assigned.
+
+
+      // TODO: Should the 'all' variable be removed for variables that have numeric channel indexes?
+
+      // Connect the in-list variables to their sources.
+      if((rc = _connect_in_vars(net, inst, pstate)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Creation of the proc instance '%s:%i' failed during input connection processing.",cwStringNullGuard(inst->label),inst->label_sfx_id);
+        goto errLabel;
+      }
+      
+      // Complete the instantiation of the proc instance by calling the custom instance creation function.
+
+      // Call the custom instance create() function.
+      if((rc = class_desc->members->create( inst )) != kOkRC )
+      {
+        rc = cwLogError(kInvalidArgRC,"Instantiation failed on instance '%s:%i'.", inst->label,inst->label_sfx_id );
+        goto errLabel;
+      }
+
+      // Create the instance->varMap[] lookup array
+      if((rc =_create_instance_var_map( inst )) != kOkRC )
+        goto errLabel;
+
+      // the custom creation function may have added channels to in-list vars fix up those connections here.
+      _complete_input_connections(inst);
+
+      // call the 'value()' function to inform the instance of the current value of all of it's variables.
+      if((rc = _call_value_func_on_all_variables( inst )) != kOkRC )
+        goto errLabel;
+
+      
+      inst_ref = inst;
+      
+      /*
+      // insert an instance in the network
+      if( net.network_tail == nullptr )
+      {
+        net.network_head = inst;
+        net.network_tail = inst;
+      }
+      else
+      {
+        net.network_tail->link = inst;
+        net.network_tail       = inst;
+      }      
+      */
+      
+    errLabel:
+      if( rc != kOkRC )
+        _destroy_inst(inst);
+      _destroy_pstate(pstate);
+      
+      return rc;      
+    }
+
+    //=======================================================================================================
+    //
+    // Apply presets
+    //
+
+    
+    unsigned _select_ranked_ele_by_rank_prob( const preset_order_t* presetA, const bool* selV , unsigned presetN )
+    {
+
+      // get a count of the candidate presets
+      unsigned rankN = selV==nullptr ? presetN : std::count_if(selV,selV+presetN,[](const bool& x){ return x; });
+
+      if( rankN == 0 )
+      {
+        cwLogWarning("All preset candidates have been eliminated.");
+        return kInvalidIdx;
+      }
+
+      unsigned rankV[  rankN ];
+      unsigned idxMapA[ rankN ];
+
+      // fill rankV[] with candidates 'order' value
+      for(unsigned i=0,j=0; i<presetN; ++i)
+        if( selV==nullptr || selV[i] )
+        {
+          assert( j < rankN );
+          rankV[j]   = presetA[i].order;
+          idxMapA[j] = i;
+          ++j;
+        }
+
+      // if only one element remains to be selected
+      if( rankN == 1 )
+        return idxMapA[0];
+
+      assert( rankN > 1 );
+      
+      unsigned threshV[ rankN ];
+      unsigned uniqueRankV[ rankN ];      
+      unsigned uniqueRankN = 0;
+      unsigned sel_idx = rankN - 1; //
+
+      // for each possible rank value
+      for(unsigned i=0; i<rankN; ++i)
+      {
+        // locate the rank in the uniqueRankV[]
+        unsigned j=0;
+        for(; j<uniqueRankN; ++j)
+          if( uniqueRankV[j]==rankV[i] )
+            break;
+
+        // if the rank was not found then include it here
+        if( j == uniqueRankN )
+          uniqueRankV[uniqueRankN++] = rankV[i];
+
+      }
+
+      // uniqueRankV[] now includes the set of possible rank values
+      
+      // Take the product of all possible values.
+      // (this will be evenly divisible by all values)
+      unsigned prod = vop::prod(uniqueRankV,uniqueRankN);
+
+      unsigned thresh = 0;
+      for(unsigned i=0; i<rankN; ++i)
+        threshV[i] = (thresh += rankV[i] * prod);
+
+      // Thresh is now set to the max possible random value.
+      
+      // Generate a random number between 0 and thresh
+      double   fval = (double)std::rand() * thresh / RAND_MAX;
+
+      unsigned thresh0 = 0;
+      for(unsigned i=0; i<rankN; ++i)
+      {
+        if( thresh0 <= fval && fval < threshV[i] )
+        {
+          sel_idx = i;
+          break;
+        }
+      }
+
+      assert( sel_idx < rankN );
+      
+      return idxMapA[sel_idx];
+    }
+
+    /*
+    unsigned _select_ranked_ele_by_rank_prob( const preset_order_t* rankV, unsigned rankN )
+    {     
+      unsigned threshV[ rankN ];
+      unsigned uniqueRankV[ rankN ];      
+      unsigned uniqueRankN = 0;
+      unsigned sel_idx = rankN - 1; //
+
+      if( rankN == 0 )
+        return kInvalidIdx;
+
+      if( rankN == 1 )
+        return 0;
+
+      // for each possible rank value
+      for(unsigned i=0; i<rankN; ++i)
+      {
+        // locate the rank in the uniqueRankV[]
+        unsigned j=0;
+        for(; j<uniqueRankN; ++j)
+          if( uniqueRankV[j]==rankV[i].order )
+            break;
+
+        // if the rank was not found then include it here
+        if( j == uniqueRankN )
+          uniqueRankV[uniqueRankN++] = rankV[i].order;
+
+      }
+
+      // uniqueRankV[] now includes the set of possible rank values
+      
+      // Take the product of all possible values.
+      // (this will be evenly divisible by all values)
+      unsigned prod = vop::prod(uniqueRankV,uniqueRankN);
+
+      unsigned thresh = 0;
+      for(unsigned i=0; i<rankN; ++i)
+        threshV[i] = (thresh += rankV[i].order * prod);
+
+      // Thresh is now set to the max possible random value.
+      
+      // Generate a random number between 0 and thresh
+      double   fval = (double)std::rand() * thresh / RAND_MAX;
+
+      unsigned thresh0 = 0;
+      for(unsigned i=0; i<rankN; ++i)
+      {
+        if( thresh0 <= fval && fval < threshV[i] )
+        {
+          sel_idx = i;
+          break;
+        }
+      }
+
+      return sel_idx;
+    }
+    */
+    
+    const char* _select_ranked_ele_label_by_rank_prob( const preset_order_t* rankV, const bool* selA, unsigned rankN )
+    {
+      unsigned sel_idx;
+
+      if((sel_idx = _select_ranked_ele_by_rank_prob( rankV, selA, rankN )) == kInvalidIdx )
+      {
+        cwLogWarning("The multi-preset select function failed. Selecting preset 0.");
+        sel_idx = 0;
+      }
+
+      return rankV[sel_idx].preset_label;
+
+    }
+    
+
+    double _calc_multi_preset_dual_coeff( const multi_preset_selector_t& mps )
+    {
+      double result = 0;
+      unsigned resultN = 0;
+      
+      if( mps.coeffN == 0 )
+      {
+        result = 0.5;
+      }
+      else
+      {  
+        for(unsigned i=0; i<mps.coeffN; ++i)
+        {
+          /*
+
+            Temporarily commented out because coeffV[] values
+            have already been normalized.
+            
+          double norm_factor = (mps.coeffMaxV[i] - mps.coeffMinV[i]);
+          
+          if( norm_factor <= 0 )
+            cwLogWarning("Invalid normalization factor in aggregated distance measurement.");
+          else
+            norm_factor = 1;
+          
+          
+          result += std::max( mps.coeffMinV[i], std::min( mps.coeffMaxV[i], mps.coeffV[i] ) ) / norm_factor;
+          */
+
+          // WOULD DISTANCE BE BETTER THAN AVERAGE????
+          
+          if( mps.coeffV[i] != 0 )
+          {
+            result += mps.coeffV[i];
+            resultN += 1;
+          }
+        }
+
+        if( resultN <= 0 )
+            cwLogWarning("Invalid normalization factor in aggregated distance measurement.");
+        else
+          result = std::min(1.0,std::max(0.0,result/mps.coeffN));
+      }
+      
+      
+      return result;
+    }
+    
+    rc_t _find_network_preset_instance_pair( network_t& net, const char* preset_label, const char* instance_label, const object_t*& preset_val_ref )
+    {
+      rc_t rc = kOkRC;
+      const object_t* net_preset_pair = nullptr;
+      
+      preset_val_ref = nullptr;
+  
+      // locate the cfg of the requested preset
+      if((net_preset_pair = find_network_preset(net, preset_label )) == nullptr )
+      {
+        rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", cwStringNullGuard(preset_label) );
+        goto errLabel;
+      }
+
+      // locate the instance matching 'instance_label'.
+      for(unsigned i=0; i<net_preset_pair->child_count(); ++i)
+      {
+        const object_t* inst_pair;
+        if((inst_pair = net_preset_pair->child_ele(i)) != nullptr && inst_pair->is_pair() && textIsEqual(inst_pair->pair_label(),instance_label) )
+        {      
+
+          preset_val_ref = inst_pair->pair_value();
+
+          goto errLabel;
+        }
+      }
+  
+      rc = cwLogError(kInvalidArgRC,"The preset instance label '%s' was not found.",cwStringNullGuard(preset_label));
+  
+    errLabel:
+      return rc;
+    }
+
+    
+  }
+}
+
+cw::rc_t cw::flow::network_create( flow_t* p,
+                                   const object_t* networkCfg,
+                                   network_t& net,
+                                   unsigned polyCnt,
+                                   network_order_id_t orderId )
+{
+  rc_t     rc     = kOkRC;
+
+  // default to kNetFirstPolyOrderId
+  unsigned outerN        = polyCnt;
+  unsigned innerN        = 1;
+
+  if((rc = networkCfg->getv("procs",net.procsCfg)) != kOkRC )
+  {
+    rc = cwLogError(rc,"Failed on parsing required network cfg. elements.");
+    goto errLabel;
+  }
+
+  if((rc = networkCfg->getv_opt("presets",net.presetsCfg)) != kOkRC )
+  {
+    rc = cwLogError(rc,"Failed on parsing optional network cfg. elements.");
+    goto errLabel;
+  }
+
+
+  if( orderId == kProcFirstPolyOrderId )
+  {
+    outerN = 1;
+    innerN = polyCnt;
+  }
+
+  net.proc_arrayAllocN = polyCnt * net.procsCfg->child_count();
+  net.proc_array  = mem::allocZ<instance_t*>(net.proc_arrayAllocN);
+  net.proc_arrayN = 0;
+
+  for(unsigned i=0; i<outerN; ++i)
+  {
+    // for each proc in the network
+    for(unsigned j=0; j<net.procsCfg->child_count(); ++j)
+    {
+      const object_t* proc_cfg = net.procsCfg->child_ele(j);
+
+      for(unsigned k=0; k<innerN; ++k)
+      {
+        unsigned sfx_id = orderId == kNetFirstPolyOrderId ? i : k;
+
+        assert(net.proc_arrayN < net.proc_arrayAllocN );
+        
+        // create the proc instance
+        if( (rc= _create_instance( p, proc_cfg, sfx_id, net, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
+        {
+          //rc = cwLogError(rc,"The instantiation at proc index %i is invalid.",net.proc_arrayN);
+          goto errLabel;
+        }
+
+        net.proc_arrayN += 1;
+      }
+    }
+  }
+
+  net.poly_cnt = polyCnt;
+  
+errLabel:
+  if( rc != kOkRC )
+    _network_destroy(net);
+  
+  return rc;
+}
+
+cw::rc_t cw::flow::network_destroy( network_t& net )
+{
+  return _network_destroy(net);
+}
+
+const cw::object_t* cw::flow::find_network_preset( const network_t& net, const char* presetLabel )
+{
+  const object_t* preset_value = nullptr;
+      
+  if( net.presetsCfg != nullptr )
+  {
+    rc_t rc;
+        
+    if((rc = net.presetsCfg->getv_opt( presetLabel, preset_value )) != kOkRC )
+      cwLogError(rc,"Search for network preset named '%s' failed.", cwStringNullGuard(presetLabel));
+  }
+
+  return preset_value;
+      
+}
+
+cw::rc_t cw::flow::exec_cycle( network_t& net )
+{
+  rc_t rc = kOkRC;
+
+  for(unsigned i=0; i<net.proc_arrayN; ++i)
+  {
+    if((rc = net.proc_array[i]->class_desc->members->exec(net.proc_array[i])) != kOkRC )
+    {          
+      break;
+    }
+  }
+      
+  return rc;
+}
+
+cw::rc_t cw::flow::get_variable( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, instance_t*& instPtrRef, variable_t*& varPtrRef )
+{
+  rc_t        rc   = kOkRC;
+  instance_t* inst = nullptr;
+  variable_t* var  = nullptr;
+
+  varPtrRef = nullptr;
+  instPtrRef = nullptr;
+
+  // locate the proc instance
+  if((inst = instance_find(net,inst_label,kBaseSfxId)) == nullptr )
+  {
+    rc = cwLogError(kInvalidIdRC,"Unknown proc instance label '%s'.", cwStringNullGuard(inst_label));
+    goto errLabel;
+  }
+
+  // locate the variable
+  if((rc = var_find( inst, var_label, kBaseSfxId, chIdx, var)) != kOkRC )
+  {
+    rc = cwLogError(kInvalidArgRC,"The variable '%s' could not be found on the proc instance '%s'.",cwStringNullGuard(var_label),cwStringNullGuard(inst_label));
+    goto errLabel;
+  }
+
+  instPtrRef = inst;
+  varPtrRef = var;
+      
+errLabel:
+  return rc;
+}
+
+
+cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel )
+{
+  rc_t    rc = kOkRC;
+  const object_t* net_preset_value;
+  const object_t* preset_pair;
+
+  // locate the cfg of the requested preset
+  if((net_preset_value = find_network_preset(net, presetLabel )) == nullptr )
+  {
+    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", presetLabel );
+    goto errLabel;
+  }
+
+  // for each instance in the preset
+  for(unsigned i=0; i<net_preset_value->child_count(); ++i)
+  {
+    // get the instance label/value pair
+    if((preset_pair = net_preset_value->child_ele(i)) != nullptr && preset_pair->is_pair() )
+    {
+      const char* inst_label = preset_pair->pair_label();
+      const object_t* preset_value_cfg = preset_pair->pair_value();
+      instance_t* inst;
+
+      // locate the instance
+      if((inst = instance_find(net,inst_label,kBaseSfxId)) == nullptr )
+      {
+        rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel);
+        goto errLabel;
+      }
+
+      // if the preset value is a string then look it up in the class preset dictionary
+      if( preset_value_cfg->is_string() )
+      {
+        const char* class_preset_label;
+        preset_value_cfg->value(class_preset_label);
+        _class_preset_channelize_vars(inst, class_preset_label );
+      }
+      else
+      {
+        // if the preset value is a dict then apply it directly
+        if( preset_value_cfg->is_dict() )
+        {
+          if((rc =  _preset_channelize_vars( inst, "network", presetLabel, preset_value_cfg )) != kOkRC )
+          {
+            rc = cwLogError(rc,"The preset  '%s' application failed on instance '%s'.", presetLabel, inst_label );
+            goto errLabel;
+          }
+          
+        }
+        else
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The network preset '%s' instance '%s' does not have a string or dictionary value.", presetLabel, inst_label );
+          goto errLabel;
+        }
+      }
+    }
+    else
+    {
+      rc = cwLogError(kSyntaxErrorRC,"The network preset '%s' is malformed.",presetLabel);
+      goto errLabel;        
+    }      
+  }
+
+  cwLogInfo("Activated preset:%s",presetLabel);
+errLabel:
+  return rc;
+}
+
+cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* presetLabel_0, const char* presetLabel_1, double coeff )
+{
+  rc_t    rc = kOkRC;
+  
+  const object_t* net_preset_value_0;
+
+  cwLogInfo("*** Applying dual: %s %s : %f",presetLabel_0, presetLabel_1, coeff );
+  
+  // locate the cfg of the requested preset
+  if((net_preset_value_0 = find_network_preset(net, presetLabel_0 )) == nullptr )
+  {
+    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", presetLabel_0 );
+    goto errLabel;
+  }
+
+  // for each instance in the preset
+  for(unsigned i=0; i<net_preset_value_0->child_count(); ++i)
+  {
+    const object_t* preset_pair_0      = net_preset_value_0->child_ele(i);
+    const char*     inst_label         = preset_pair_0->pair_label(); 
+    const object_t* preset_value_cfg_0 = preset_pair_0->pair_value();
+    instance_t*     inst               = nullptr;
+    const object_t* preset_value_cfg_1 = nullptr;
+    const int two = 2;
+    const char* class_preset_labelA[two];
+    
+    // get the instance label/value pair
+    if((preset_pair_0 = net_preset_value_0->child_ele(i)) == nullptr || !preset_pair_0->is_pair() )
+    {
+      rc = cwLogError(kSyntaxErrorRC,"An invalid preset value pair was encountered in '%s'.",presetLabel_0);
+      goto errLabel;
+    }
+
+    // verify that the preset value is a string or dict
+    if( preset_pair_0->pair_value()==nullptr || (!preset_value_cfg_0->is_dict() && !preset_value_cfg_0->is_string() ))
+    {
+      rc = cwLogError(kSyntaxErrorRC,"The preset value pair for instance '%s' in '%s' is not a 'dict' or 'string'.",inst_label,presetLabel_0);
+      goto errLabel;
+    }
+
+    // locate the instance associated with the primary and secondary preset
+    if((inst = instance_find(net,inst_label,kBaseSfxId)) == nullptr )
+    {
+      rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",cwStringNullGuard(inst_label),cwStringNullGuard(presetLabel_0));
+      goto errLabel;
+    }
+            
+    // locate the second instance/preset value pair 
+    if((rc = _find_network_preset_instance_pair(net, presetLabel_1, inst_label, preset_value_cfg_1 )) != kOkRC )
+    {
+      rc = cwLogError(kInvalidIdRC,"The second network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel_1);
+      goto errLabel;
+    }
+    
+    // TODO: We require that the instance presets both be of the same type: string or dict.
+    // There's no good reason for this, as string's resolve to class dict presets anyway.
+    // Fix this!
+    if( !(preset_value_cfg_0->is_dict() == preset_value_cfg_1->is_dict() && preset_value_cfg_0->is_string() == preset_value_cfg_1->is_string()) )
+    {
+      rc = cwLogError(kInvalidIdRC,"The value type (string or dict) of dual network presets must match. (%s != %s)",preset_value_cfg_0->type->label,preset_value_cfg_1->type->label);
+      goto errLabel;
+    }
+
+    preset_value_cfg_0->value(class_preset_labelA[0]);
+    preset_value_cfg_1->value(class_preset_labelA[1]);
+    
+    
+    // if the preset value is a string then look it up in the class dictionary
+    if( preset_value_cfg_0->is_string() )
+    {
+      rc = _class_multi_preset_channelize_vars(inst, class_preset_labelA, two, coeff );        
+    }
+    else
+    {
+      assert( preset_value_cfg_1->is_dict() );
+        
+      const object_t* preset_value_cfgA[] = { preset_value_cfg_0, preset_value_cfg_1};
+                  
+      if((rc =  _multi_preset_channelize_vars( inst, "network", class_preset_labelA, preset_value_cfgA, two, coeff )) != kOkRC )
+      {
+        rc = cwLogError(rc,"The dual preset  '%s':'%s' application failed on instance '%s'.", cwStringNullGuard(class_preset_labelA[0]), cwStringNullGuard(class_preset_labelA[1]), inst_label );
+        goto errLabel;
+      }
+    }
+  }
+
+  
+errLabel:
+
+  if( rc != kOkRC )
+    rc = cwLogError(rc,"The dual preset  '%s':'%s' application failed.", cwStringNullGuard(presetLabel_0), cwStringNullGuard(presetLabel_1) );
+
+  return rc;
+}
+
+cw::rc_t cw::flow::network_apply_preset( network_t& net, const multi_preset_selector_t& mps )
+{
+  rc_t        rc        = kOkRC;
+  const char* label0    = nullptr;
+  const char* label1    = nullptr;
+  bool        priProbFl = cwIsFlag(mps.flags, kPriPresetProbFl );
+  bool        secProbFl = cwIsFlag(mps.flags, kSecPresetProbFl );
+  bool        interpFl  = cwIsFlag(mps.flags, kInterpPresetFl );
+
+  //printf("preset flags: pri:%i sec:%i interp:%i\n",priProbFl,secProbFl,interpFl);
+  
+  // verify that the set of candidate presets is not empty
+  if( mps.presetN == 0 )
+  {
+    cwLogError(kInvalidArgRC,"A multi-preset application was requested but no presets were provided.");
+    goto errLabel;    
+  }
+
+  // if only a single candidate preset exists or needs to be selected
+  if( interpFl==false || mps.presetN==1 )
+  {
+    // if only a single candidate preset is available or pri. probablity is not enabled 
+    if( mps.presetN == 1 || priProbFl==false )
+      label0 = mps.presetA[0].preset_label;
+    else
+    {
+      if( priProbFl )
+        label0 = _select_ranked_ele_label_by_rank_prob( mps.presetA, nullptr, mps.presetN );
+      else
+        label0 = mps.presetA[0].preset_label;
+    }
+  }
+  else  // interpolation has been selected and at least 2 presets exist
+  {    
+    unsigned pri_sel_idx = 0;
+        
+    // select the primary preset
+    if( priProbFl )
+      pri_sel_idx = _select_ranked_ele_by_rank_prob( mps.presetA, nullptr, mps.presetN );
+    else
+    {
+      // select all presets assigned to order == 1
+      bool selA[ mps.presetN ];
+      for(unsigned i=0; i<mps.presetN; ++i)
+        selA[i]= mps.presetA[i].order==1;
+
+      // select the preset among all presets marked as 1
+      pri_sel_idx = _select_ranked_ele_by_rank_prob( mps.presetA, selA, mps.presetN );
+    }
+
+    if( pri_sel_idx == kInvalidIdx )
+      pri_sel_idx    = 0;
+    
+    // the primary preset has now been selected
+
+    // if there is only one candidate secondary preset
+    if( mps.presetN == 2)
+    {
+      assert( pri_sel_idx <= 1 );
+      label1  = mps.presetA[ pri_sel_idx == 0 ? 1 : 0 ].preset_label;
+    }
+    else                        // at least two remaining presets exist to select between
+    {
+      // mark the selected primary preset as not-available
+      bool selA[ mps.presetN ];
+      vop::fill(selA,mps.presetN,true);
+      selA[pri_sel_idx] = false;
+
+      // if the second preset should be selected probabilistically
+      if( secProbFl )
+        label1 = _select_ranked_ele_label_by_rank_prob( mps.presetA, selA, mps.presetN );
+      else 
+      {
+        // select the best preset that is not the primary preset
+        for(unsigned i=0; i<mps.presetN; ++i)
+          if( i != pri_sel_idx )
+          {
+            label1 = mps.presetA[i].preset_label;
+            break;
+          }        
+      }
+    }
+    
+    assert( pri_sel_idx != kInvalidIdx );
+    label0               = mps.presetA[ pri_sel_idx ].preset_label;
+  }
+    
+  assert(label0 != nullptr );
+  
+  if( label1 == nullptr )
+  {
+    rc = network_apply_preset( net, label0 );
+  }
+  else
+  {
+    double coeff = _calc_multi_preset_dual_coeff(mps);
+    rc = network_apply_dual_preset( net, label0, label1, coeff );
+  }
+  
+
+errLabel:
+  return rc;
+}
diff --git a/cwFlowNet.h b/cwFlowNet.h
new file mode 100644
index 0000000..fa35553
--- /dev/null
+++ b/cwFlowNet.h
@@ -0,0 +1,82 @@
+#ifndef cwFlowNet_h
+#define cwFlowNet_h
+
+namespace cw
+{
+  namespace flow
+  {
+    typedef enum {
+      kNetFirstPolyOrderId,
+      kProcFirstPolyOrderId
+    } network_order_id_t;
+    
+    rc_t network_create( flow_t* p,
+                         const object_t*    networkCfg,
+                         network_t&         net,                            // Network object to be filled with new proc instances
+                         unsigned           polyCnt = 1,                    // Count of networks to create
+                         network_order_id_t orderId = kNetFirstPolyOrderId  // Set the network exec order.
+      );
+    
+    rc_t network_destroy( network_t& net );
+
+    const object_t* find_network_preset( const network_t& net, const char* presetLabel );
+    
+    rc_t exec_cycle( network_t& net );
+
+
+    rc_t get_variable( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, instance_t*& instPtrRef, variable_t*& varPtrRef );
+
+    template< typename T >
+    rc_t set_variable_value( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, T value )
+    {
+      rc_t rc = kOkRC;
+      instance_t* inst = nullptr;
+      variable_t* var = nullptr;
+
+      // get the variable
+      if((rc = get_variable(net,inst_label,var_label,chIdx,inst,var)) != kOkRC )
+        goto errLabel;
+      
+      // set the variable value
+      if((rc = var_set( inst, var->vid, chIdx, value )) != kOkRC )
+      {
+        rc = cwLogError(kOpFailRC,"The variable set failed on instance:'%s' variable:'%s'.",cwStringNullGuard(inst_label),cwStringNullGuard(var_label));
+        goto errLabel;
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    template< typename T >
+    rc_t get_variable_value( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, T& valueRef )
+    {
+      rc_t rc = kOkRC;
+      instance_t* inst = nullptr;
+      variable_t* var = nullptr;
+
+      // get the variable 
+      if((rc = get_variable(net,inst_label,var_label,chIdx,inst,var)) != kOkRC )
+        goto errLabel;
+      
+      // get the variable value
+      if((rc = var_get( inst, var->vid, chIdx, valueRef )) != kOkRC )
+      {
+        rc = cwLogError(kOpFailRC,"The variable get failed on instance:'%s' variable:'%s'.",cwStringNullGuard(inst_label),cwStringNullGuard(var_label));
+        goto errLabel;
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t network_apply_preset( network_t& net, const char* presetLabel );
+    rc_t network_apply_dual_preset( network_t& net, const char* presetLabel_0, const char* presetLabel_1, double coeff );      
+    rc_t network_apply_preset( network_t& net, const multi_preset_selector_t& mps );
+    
+    
+  }
+}
+
+
+#endif
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 5eff84e..bb23ca1 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -17,6 +17,7 @@
 #include "cwFlowDecl.h"
 #include "cwFlow.h"
 #include "cwFlowTypes.h"
+#include "cwFlowNet.h"
 #include "cwFlowProc.h"
 
 #include "cwFile.h"
@@ -89,6 +90,119 @@ namespace cw
       };
       
     }    
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // poly
+    //
+    namespace poly
+    {
+      enum
+      {
+        kCountPId,
+        kOrderPId,
+      };
+      
+      typedef struct
+      {
+        unsigned   count;
+        network_t  net;
+        network_order_id_t orderId;
+      } inst_t;
+
+
+      rc_t create( instance_t* proc )
+      {
+        rc_t            rc          = kOkRC;        
+        inst_t*         inst        = mem::allocZ<inst_t>();
+        const object_t* networkCfg  = nullptr;
+        const char*     order_label = nullptr;
+        
+        proc->userPtr = inst;
+        
+        if((rc  = var_register_and_get( proc, kAnyChIdx,
+                                        kCountPId, "count", kBaseSfxId, inst->count,
+                                        kOrderPId, "order", kBaseSfxId, order_label )) != kOkRC )
+          goto errLabel;
+
+        if( inst->count == 0 )
+        {
+          cwLogWarning("The 'poly' %s:%i was given a count of 0.",proc->label,proc->label_sfx_id);
+          goto errLabel;
+        }
+
+        if((rc = proc->proc_cfg->getv("network",networkCfg)) != kOkRC )
+        {
+          rc = cwLogError(rc,"The 'network' cfg. was not found.");
+          goto errLabel;
+        }
+
+        // get the network exec. order type
+        if( textIsEqual(order_label,"net") )
+          inst->orderId = kNetFirstPolyOrderId;
+        else
+        {
+          if( textIsEqual(order_label,"proc") )
+            inst->orderId = kProcFirstPolyOrderId;
+          else
+          {
+            rc = cwLogError(kInvalidArgRC,"'%s' is not one of the valid order types (i.e. 'net','proc').",order_label);
+            goto errLabel;
+          }
+        }
+        
+        if((rc = network_create(proc->ctx,networkCfg,inst->net,inst->count )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Creation failed on the internal network.");
+          goto errLabel;
+        }
+
+
+        // Set the internal net pointer in the base proc instance
+        // so that network based utilities can scan it
+        proc->internal_net = &inst->net;
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        inst_t* p = (inst_t*)proc->userPtr;
+        network_destroy(p->net);
+
+        
+        mem::release( proc->userPtr );
+        return kOkRC;
+      }
+
+      rc_t value( instance_t* ctx, variable_t* var )
+      {
+        return kOkRC;
+      }
+
+      rc_t exec( instance_t* ctx )
+      {
+        inst_t* p = (inst_t*)ctx->userPtr;
+        rc_t   rc = kOkRC;
+
+        if((rc = exec_cycle(p->net)) != kOkRC )
+        {
+          rc = cwLogError(rc,"poly internal network exec failed.");
+        }
+        
+        return rc;
+      }
+
+      class_members_t members = {
+        .create               = create,
+        .destroy              = destroy,
+        .value                = value,
+        .exec                 = exec,
+        .report               = nullptr
+      };
+      
+    }    
     
     //------------------------------------------------------------------------------------------------------------------
     //
@@ -115,12 +229,12 @@ namespace cw
         real_t in_value = 0.5;
         ctx->userPtr = mem::allocZ<inst_t>();
         
-        if((rc  = var_register_and_get( ctx, kAnyChIdx, kInPId, "in", in_value )) != kOkRC )
+        if((rc  = var_register_and_get( ctx, kAnyChIdx, kInPId, "in", kBaseSfxId, in_value )) != kOkRC )
           goto errLabel;
 
         if((rc = var_register_and_set( ctx, kAnyChIdx,
-                                       kOutPId,    "out", in_value,
-                                       kInvOutPId, "inv_out", (real_t)(1.0-in_value) )) != kOkRC )
+                                       kOutPId,    "out",     kBaseSfxId, in_value,
+                                       kInvOutPId, "inv_out", kBaseSfxId, (real_t)(1.0-in_value) )) != kOkRC )
         {
           goto errLabel;
         }
@@ -205,14 +319,14 @@ namespace cw
 
         // Register variable and get their current value
         if((rc = var_register_and_get( ctx, kAnyChIdx,
-                                       kDevLabelPId,  "dev_label",  dev_label,
-                                       kPortLabelPId, "port_label", port_label )) != kOkRC )
+                                       kDevLabelPId,  "dev_label",  kBaseSfxId, dev_label,
+                                       kPortLabelPId, "port_label", kBaseSfxId, port_label )) != kOkRC )
           
         {
           goto errLabel;
         }
 
-        if((rc = var_register( ctx, kAnyChIdx,kOutPId, "out")) != kOkRC )
+        if((rc = var_register( ctx, kAnyChIdx, kOutPId, "out", kBaseSfxId)) != kOkRC )
         {
           goto errLabel;
         }
@@ -246,7 +360,7 @@ namespace cw
         inst->buf = mem::allocZ<midi::ch_msg_t>( inst->bufN );
 
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, nullptr, 0  );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, nullptr, 0  );
 
 
       errLabel: 
@@ -349,9 +463,9 @@ namespace cw
         
         // Register variables and get their current value
         if((rc = var_register_and_get( ctx, kAnyChIdx,
-                                       kDevLabelPId, "dev_label", dev_label,
-                                       kPortLabelPId,"port_label", port_label,
-                                       kInPId,       "in",         mbuf)) != kOkRC )
+                                       kDevLabelPId, "dev_label",  kBaseSfxId, dev_label,
+                                       kPortLabelPId,"port_label", kBaseSfxId, port_label,
+                                       kInPId,       "in",         kBaseSfxId, mbuf)) != kOkRC )
         {
           goto errLabel;
         }
@@ -444,7 +558,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // Register variable and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx, kDevLabelPId, "dev_label", inst->dev_label )) != kOkRC )
+        if((rc = var_register_and_get( ctx, kAnyChIdx, kDevLabelPId, "dev_label", kBaseSfxId, inst->dev_label )) != kOkRC )
         {
           goto errLabel;
         }
@@ -457,7 +571,7 @@ namespace cw
         
 
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, inst->ext_dev->u.a.abuf->srate, inst->ext_dev->u.a.abuf->chN, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, inst->ext_dev->u.a.abuf->srate, inst->ext_dev->u.a.abuf->chN, ctx->ctx->framesPerCycle );
 
       errLabel:
         return rc;
@@ -542,8 +656,8 @@ namespace cw
 
         // Register variables and get their current value
         if((rc = var_register_and_get( ctx, kAnyChIdx,
-                                       kDevLabelPId, "dev_label", inst->dev_label,
-                                       kInPId,       "in",        src_abuf)) != kOkRC )
+                                       kDevLabelPId, "dev_label", kBaseSfxId, inst->dev_label,
+                                       kInPId,       "in",        kBaseSfxId, src_abuf)) != kOkRC )
         {
           goto errLabel;
         }
@@ -638,16 +752,16 @@ namespace cw
         inst_t* inst = mem::allocZ<inst_t>();
         ctx->userPtr = inst;
 
-        if((rc = var_register( ctx, kAnyChIdx, kOnOffFlPId, "on_off" )) != kOkRC )
+        if((rc = var_register( ctx, kAnyChIdx, kOnOffFlPId, "on_off", kBaseSfxId)) != kOkRC )
         {
           goto errLabel;
         }
 
         // Register variable and get their current value
         if((rc = var_register_and_get( ctx, kAnyChIdx,
-                                       kFnamePId, "fname", inst->filename,
-                                       kSeekSecsPId, "seekSecs", seekSecs,
-                                       kEofFlPId, "eofFl", inst->eofFl )) != kOkRC )
+                                       kFnamePId,    "fname",    kBaseSfxId, inst->filename,
+                                       kSeekSecsPId, "seekSecs", kBaseSfxId, seekSecs,
+                                       kEofFlPId,    "eofFl",    kBaseSfxId, inst->eofFl )) != kOkRC )
         {
           goto errLabel;
         }
@@ -669,7 +783,7 @@ namespace cw
         cwLogInfo("Audio '%s' srate:%f chs:%i frames:%i %f seconds.",inst->filename,info.srate,info.chCnt,info.frameCnt, info.frameCnt/info.srate );
 
         // create one output audio buffer - with the same configuration as the source audio file
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, info.srate, info.chCnt, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, info.srate, info.chCnt, ctx->ctx->framesPerCycle );
 
       errLabel:
         return rc;
@@ -795,9 +909,9 @@ namespace cw
 
         // Register variables and get their current value
         if((rc = var_register_and_get( ctx, kAnyChIdx,
-                                       kFnamePId, "fname", inst->filename,
-                                       kBitsPId,  "bits",  audioFileBits,
-                                       kInPId,    "in",    src_abuf )) != kOkRC )
+                                       kFnamePId, "fname", kBaseSfxId, inst->filename,
+                                       kBitsPId,  "bits",  kBaseSfxId, audioFileBits,
+                                       kInPId,    "in",    kBaseSfxId, src_abuf )) != kOkRC )
         {
           goto errLabel;
         }
@@ -902,16 +1016,16 @@ namespace cw
         ctx->userPtr = mem::allocZ<inst_t>();
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",abuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
         // register the gain 
         for(unsigned i=0; i<abuf->chN; ++i)
-          if((rc = var_register( ctx, i, kGainPId, "gain" )) != kOkRC )
+          if((rc = var_register( ctx, i, kGainPId, "gain", kBaseSfxId )) != kOkRC )
             goto errLabel;
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
 
 
       errLabel:
@@ -1021,7 +1135,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",abuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId, abuf )) != kOkRC )
           goto errLabel;
 
         if( abuf->chN )
@@ -1030,20 +1144,20 @@ namespace cw
           
           inst->chSelMap = mem::allocZ<bool>(abuf->chN);
           
-          if((rc = var_channel_count(ctx,"select",selChN)) != kOkRC )
+          if((rc = var_channel_count(ctx,"select",kBaseSfxId,selChN)) != kOkRC )
             goto errLabel;
           
           // register the gain 
           for(unsigned i=0; i<abuf->chN; ++i)
           {
             if( i < selChN )
-              if((rc = var_register_and_get( ctx, i, kSelectPId, "select", inst->chSelMap[i] )) != kOkRC )
+              if((rc = var_register_and_get( ctx, i, kSelectPId, "select", kBaseSfxId, inst->chSelMap[i] )) != kOkRC )
                 goto errLabel;
 
             if( inst->chSelMap[i] )
             {
               // register an output gain control
-              if((rc = var_register( ctx, inst->outChN, kGainPId, "gain")) != kOkRC )
+              if((rc = var_register( ctx, inst->outChN, kGainPId, "gain", kBaseSfxId)) != kOkRC )
                 goto errLabel;
 
               // count the number of selected channels to determine the count of output channels
@@ -1055,7 +1169,7 @@ namespace cw
           if( inst->outChN == 0 )
             cwLogWarning("The audio split instance '%s' has no selected channels.",ctx->label);
           else
-            rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
+            rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
         }
 
       errLabel:
@@ -1162,7 +1276,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",abuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
         if( abuf->chN )
@@ -1172,13 +1286,13 @@ namespace cw
           // register the gain 
           for(unsigned i=0; i<abuf->chN; ++i)
           {
-            if((rc = var_register_and_get( ctx, i, kDuplicatePId, "duplicate", inst->chDuplMap[i] )) != kOkRC )
+            if((rc = var_register_and_get( ctx, i, kDuplicatePId, "duplicate", kBaseSfxId, inst->chDuplMap[i] )) != kOkRC )
               goto errLabel;
 
             if( inst->chDuplMap[i] )
             {
               // register an input gain control
-              if((rc = var_register( ctx, inst->outChN, kGainPId, "gain")) != kOkRC )
+              if((rc = var_register( ctx, inst->outChN, kGainPId, "gain", kBaseSfxId)) != kOkRC )
                 goto errLabel;
 
               // count the number of selected channels to determine the count of output channels
@@ -1190,7 +1304,7 @@ namespace cw
           if( inst->outChN == 0 )
             cwLogWarning("The audio split instance '%s' has no selected channels.",ctx->label);
           else
-            rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
+            rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
         }
 
       errLabel:
@@ -1309,11 +1423,11 @@ namespace cw
           // TODO: allow non-contiguous source labels
           
           // the source labels must be contiguous
-          if( !var_has_value( ctx, label, kAnyChIdx ) )
+          if( !var_has_value( ctx, label, kBaseSfxId, kAnyChIdx ) )
             break;
           
           // get the source audio buffer
-          if((rc = var_register_and_get(ctx, kAnyChIdx,kInBasePId+i,label,abuf )) != kOkRC )
+          if((rc = var_register_and_get(ctx, kAnyChIdx,kInBasePId+i,label,kBaseSfxId, abuf )) != kOkRC )
           {
             goto errLabel;
           }
@@ -1337,11 +1451,11 @@ namespace cw
 
         // register the gain 
         for(unsigned i=0; i<outChN; ++i)
-          if((rc = var_register( ctx, i, kGainPId, "gain" )) != kOkRC )
+          if((rc = var_register( ctx, i, kGainPId, "gain", kBaseSfxId )) != kOkRC )
             goto errLabel;
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srate, outChN, frameN );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, outChN, frameN );
 
       errLabel:
         return rc;
@@ -1473,8 +1587,8 @@ namespace cw
         
         // get the source audio buffer
         if((rc = var_register_and_get(ctx, kAnyChIdx,
-                                      kIn0PId,"in0",abuf0,
-                                      kIn1PId,"in1",abuf1 )) != kOkRC )
+                                      kIn0PId,"in0",kBaseSfxId,abuf0,
+                                      kIn1PId,"in1",kBaseSfxId,abuf1 )) != kOkRC )
         {
           goto errLabel;
         }
@@ -1484,11 +1598,11 @@ namespace cw
         outChN = std::max(abuf0->chN, abuf1->chN);
 
         // register the gain
-        var_register_and_get( ctx, kAnyChIdx, kGain0PId, "gain0", dum );
-        var_register_and_get( ctx, kAnyChIdx, kGain1PId, "gain1", dum );
+        var_register_and_get( ctx, kAnyChIdx, kGain0PId, "gain0", kBaseSfxId, dum );
+        var_register_and_get( ctx, kAnyChIdx, kGain1PId, "gain1", kBaseSfxId, dum );
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, abuf0->srate, outChN, abuf0->frameN );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf0->srate, outChN, abuf0->frameN );
 
       errLabel:
         return rc;
@@ -1601,7 +1715,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // Register variables and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx, kChCntPid, "chCnt", chCnt)) != kOkRC )
+        if((rc = var_register_and_get( ctx, kAnyChIdx, kChCntPid, "chCnt", kBaseSfxId, chCnt)) != kOkRC )
         {
           goto errLabel;
         }
@@ -1609,15 +1723,15 @@ namespace cw
         // register each oscillator variable
         for(unsigned i=0; i<chCnt; ++i)
           if((rc = var_register_and_get( ctx, i,
-                                         kSratePId,  "srate", srate,
-                                         kFreqHzPId, "hz",    hz,
-                                         kGainPId,   "gain",  gain)) != kOkRC )
+                                         kSratePId,  "srate", kBaseSfxId, srate,
+                                         kFreqHzPId, "hz",    kBaseSfxId, hz,
+                                         kGainPId,   "gain",  kBaseSfxId, gain)) != kOkRC )
           {
             goto errLabel;
           }
 
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srate, chCnt, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, chCnt, ctx->ctx->framesPerCycle );
 
         inst->phaseA = mem::allocZ<real_t>( chCnt );
         
@@ -1719,7 +1833,7 @@ namespace cw
         inst_t*       inst   = mem::allocZ<inst_t>();
         ctx->userPtr = inst;
 
-        if((rc = var_register_and_get( ctx, kAnyChIdx,kInPId, "in", srcBuf )) != kOkRC )
+        if((rc = var_register_and_get( ctx, kAnyChIdx,kInPId, "in", kBaseSfxId, srcBuf )) != kOkRC )
         {
           cwLogError(kInvalidArgRC,"Unable to access the 'src' buffer.");
         }
@@ -1746,10 +1860,10 @@ namespace cw
             bool hzFl = false;
             
             if((rc = var_register_and_get( ctx, i,
-                                           kMaxWndSmpNPId, "maxWndSmpN", maxWndSmpN,
-                                           kWndSmpNPId, "wndSmpN", wndSmpN,
-                                           kHopSmpNPId, "hopSmpN", hopSmpN,
-                                           kHzFlPId,    "hzFl",    hzFl )) != kOkRC )
+                                           kMaxWndSmpNPId, "maxWndSmpN", kBaseSfxId, maxWndSmpN,
+                                           kWndSmpNPId, "wndSmpN",       kBaseSfxId, wndSmpN,
+                                           kHopSmpNPId, "hopSmpN",       kBaseSfxId, hopSmpN,
+                                           kHzFlPId,    "hzFl",          kBaseSfxId, hzFl )) != kOkRC )
             {
               goto errLabel;
             }
@@ -1771,7 +1885,7 @@ namespace cw
 
         
           // create the fbuf 'out'
-          if((rc = var_register_and_set(ctx, "out", kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, maxBinNV, binNV, hopNV, magV, phsV, hzV )) != kOkRC )
+          if((rc = var_register_and_set(ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, maxBinNV, binNV, hopNV, magV, phsV, hzV )) != kOkRC )
           {
             cwLogError(kOpFailRC,"The output freq. buffer could not be created.");
             goto errLabel;
@@ -1902,7 +2016,7 @@ namespace cw
         inst_t*       inst   = mem::allocZ<inst_t>();
         ctx->userPtr = inst;
 
-        if((rc = var_register_and_get( ctx, kAnyChIdx,kInPId, "in", srcBuf)) != kOkRC )
+        if((rc = var_register_and_get( ctx, kAnyChIdx,kInPId, "in", kBaseSfxId, srcBuf)) != kOkRC )
         {
           goto errLabel;
         }
@@ -1925,11 +2039,11 @@ namespace cw
             }
           }
 
-          if((rc = var_register( ctx, kAnyChIdx, kInPId, "in" )) != kOkRC )
+          if((rc = var_register( ctx, kAnyChIdx, kInPId, "in", kBaseSfxId)) != kOkRC )
             goto errLabel;
 
           // create the abuf 'out'
-          rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, ctx->ctx->framesPerCycle );
+          rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, ctx->ctx->framesPerCycle );
         }
         
       errLabel:
@@ -2035,7 +2149,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
           rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
           goto errLabel;
@@ -2070,13 +2184,13 @@ namespace cw
             spec_dist_t* sd = inst->sdA[i];
 
             if((rc = var_register_and_get( ctx, i,
-                                           kBypassPId,   "bypass",   sd->bypassFl,
-                                           kCeilingPId,  "ceiling",  sd->ceiling,
-                                           kExpoPId,     "expo",     sd->expo,
-                                           kThreshPId,   "thresh",   sd->thresh,
-                                           kUprSlopePId, "upr",      sd->uprSlope,
-                                           kLwrSlopePId, "lwr",      sd->lwrSlope,
-                                           kMixPId,      "mix",      sd->mix )) != kOkRC )
+                                           kBypassPId,   "bypass",   kBaseSfxId, sd->bypassFl,
+                                           kCeilingPId,  "ceiling",  kBaseSfxId, sd->ceiling,
+                                           kExpoPId,     "expo",     kBaseSfxId, sd->expo,
+                                           kThreshPId,   "thresh",   kBaseSfxId, sd->thresh,
+                                           kUprSlopePId, "upr",      kBaseSfxId, sd->uprSlope,
+                                           kLwrSlopePId, "lwr",      kBaseSfxId, sd->lwrSlope,
+                                           kMixPId,      "mix",      kBaseSfxId, sd->mix )) != kOkRC )
             {
               goto errLabel;
             }
@@ -2084,7 +2198,7 @@ namespace cw
           }
           
           // create the output buffer
-          if((rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->maxBinN_V, srcBuf->binN_V, srcBuf->hopSmpN_V, magV, phsV, hzV )) != kOkRC )
+          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->maxBinN_V, srcBuf->binN_V, srcBuf->hopSmpN_V, magV, phsV, hzV )) != kOkRC )
             goto errLabel;
         }
         
@@ -2223,7 +2337,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
           rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
           goto errLabel;
@@ -2243,15 +2357,15 @@ namespace cw
 
             // get the compressor variable values
             if((rc = var_register_and_get( ctx, i,
-                                           kBypassPId,   "bypass",    bypassFl,
-                                           kInGainPId,   "igain",     igain,
-                                           kThreshPId,   "thresh",    thresh,
-                                           kRatioPId,    "ratio",     ratio,
-                                           kAtkMsPId,    "atk_ms",    atk_ms,
-                                           kRlsMsPId,    "rls_ms",    rls_ms,
-                                           kWndMsPId,    "wnd_ms",    wnd_ms,
-                                           kMaxWndMsPId, "maxWnd_ms", maxWnd_ms,
-                                           kOutGainPId,  "ogain",     ogain )) != kOkRC )
+                                           kBypassPId,   "bypass",    kBaseSfxId, bypassFl,
+                                           kInGainPId,   "igain",     kBaseSfxId, igain,
+                                           kThreshPId,   "thresh",    kBaseSfxId, thresh,
+                                           kRatioPId,    "ratio",     kBaseSfxId, ratio,
+                                           kAtkMsPId,    "atk_ms",    kBaseSfxId, atk_ms,
+                                           kRlsMsPId,    "rls_ms",    kBaseSfxId, rls_ms,
+                                           kWndMsPId,    "wnd_ms",    kBaseSfxId, wnd_ms,
+                                           kMaxWndMsPId, "maxWnd_ms", kBaseSfxId, maxWnd_ms,
+                                           kOutGainPId,  "ogain",     kBaseSfxId, ogain )) != kOkRC )
             {
               goto errLabel;
             }
@@ -2266,7 +2380,7 @@ namespace cw
           }
           
           // create the output audio buffer
-          if((rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
+          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
             goto errLabel;
         }
         
@@ -2411,7 +2525,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
           rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
           goto errLabel;
@@ -2431,10 +2545,10 @@ namespace cw
 
             // get the limiter variable values
             if((rc = var_register_and_get( ctx, i,
-                                           kBypassPId,   "bypass",    bypassFl,
-                                           kInGainPId,   "igain",     igain,
-                                           kThreshPId,   "thresh",    thresh,
-                                           kOutGainPId,  "ogain",     ogain )) != kOkRC )
+                                           kBypassPId,   "bypass",    kBaseSfxId, bypassFl,
+                                           kInGainPId,   "igain",     kBaseSfxId, igain,
+                                           kThreshPId,   "thresh",    kBaseSfxId, thresh,
+                                           kOutGainPId,  "ogain",     kBaseSfxId, ogain )) != kOkRC )
             {
               goto errLabel;
             }
@@ -2449,7 +2563,7 @@ namespace cw
           }
           
           // create the output audio buffer
-          if((rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
+          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
             goto errLabel;
         }
         
@@ -2585,7 +2699,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",abuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
 
@@ -2596,8 +2710,8 @@ namespace cw
         for(unsigned i=0; i<abuf->chN; ++i)
         {
           if((rc = var_register_and_get( ctx, i,
-                                         kMaxDelayMsPId, "maxDelayMs", maxDelayMs,
-                                         kDelayMsPId,    "delayMs",    delayMs)) != kOkRC )
+                                         kMaxDelayMsPId, "maxDelayMs", kBaseSfxId, maxDelayMs,
+                                         kDelayMsPId,    "delayMs",    kBaseSfxId, delayMs)) != kOkRC )
           {
             goto errLabel;
           }
@@ -2617,7 +2731,7 @@ namespace cw
         inst->delayBuf = abuf_create( abuf->srate, abuf->chN, inst->maxDelayFrameN );
         
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
 
 
       errLabel:
@@ -2775,7 +2889,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
           rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
           goto errLabel;
@@ -2795,8 +2909,8 @@ namespace cw
 
             // get the dc_filter variable values
             if((rc = var_register_and_get( ctx, i,
-                                           kBypassPId,   "bypass",    bypassFl,
-                                           kGainPId,     "gain",      gain )) != kOkRC )
+                                           kBypassPId,   "bypass",    kBaseSfxId, bypassFl,
+                                           kGainPId,     "gain",      kBaseSfxId, gain )) != kOkRC )
             {
               goto errLabel;
             }
@@ -2811,7 +2925,7 @@ namespace cw
           }
           
           // create the output audio buffer
-          if((rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
+          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
             goto errLabel;
         }
         
@@ -2931,7 +3045,7 @@ namespace cw
         ctx->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
           rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
           goto errLabel;
@@ -2950,18 +3064,18 @@ namespace cw
 	    
             // get the audio_meter variable values
             if((rc = var_register_and_get( ctx, i,
-                                           kDbFlPId,   "dbFl",    dbFl,
-                                           kWndMsPId, "wndMs",    wndMs,
-                                           kPeakDbPId, "peakDb",  peakThreshDb )) != kOkRC )
+                                           kDbFlPId,   "dbFl",    kBaseSfxId, dbFl,
+                                           kWndMsPId, "wndMs",    kBaseSfxId, wndMs,
+                                           kPeakDbPId, "peakDb",  kBaseSfxId, peakThreshDb )) != kOkRC )
             {
               goto errLabel;
             }
 
             // get the audio_meter variable values
             if((rc = var_register( ctx, i,
-                                   kOutPId,   "out",
-                                   kPeakFlPId, "peakFl",
-                                   kClipFlPId, "clipFl" )) != kOkRC )
+                                   kOutPId,   "out",     kBaseSfxId,
+                                   kPeakFlPId, "peakFl", kBaseSfxId, 
+                                   kClipFlPId, "clipFl", kBaseSfxId )) != kOkRC )
             {
               goto errLabel;
             }
@@ -3075,15 +3189,15 @@ namespace cw
         ctx->userPtr = mem::allocZ<inst_t>();
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",abuf )) != kOkRC )
+        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
         // register the marker input 
-        if((rc = var_register_and_set( ctx, kAnyChIdx, kMarkPId, "mark", 0.0f )) != kOkRC )
+        if((rc = var_register_and_set( ctx, kAnyChIdx, kMarkPId, "mark", kBaseSfxId, 0.0f )) != kOkRC )
           goto errLabel;
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
 
       errLabel:
         return rc;
@@ -3147,6 +3261,307 @@ namespace cw
       };
       
     }
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // xfade_ctl
+    //
+    namespace xfade_ctl
+    {
+      enum {
+        kNetLabelPId,
+        kNetLabelSfxPId,
+        kSrateRefPId,
+        kDurMsPId,
+        kTriggerPId,
+        kGainPId,
+      };
+      
+      typedef struct
+      {
+        unsigned    xfadeDurMs;        // crossfade duration in milliseconds
+        instance_t* net_proc;          // source 'poly' network
+        network_t   net;               // internal proxy network 
+        unsigned    poly_ch_cnt;      // set to 2 (one for 'cur' poly-ch., one for 'next' poly-ch.)
+        unsigned    net_proc_cnt;      // count of proc's in a single poly-channel (net_proc->proc_arrayN/poly_cnt)
+        unsigned    cur_poly_ch_idx;  // 
+        unsigned    next_poly_ch_idx; //
+        float*      target_gainA;     // target_gainA[net_proc->poly_cnt]
+        float*      cur_gainA;        // cur_gainA[net_proc->poly_cnt]
+        double      srate;
+        
+      } inst_t;
+
+      void _trigger_xfade( inst_t* p )
+      {
+        // begin fading out the cur channel
+        p->target_gainA[ p->cur_poly_ch_idx ] = 0;
+        
+        // the next poly-ch become the cur poly-ch
+        p->cur_poly_ch_idx  = p->next_poly_ch_idx;
+
+        // the next poly-ch advances
+        p->next_poly_ch_idx = p->next_poly_ch_idx+1 >= p->poly_ch_cnt ? 0 : p->next_poly_ch_idx+1;
+
+        // j selects a block of 'net_proc_cnt' slots in the proxy network which will become the 'next' channel
+        unsigned j = p->next_poly_ch_idx * p->net_proc_cnt;
+
+        // set the [j:j+poly_proc_cnt] pointers in the proxy net to the actual proc instances in the source net
+        for(unsigned i=0; i<p->net_proc->internal_net->proc_arrayN; ++i)
+          if( p->net_proc->internal_net->proc_array[i]->label_sfx_id == p->next_poly_ch_idx )
+          {
+            assert( p->next_poly_ch_idx * p->net_proc_cnt <= j
+                    && j < p->next_poly_ch_idx * p->net_proc_cnt + p->net_proc_cnt
+                    && j < p->net.proc_arrayN );
+            
+            p->net.proc_array[j++] = p->net_proc->internal_net->proc_array[i];
+          }
+
+        // begin fading in the new cur channel
+        p->target_gainA[ p->cur_poly_ch_idx ] = 1;
+
+        // if the next channel is not already at 0 send it in that direction
+        p->target_gainA[ p->next_poly_ch_idx ] = 0; 
+
+      }
+
+
+
+      rc_t create( instance_t* ctx )
+      {
+        rc_t        rc            = kOkRC;
+        const char* netLabel      = nullptr;
+        unsigned    netLabelSfxId = kBaseSfxId;
+        bool        trigFl        = false;
+        variable_t* gainVar       = nullptr;
+        abuf_t*     srateSrc      = nullptr;
+        double      dum;
+
+        inst_t* p = mem::allocZ<inst_t>();
+
+        ctx->userPtr = p;
+        
+        p->poly_ch_cnt = 2;
+        
+        if((rc = var_register_and_get(ctx,kAnyChIdx,
+                                      kNetLabelPId,       "net",       kBaseSfxId, netLabel,
+                                      kNetLabelSfxPId,    "netSfxId",  kBaseSfxId, netLabelSfxId,
+                                      kSrateRefPId,       "srateSrc",  kBaseSfxId, srateSrc,
+                                      kDurMsPId,          "durMs",     kBaseSfxId, p->xfadeDurMs,
+                                      kTriggerPId,         "trigger",  kBaseSfxId, trigFl,
+                                      kGainPId,            "gain",     kBaseSfxId, dum)) != kOkRC )
+        {
+          goto errLabel; 
+        }
+
+        // locate the source poly-network for this xfad-ctl
+        if((rc = instance_find(*ctx->net,netLabel,netLabelSfxId,p->net_proc)) != kOkRC )
+        {
+          cwLogError(rc,"The xfade_ctl source network proc instance '%s:%i' was not found.",cwStringNullGuard(netLabel),netLabelSfxId);
+          goto errLabel;
+        }
+
+        if( p->net_proc->internal_net->poly_cnt < 3 )
+        {
+          cwLogError(rc,"The xfade_ctl source network must have at least 3 poly channels. %i < 3",p->net_proc->internal_net->poly_cnt);
+          goto errLabel;
+        }
+          
+
+        // create the gain output variables - one output for each poly-channel
+        for(unsigned i=1; i<p->net_proc->internal_net->poly_cnt; ++i)
+        {
+          variable_t* dum;
+          if((rc = var_create(ctx, "gain", i, kGainPId+i, kAnyChIdx, nullptr, dum )) != kOkRC )
+          {
+            cwLogError(rc,"'gain:%i' create failed.",i);
+            goto errLabel;
+          }
+        }
+
+        // count of proc's in one poly-ch of the poly network
+        p->net_proc_cnt = p->net_proc->internal_net->proc_arrayN / p->net_proc->internal_net->poly_cnt;
+
+        // create the proxy network
+        p->net.proc_arrayAllocN = p->net_proc_cnt * p->poly_ch_cnt;
+        p->net.proc_arrayN = p->net.proc_arrayAllocN;
+        p->net.proc_array  = mem::allocZ<instance_t*>(p->net.proc_arrayAllocN);
+        p->target_gainA    = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
+        p->cur_gainA       = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
+        p->srate           = srateSrc->srate;
+        
+        // make the proxy network public - xfad_ctl now looks like the source network
+        // because it has the same proc instances
+        ctx->internal_net = &p->net;
+
+        // setup the channels such that the first active channel after _trigger_xfade()
+        // will be channel 0
+        p->cur_poly_ch_idx  = 1;
+        p->next_poly_ch_idx = 2;
+        _trigger_xfade(p);  // cur=2 nxt=0 initialize inst ptrs in range: p->net[0:net_proc_cnt]
+        _trigger_xfade(p);  // cur=0 nxt=1 initialize inst ptrs in range: p->net[net_proc_cnt:2*net_proc_cnt]
+
+
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* ctx )
+      {
+        inst_t* p = (inst_t*)ctx->userPtr;
+        mem::release(p->net.proc_array);
+        mem::release(p->target_gainA);
+        mem::release(p->cur_gainA);
+        mem::release(ctx->userPtr);
+        
+        return kOkRC;
+      }
+
+      rc_t value( instance_t* ctx, variable_t* var )
+      { return kOkRC; }
+
+      // return sign of expression as a float
+      float _signum( float v ) { return (0.0f < v) - (v < 0.0f); }
+      
+      rc_t exec( instance_t* ctx )
+      {
+        rc_t    rc     = kOkRC;
+        inst_t* p      = (inst_t*)ctx->userPtr;
+        bool    trigFl = false;
+
+        // check if a cross-fade has been triggered
+        if((rc = var_get(ctx,kTriggerPId,kAnyChIdx,trigFl)) == kOkRC )
+        {
+          _trigger_xfade(p);
+          
+          var_set(ctx,kTriggerPId,kAnyChIdx,false);
+        }
+        
+        // time in sample frames to complete a xfade
+        double xfade_dur_smp        = p->xfadeDurMs * p->srate / 1000.0;
+
+        // fraction of a xfade which will be completed in on exec() cycle
+        float delta_gain_per_cycle =  (float)(ctx->ctx->framesPerCycle / xfade_dur_smp);
+
+        // update the cross-fade gain outputs
+        for(unsigned i=0; i<p->net_proc->internal_net->poly_cnt; ++i)
+        {
+          p->cur_gainA[i] += _signum(p->target_gainA[i] - p->cur_gainA[i]) * delta_gain_per_cycle;
+          
+          p->cur_gainA[i] = std::min(1.0f, std::max(0.0f, p->cur_gainA[i]));
+          
+          var_set(ctx,kGainPId+i,kAnyChIdx,p->cur_gainA[i]);
+        }
+        
+      errLabel:
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
+    
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // poly_mixer
+    //
+    namespace poly_mixer
+    {
+      enum {
+        kOutGainPId,
+        kOutPId,
+        
+      };
+      
+      typedef struct
+      {
+        unsigned inBaseVId;
+        unsigned gainBaseVId;
+      } inst_t;
+
+
+      rc_t create( instance_t* ctx )
+      {
+        rc_t          rc     = kOkRC;
+        /*
+        const abuf_t* abuf0  = nullptr; //
+        const abuf_t* abuf1  = nullptr;
+        unsigned      outChN = 0;
+        double dum;
+        
+        // get the source audio buffer
+        if((rc = var_register_and_get(ctx, kAnyChIdx,
+                                      kIn0PId,"in0",kBaseSfxId,abuf0,
+                                      kIn1PId,"in1",kBaseSfxId,abuf1 )) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        assert( abuf0->frameN == abuf1->frameN );
+
+        outChN = std::max(abuf0->chN, abuf1->chN);
+
+        // register the gain
+        var_register_and_get( ctx, kAnyChIdx, kGain0PId, "gain0", kBaseSfxId, dum );
+        var_register_and_get( ctx, kAnyChIdx, kGain1PId, "gain1", kBaseSfxId, dum );
+
+        // create the output audio buffer
+        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf0->srate, outChN, abuf0->frameN );
+        */
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* ctx )
+      { return kOkRC; }
+
+      rc_t value( instance_t* ctx, variable_t* var )
+      { return kOkRC; }
+
+      
+      rc_t exec( instance_t* ctx )
+      {
+        rc_t          rc    = kOkRC;
+        /*
+        abuf_t*       obuf  = nullptr;
+        //const abuf_t* ibuf0 = nullptr;
+        //const abuf_t* ibuf1 = nullptr;
+
+        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+          goto errLabel;
+
+        //if((rc = var_get(ctx,kIn0PId, kAnyChIdx, ibuf0 )) != kOkRC )
+        //  goto errLabel;
+        
+        //if((rc = var_get(ctx,kIn1PId, kAnyChIdx, ibuf1 )) != kOkRC )
+        //  goto errLabel;
+
+        vop::zero(obuf->buf, obuf->frameN*obuf->chN );
+        
+        _mix( ctx, kIn0PId, kGain0PId, obuf );
+        _mix( ctx, kIn1PId, kGain1PId, obuf );
+        */
+        
+      errLabel:
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
     
     
   } // flow
diff --git a/cwFlowProc.h b/cwFlowProc.h
index 026bbed..3898cb1 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -2,6 +2,7 @@ namespace cw
 {
   namespace flow
   {
+    namespace poly            { extern class_members_t members;  }
     namespace midi_in         { extern class_members_t members;  }
     namespace midi_out        { extern class_members_t members;  }
     namespace audio_in        { extern class_members_t members;  }
@@ -24,5 +25,7 @@ namespace cw
     namespace balance         { extern class_members_t members;  }
     namespace audio_meter     { extern class_members_t members;  }
     namespace audio_marker    { extern class_members_t members;  }
+    namespace xfade_ctl       { extern class_members_t members;  }
+    namespace poly_mixer      { extern class_members_t members;  }
   }
 }
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 477b5f1..0788edc 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -393,7 +393,7 @@ namespace cw
         return cwLogError(kInvalidArgRC,"Cannnot get the value of a non-existent variable.");
       
       if( var->value == nullptr )
-        return cwLogError(kInvalidStateRC,"No value has been assigned to the variable: %s.%s ch:%i.",cwStringNullGuard(var->inst->label),cwStringNullGuard(var->label),var->chIdx);
+        return cwLogError(kInvalidStateRC,"No value has been assigned to the variable: %s:%i.%s:%i ch:%i.",cwStringNullGuard(var->inst->label),var->inst->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id,var->chIdx);
 
       return _val_get(var->value,valRef);
     }
@@ -408,7 +408,7 @@ namespace cw
       {
         // validate the type of the variable against the description
         if( !cwIsFlag(varRef->varDesc->type,typeFl ) )
-          rc = cwLogError(kTypeMismatchRC,"Type mismatch. Instance:%s variable:%s with type 0x%x does not match requested type:0x%x.",varRef->inst->label,varRef->label,varRef->varDesc->type,typeFl);
+          rc = cwLogError(kTypeMismatchRC,"Type mismatch. Instance:%s:%i variable:%s:%i with type 0x%x does not match requested type:0x%x.",varRef->inst->label,varRef->inst->label_sfx_id,varRef->label,varRef->label_sfx_id,varRef->varDesc->type,typeFl);
     
       }
 
@@ -430,16 +430,16 @@ namespace cw
           return kOkRC;
         }
       }
-      return cwLogError(kInvalidIdRC,"The variable matching id:%i ch:%i on instance '%s' could not be found.", vid, chIdx, inst->label);
+      return cwLogError(kInvalidIdRC,"The variable matching id:%i ch:%i on instance '%s:%i' could not be found.", vid, chIdx, inst->label, inst->label_sfx_id);
     }
 
     // Variable lookup: Exact match on label and chIdx
-    variable_t* _var_find_on_label_and_ch( instance_t* inst, const char* var_label, unsigned chIdx )
+    variable_t* _var_find_on_label_and_ch( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx )
     {
       for(variable_t* var = inst->varL; var!=nullptr; var=var->var_link)
       {
         // the variable vid and chIdx should form a unique pair
-        if( textCompare(var->label,var_label)==0 && var->chIdx == chIdx )
+        if( var->label_sfx_id==sfx_id && textCompare(var->label,var_label)==0 && var->chIdx == chIdx )
           return var;
       }
       
@@ -450,10 +450,10 @@ namespace cw
     rc_t _validate_var_assignment( variable_t* var, unsigned typeFl )
     {
       if( cwIsFlag(var->varDesc->flags, kSrcVarFl ) )
-        return cwLogError(kInvalidStateRC, "The variable '%s' on instance '%s' cannot be set because it is a 'src' variable.", var->label, var->inst->label);
+        return cwLogError(kInvalidStateRC, "The variable '%s:%i' on instance '%s:%i' cannot be set because it is a 'src' variable.", var->label, var->label_sfx_id, var->inst->label,var->inst->label_sfx_id);
       
       if( !cwIsFlag(var->varDesc->type, typeFl ) )
-        return cwLogError(kTypeMismatchRC, "The variable '%s' on instance '%s' is not a  '%s'.", var->label, var->inst->label, _typeFlagToLabel( typeFl ));
+        return cwLogError(kTypeMismatchRC, "The variable '%s:%i' on instance '%s:%i' is not a  '%s'.", var->label, var->label_sfx_id, var->inst->label, var->inst->label_sfx_id, _typeFlagToLabel( typeFl ));
 
       return kOkRC;
     }
@@ -482,7 +482,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.b   = val;
       var->local_value[ local_value_idx ].flags = kBoolTFl;
-      cwLogMod("%s.%s ch:%i %i (bool).",var->inst->label,var->label,var->chIdx,val);
+      cwLogMod("%s:%i.%s:%i ch:%i %i (bool).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
     }
 
     template<>
@@ -490,7 +490,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.u   = val;
       var->local_value[ local_value_idx ].flags = kUIntTFl;
-      cwLogMod("%s.%s ch:%i %i (uint).",var->inst->label,var->label,var->chIdx,val);
+      cwLogMod("%s:%i.%s:%i ch:%i %i (uint).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
     }
 
     template<>
@@ -498,7 +498,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.i   = val;
       var->local_value[ local_value_idx ].flags = kIntTFl;
-      cwLogMod("%s.%s ch:%i %i (int).",var->inst->label,var->label,var->chIdx,val);
+      cwLogMod("%s:%i.%s:%i ch:%i %i (int).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
     }
 
     template<>
@@ -506,7 +506,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.f   = val;
       var->local_value[ local_value_idx ].flags = kFloatTFl;
-      cwLogMod("%s.%s ch:%i %f (float).",var->inst->label,var->label,var->chIdx,val);
+      cwLogMod("%s:%i.%s:%i ch:%i %f (float).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
     }
 
     template<>
@@ -514,7 +514,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.d   = val;
       var->local_value[ local_value_idx ].flags = kDoubleTFl;
-      cwLogMod("%s.%s ch:%i %f (double).",var->inst->label,var->label,var->chIdx,val);
+      cwLogMod("%s:%i.%s:%i ch:%i %f (double).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
     }
 
     template<>
@@ -522,7 +522,7 @@ namespace cw
     {      
       var->local_value[ local_value_idx ].u.s   = mem::duplStr(val);
       var->local_value[ local_value_idx ].flags = kStringTFl;
-      cwLogMod("%s.%s ch:%i %s (string).",var->inst->label,var->label,var->chIdx,val);
+      cwLogMod("%s:%i.%s:%i ch:%i %s (string).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
     }
 
     template<>
@@ -530,7 +530,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.abuf   = val;
       var->local_value[ local_value_idx ].flags = kABufTFl;
-      cwLogMod("%s.%s ch:%i %s (abuf).",var->inst->label,var->label,var->chIdx,abuf==nullptr ? "null" : "valid");
+      cwLogMod("%s:%i.%s:%i ch:%i %s (abuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,abuf==nullptr ? "null" : "valid");
     }
 
     template<>
@@ -538,7 +538,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.mbuf   = val;
       var->local_value[ local_value_idx ].flags = kMBufTFl;
-      cwLogMod("%s.%s ch:%i %s (abuf).",var->inst->label,var->label,var->chIdx,mbuf==nullptr ? "null" : "valid");
+      cwLogMod("%s:%i.%s:%i ch:%i %s (abuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,mbuf==nullptr ? "null" : "valid");
     }
     
     template<>
@@ -546,7 +546,7 @@ namespace cw
     {
       var->local_value[ local_value_idx ].u.fbuf = val;
       var->local_value[ local_value_idx ].flags  = kFBufTFl;
-      cwLogMod("%s.%s ch:%i %s (fbuf).",var->inst->label,var->label,var->chIdx,fbuf==nullptr ? "null" : "valid");
+      cwLogMod("%s:%i.%s:%i ch:%i %s (fbuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,fbuf==nullptr ? "null" : "valid");
     }
     
     template< typename T >
@@ -644,11 +644,11 @@ namespace cw
     }
 
     
-    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, abuf_t* abuf )
+    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, abuf_t* abuf )
     {
       rc_t rc;
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, vid, chIdx, var)) != kOkRC )
+      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
         return rc;
 
       if( var != nullptr )
@@ -657,11 +657,11 @@ namespace cw
       return rc;
     }
 
-    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, mbuf_t* mbuf )
+    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, mbuf_t* mbuf )
     {
       rc_t rc;
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, vid, chIdx, var)) != kOkRC )
+      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
         return rc;
 
       if( var != nullptr )
@@ -670,11 +670,11 @@ namespace cw
       return rc;
     }
     
-    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, fbuf_t* fbuf )
+    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, fbuf_t* fbuf )
     {
       rc_t rc;
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, vid, chIdx, var)) != kOkRC )
+      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
         return rc;
 
       if( var != nullptr )
@@ -746,7 +746,7 @@ namespace cw
 
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(kSyntaxErrorRC,"The %s.%s could not extract a type:%s from a configuration value.",var->inst->label,var->label,_typeFlagToLabel(var->varDesc->type & kTypeMask));
+        rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
       return rc;
       
     }
@@ -757,20 +757,20 @@ namespace cw
 
       // verify that the map idx is valid
       if( idx >= inst->varMapN )
-        return cwLogError(kAssertFailRC,"The variable map positioning location %i is out of the range %i on instance '%s' vid:%i ch:%i.", idx, inst->varMapN, inst->label,vid,chIdx);
+        return cwLogError(kAssertFailRC,"The variable map positioning location %i is out of the range %i on instance '%s:%i' vid:%i ch:%i.", idx, inst->varMapN, inst->label,inst->label_sfx_id,vid,chIdx);
 
       idxRef = idx;
   
       return kOkRC;
     }
 
-    rc_t  _var_map_label_to_index(  instance_t* inst, const char* var_label, unsigned chIdx, unsigned& idxRef )
+    rc_t  _var_map_label_to_index(  instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, unsigned& idxRef )
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
   
       idxRef = kInvalidIdx;
-      if((rc = var_find(inst, var_label, chIdx, var )) == kOkRC)
+      if((rc = var_find(inst, var_label, sfx_id, chIdx, var )) == kOkRC)
         rc = _var_map_id_to_index( inst, var->vid, chIdx, idxRef );
      
       return rc;
@@ -787,9 +787,9 @@ namespace cw
       if( new_var->chIdx == kAnyChIdx )
         return kOkRC;
       
-      if((base_var = _var_find_on_label_and_ch( inst, new_var->label, kAnyChIdx )) == nullptr )
+      if((base_var = _var_find_on_label_and_ch( inst, new_var->label, new_var->label_sfx_id, kAnyChIdx )) == nullptr )
       {
-        rc = cwLogError(kInvalidStateRC,"The base channel variable does not exist for '%s.%s'. This is an illegal state.", inst->label, new_var->label );
+        rc = cwLogError(kInvalidStateRC,"The base channel variable does not exist for '%s:%i.%s:%i'. This is an illegal state.", inst->label, inst->label_sfx_id, new_var->label, new_var->label_sfx_id );
         goto errLabel;
       }
 
@@ -815,7 +815,7 @@ namespace cw
 
     // Create a variable and set it's value from 'value_cfg'.
     // If 'value_cfg' is null then use the value from var->varDesc->val_cfg.
-    rc_t _var_create( instance_t* inst, const char* var_label, unsigned id, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
+    rc_t _var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
@@ -824,28 +824,29 @@ namespace cw
       varRef = nullptr;
 
       // if this var already exists - it can't be created again
-      if((var = _var_find_on_label_and_ch(inst,var_label,chIdx)) != nullptr )
+      if((var = _var_find_on_label_and_ch(inst,var_label, sfx_id, chIdx)) != nullptr )
       {
-        rc = cwLogError(kInvalidStateRC,"The variable '%s' ch:%i has already been created on the instance: '%s'.",var_label,chIdx,inst->label);
+        rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' ch:%i has already been created on the instance: '%s:%i'.",var_label,sfx_id,chIdx,inst->label,inst->label_sfx_id);
         goto errLabel;
       }
 
       // locate the var desc
       if((vd = var_desc_find( inst->class_desc, var_label)) == nullptr )
       {
-        rc = cwLogError(kInvalidIdRC,"Unable to locate the variable '%s' in class '%s'.", var_label, inst->class_desc->label );
+        rc = cwLogError(kInvalidIdRC,"Unable to locate the variable '%s:%i' in class '%s'.", var_label, sfx_id, inst->class_desc->label );
         goto errLabel;
       }
 
       // create the var
       var = mem::allocZ<variable_t>();
 
-      var->varDesc = vd;
-      var->inst    = inst;
-      var->label   = mem::duplStr(var_label);
-      var->vid     = id;
-      var->chIdx   = chIdx;
-      var->value   = nullptr;
+      var->varDesc      = vd;
+      var->inst         = inst;
+      var->label        = mem::duplStr(var_label);
+      var->label_sfx_id = sfx_id;
+      var->vid          = id;
+      var->chIdx        = chIdx;
+      var->value        = nullptr;
 
       // if no value was given then set the value to the value given in the class
       if( value_cfg == nullptr )
@@ -868,12 +869,12 @@ namespace cw
       if( rc != kOkRC )
       {
         _var_destroy(var);
-        cwLogError(kOpFailRC,"Variable creation failed on '%s.%s' ch:%i.", inst->label, var_label, chIdx );
+        cwLogError(kOpFailRC,"Variable creation failed on '%s:%i.%s:%i' ch:%i.", inst->label, inst->label_sfx_id, var_label, sfx_id, chIdx );
       }
       else
       {
         varRef = var;
-        cwLogMod("Created var: %s.%s ch:%i.", inst->label, var_label, chIdx );
+        cwLogMod("Created var: %s:%i.%s:%i ch:%i.", inst->label, inst->label_sfx_id, var_label, sfx_id, chIdx );
       }
       
       return rc;
@@ -883,31 +884,34 @@ namespace cw
     {
       const char* conn_label  = is_connected_to_external_proc(var) ? "extern" : "      ";
     
-      printf("  %20s id:%4i ch:%3i : %s  : ", var->label, var->vid, var->chIdx, conn_label );
+      printf("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
     
       if( var->value == nullptr )
         _value_print( &var->local_value[0] );
       else
         _value_print( var->value );
 
+      if( var->src_var != nullptr )
+        printf(" src:%s:%i.%s:%i",var->src_var->inst->label,var->src_var->inst->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
+
       printf("\n");    
     }
     
     
-    rc_t _preset_set_var_value( instance_t* inst, const char* var_label, unsigned chIdx, const object_t* value )
+    rc_t _preset_set_var_value( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value )
     {
       rc_t rc = kOkRC;
       variable_t* var = nullptr;
 
       // get the variable
-      if((rc = var_find( inst, var_label, chIdx, var )) != kOkRC )
+      if((rc = var_find( inst, var_label, sfx_id, chIdx, var )) != kOkRC )
         goto errLabel;
         
       rc = _set_var_value_from_cfg( var, value );
       
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(rc,"The value of instance:%s variable:%s could not be set via a preset.", inst->label, var_label );
+        rc = cwLogError(rc,"The value of instance:%s:%i variable:%s:%i could not be set via a preset.", inst->label, inst->label_sfx_id, var_label, sfx_id );
 
       return rc;
     }
@@ -1136,37 +1140,52 @@ void cw::flow::class_dict_print( flow_t* p )
         
     for(; vd!=nullptr; vd=vd->link)
     {
-      const char* srcFlStr    = vd->flags & kSrcVarFl    ? "src"    : "   ";
-      const char* srcOptFlStr = vd->flags & kSrcOptVarFl ? "srcOpt" : "      ";
+      const char* srcFlStr    = vd->flags & kSrcVarFl    ? "src"      : "   ";
+      const char* srcOptFlStr = vd->flags & kSrcOptVarFl ? "srcOpt"   : "      ";
+      const char* plyMltFlStr = vd->flags & kMultVarFl   ? "mult"     : "    ";
           
-      printf("  %10s 0x%08x %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, cwStringNullGuard(vd->docText) );
+      printf("  %10s 0x%08x %s %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, plyMltFlStr, cwStringNullGuard(vd->docText) );
     }
   }
 }
 
-void cw::flow::network_print( flow_t* p )
+
+void cw::flow::network_print( const network_t& net )
 {
-  for(instance_t* inst = p->network_head; inst!=nullptr; inst=inst->link)
+  // for each instance in the network
+  for(unsigned i=0; i<net.proc_arrayN; ++i)
+  {
+    instance_t* inst = net.proc_array[i];
     instance_print(inst);
+
+    // if this instance has an  internal network
+    if( inst->internal_net != nullptr )
+    {
+      printf("------- Begin Nested Network: %s -------\n",cwStringNullGuard(inst->label));
+      network_print(*(inst->internal_net));
+      printf("------- End Nested Network: %s -------\n",cwStringNullGuard(inst->label));
+    }
+        
+  }
 }
 
-cw::flow::instance_t* cw::flow::instance_find( flow_t* p, const char* inst_label )
+cw::flow::instance_t* cw::flow::instance_find( network_t& net, const char* inst_label, unsigned sfx_id )
 {
-  for(instance_t* inst = p->network_head; inst!=nullptr; inst=inst->link )
-    if( textCompare(inst_label,inst->label) == 0 )
-      return inst;
+  for(unsigned i=0; i<net.proc_arrayN; ++i)
+    if( net.proc_array[i]->label_sfx_id==sfx_id && textIsEqual(inst_label,net.proc_array[i]->label) )
+      return net.proc_array[i];
 
   return nullptr;
 }
 
-cw::rc_t cw::flow::instance_find( flow_t* p, const char* inst_label, instance_t*& instPtrRef )
+cw::rc_t cw::flow::instance_find( network_t& net, const char* inst_label, unsigned sfx_id, instance_t*& instPtrRef )
 {
   rc_t rc = kOkRC;
       
-  if((instPtrRef = instance_find(p,inst_label)) != nullptr )
+  if((instPtrRef = instance_find(net,inst_label,sfx_id)) != nullptr )
     return rc;
       
-  return cwLogError(kInvalidArgRC,"The instance '%s' was not found.", inst_label );
+  return cwLogError(kInvalidArgRC,"The instance '%s:%i' was not found.", inst_label, sfx_id );
 }
 
 cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel )
@@ -1185,7 +1204,7 @@ cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const ch
 
 void cw::flow::instance_print( instance_t* inst )
 {
-  printf("%s\n", inst->label);
+  printf("%s:%i\n", inst->label,inst->label_sfx_id);
   for(variable_t* var = inst->varL; var!=nullptr; var=var->var_link)
     if( var->chIdx == kAnyChIdx )
       for(variable_t* v0 = var; v0!=nullptr; v0=v0->ch_link)
@@ -1209,31 +1228,31 @@ void cw::flow::_var_destroy( variable_t* var )
 }
 
 
-cw::rc_t cw::flow::var_create( instance_t* inst, const char* var_label, unsigned id, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
+cw::rc_t cw::flow::var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
 {
   rc_t rc = kOkRC;
  
-  rc = _var_create( inst, var_label, id, chIdx, value_cfg, varRef );
+  rc = _var_create( inst, var_label, sfx_id, id, chIdx, value_cfg, varRef );
 
   return rc;
 }
 
-cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef )
+cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   variable_t* base_var = nullptr;
   varRef = nullptr;
 
-  if((base_var = _var_find_on_label_and_ch( inst, var_label, kAnyChIdx)) == nullptr)
+  if((base_var = _var_find_on_label_and_ch( inst, var_label, sfx_id, kAnyChIdx)) == nullptr)
   {
-    rc = cwLogError(kInvalidStateRC,"The base ('any') channel variable could not be located on '%s.%s'.",inst->label,var_label);
+    rc = cwLogError(kInvalidStateRC,"The base ('any') channel variable could not be located on '%s:%i.%s:%i'.",inst->label,inst->label_sfx_id,var_label,sfx_id);
     goto errLabel;
   }
 
   
   // locate the variable with the stated chIdx
-  var = _var_find_on_label_and_ch( inst, var_label, chIdx );
+  var = _var_find_on_label_and_ch( inst, var_label, sfx_id, chIdx );
   
 
   // 'src' variables cannot be channelized
@@ -1247,7 +1266,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   if( var == nullptr && chIdx != kAnyChIdx )
   {
     // create the channelized var
-    if((rc = _var_create( inst, var_label, vid, chIdx, value_cfg, var )) != kOkRC )
+    if((rc = _var_create( inst, var_label, sfx_id, vid, chIdx, value_cfg, var )) != kOkRC )
       goto errLabel;
 
     // if no value was set then set the value from the 'any' channel
@@ -1272,7 +1291,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
     }
     else
     {
-      cwLogWarning("An existing var (%s.%s ch:%i) was specified for channelizing but no value was provided.", inst->label, var_label, chIdx );
+      cwLogWarning("An existing var (%s:i.%s:i ch:%i) was specified for channelizing but no value was provided.", inst->label, inst->label_sfx_id, var_label, sfx_id, chIdx );
     }
   }
 
@@ -1281,20 +1300,20 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Channelize failed for variable '%s' on instance '%s' ch:%i.", var_label, inst->label, chIdx );
+    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on instance '%s:i' ch:%i.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx );
   
   return rc;
 }
 
-bool cw::flow::var_exists( instance_t* inst, const char* label, unsigned chIdx )
-{ return _var_find_on_label_and_ch(inst,label,chIdx) != nullptr; }
+bool cw::flow::var_exists( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
+{ return _var_find_on_label_and_ch(inst,label,sfx_id,chIdx) != nullptr; }
 
-bool cw::flow::var_has_value( instance_t* inst, const char* label, unsigned chIdx )
+bool cw::flow::var_has_value( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
 {
   variable_t* varPtr = nullptr;
   rc_t rc;
   
-  if((rc = var_find( inst, label, chIdx, varPtr )) != kOkRC )
+  if((rc = var_find( inst, label, sfx_id, chIdx, varPtr )) != kOkRC )
     return false;
 
   return varPtr->value != nullptr;
@@ -1322,7 +1341,7 @@ cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, var
       var = inst->varMapA[idx];
     else
     {
-      rc = cwLogError(kInvalidIdRC,"The index of variable vid:%i chIdx:%i on instance '%s' could not be calculated and the variable value could not be retrieved.", vid, chIdx, inst->label);
+      rc = cwLogError(kInvalidIdRC,"The index of variable vid:%i chIdx:%i on instance '%s:%i' could not be calculated and the variable value could not be retrieved.", vid, chIdx, inst->label,inst->label_sfx_id);
       goto errLabel;
     }
   }
@@ -1338,34 +1357,35 @@ cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, var
 
 
 
-cw::rc_t cw::flow::var_find( instance_t* inst, const char* label, unsigned chIdx, variable_t*& vRef )
+cw::rc_t cw::flow::var_find( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx, variable_t*& vRef )
 {
   variable_t* var;
   vRef = nullptr;
   
-  if((var = _var_find_on_label_and_ch(inst,label,chIdx)) != nullptr )
+  if((var = _var_find_on_label_and_ch(inst,label,sfx_id,chIdx)) != nullptr )
   {
     vRef = var;
     return kOkRC;
   }
 
-  return cwLogError(kInvalidIdRC,"The instance '%s' does not have a variable named '%s'.", inst->label, label );  
+  return cwLogError(kInvalidIdRC,"The instance '%s:%i' does not have a variable named '%s:%i'.", inst->label, inst->label_sfx_id, label, sfx_id );  
 }
 
-cw::rc_t cw::flow::var_find( instance_t* inst, const char* label, unsigned chIdx, const variable_t*& vRef )
+cw::rc_t cw::flow::var_find( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx, const variable_t*& vRef )
 {
   variable_t* v = nullptr;
-  rc_t        rc = var_find(inst,label,chIdx,v);
+  rc_t        rc = var_find(inst,label,sfx_id,chIdx,v);
   vRef = v;
   return rc;
 }
 
-cw::rc_t  cw::flow::var_channel_count( instance_t* inst, const char* label, unsigned& chCntRef )
+
+cw::rc_t  cw::flow::var_channel_count( instance_t* inst, const char* label, unsigned sfx_id, unsigned& chCntRef )
 {
   rc_t rc = kOkRC;
   const variable_t* var= nullptr;
-  if((rc = var_find(inst,label,kAnyChIdx,var)) != kOkRC )
-    return cwLogError(rc,"Channel count was not available because the variable '%s.%s' does not exist.",cwStringNullGuard(inst->label),cwStringNullGuard(label));
+  if((rc = var_find(inst,label,sfx_id,kAnyChIdx,var)) != kOkRC )
+    return cwLogError(rc,"Channel count was not available because the variable '%s:%i.%s:%i' does not exist.",cwStringNullGuard(inst->label),inst->label_sfx_id,cwStringNullGuard(label),sfx_id);
 
   return var_channel_count(var,chCntRef);
 }
@@ -1377,9 +1397,9 @@ cw::rc_t  cw::flow::var_channel_count( const variable_t* var, unsigned& chCntRef
   
   chCntRef = 0;
   
-  if((rc = var_find( var->inst, var->label, kAnyChIdx, v )) != kOkRC )
+  if((rc = var_find( var->inst, var->label, var->label_sfx_id, kAnyChIdx, v )) != kOkRC )
   {
-    rc = cwLogError(kInvalidStateRC,"The base channel variable instance could not be found for the variable '%s.%s'.",var->inst->label,var->label);
+    rc = cwLogError(kInvalidStateRC,"The base channel variable instance could not be found for the variable '%s:%i.%s:%i'.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id);
     goto errLabel;
   }
 
@@ -1392,7 +1412,7 @@ cw::rc_t  cw::flow::var_channel_count( const variable_t* var, unsigned& chCntRef
 
 
 
-cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
+cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsigned sfx_id,  unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
@@ -1403,7 +1423,7 @@ cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsign
   // The concatenation of 'vid' and 'chIdx' should be unique 
 
   // if an exact match to label/chIdx was found
-  if((var = _var_find_on_label_and_ch(inst,var_label,chIdx)) != nullptr )
+  if((var = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx)) != nullptr )
   {
     // if a value was given - then update the value
     if( value_cfg != nullptr )
@@ -1412,74 +1432,74 @@ cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsign
   }
   else // an exact match was not found - channelize the variable
   {
-    if((rc = var_channelize(inst,var_label,chIdx,value_cfg,vid,var)) != kOkRC )
+    if((rc = var_channelize(inst,var_label,sfx_id,chIdx,value_cfg,vid,var)) != kOkRC )
       goto errLabel;
   }
 
   var->vid = vid;
   varRef   = var;
 
-  if((var = _var_find_on_label_and_ch(inst,var_label,kAnyChIdx)) != nullptr )
+  if((var = _var_find_on_label_and_ch(inst,var_label,sfx_id,kAnyChIdx)) != nullptr )
     var->vid = vid;
   else
-    rc = cwLogError(kInvalidStateRC,"The variable '%s' instance '%s' has no base channel.", var_label, inst->label, chIdx);
+    rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' instance '%s:%i' has no base channel.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx);
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Registration failed on variable '%s' instance '%s' ch: %i.", var_label, inst->label, chIdx);
+    rc = cwLogError(rc,"Registration failed on variable '%s:%i' instance '%s:%i' ch: %i.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx);
   
   return rc;
 }
 
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, variable_t*& varRef )
+cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, variable_t*& varRef )
 {
-  return var_register( inst, var_label, vid, chIdx, nullptr, varRef );
+  return var_register( inst, var_label, sfx_id, vid, chIdx, nullptr, varRef );
 }
 
-cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN )
+cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN )
 {
   rc_t rc = kOkRC;
   abuf_t* abuf;
   
   if((abuf = abuf_create( srate, chN, frameN )) == nullptr )
-    return cwLogError(kOpFailRC,"abuf create failed on instance:'%s' variable:'%s'.", inst->label, var_label);
+    return cwLogError(kOpFailRC,"abuf create failed on instance:'%s:%i' variable:'%s:%i'.", inst->label, inst->label_sfx_id, var_label,sfx_id);
 
-  if((rc = _var_register_and_set( inst, var_label, vid, chIdx, abuf )) != kOkRC )
+  if((rc = _var_register_and_set( inst, var_label, sfx_id, vid, chIdx, abuf )) != kOkRC )
     abuf_destroy(abuf);
 
   return rc;
 }
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
+cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
 {
   rc_t rc = kOkRC;
   fbuf_t* fbuf;
   if((fbuf = fbuf_create( srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV )) == nullptr )
-    return cwLogError(kOpFailRC,"fbuf create failed on instance:'%s' variable:'%s'.", inst->label, var_label);
+    return cwLogError(kOpFailRC,"fbuf create failed on instance:'%s:%i' variable:'%s:%i'.", inst->label, inst->label_sfx_id, var_label,sfx_id);
 
-  if((rc = _var_register_and_set( inst, var_label, vid, chIdx, fbuf )) != kOkRC )
+  if((rc = _var_register_and_set( inst, var_label, sfx_id, vid, chIdx, fbuf )) != kOkRC )
     fbuf_destroy(fbuf);
 
   return rc;
 }
 
-cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, midi::ch_msg_t* msgA, unsigned msgN  )
+cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* msgA, unsigned msgN  )
 {
   rc_t rc = kOkRC;
   mbuf_t* mbuf;
   
   if((mbuf = mbuf_create(msgA,msgN)) == nullptr )
-    return cwLogError(kOpFailRC,"mbuf create failed on instance:'%s' variable:'%s'.", inst->label, var_label);
+    return cwLogError(kOpFailRC,"mbuf create failed on instance:'%s:%i' variable:'%s:%i'.", inst->label, inst->label_sfx_id, var_label, sfx_id);
 
-  if((rc = _var_register_and_set( inst, var_label, vid, chIdx, mbuf )) != kOkRC )
+  if((rc = _var_register_and_set( inst, var_label, sfx_id, vid, chIdx, mbuf )) != kOkRC )
     mbuf_destroy(mbuf);
 
   return rc;
 }
 
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
+cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
 {
   unsigned maxBinN_V[ chN ];
   unsigned binN_V[ chN ];
@@ -1487,7 +1507,7 @@ cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label
   vop::fill(maxBinN_V,chN,maxBinN);
   vop::fill(binN_V,chN,binN);
   vop::fill(hopSmpN_V,chN, hopSmpN );
-  return var_register_and_set(inst,var_label,vid,chIdx,srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV);
+  return var_register_and_set(inst,var_label,sfx_id,vid,chIdx,srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV);
 }
 
 
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 0fe4ce5..e111842 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -15,6 +15,7 @@ namespace cw
     typedef unsigned vid_t;
 
     enum {
+      kBaseSfxId = 0,
       kFbufVectN = 3,  // count of signal vectors in fbuf (mag,phs,hz)
       kAnyChIdx = kInvalidIdx,
       kLocalValueN = 2
@@ -127,8 +128,10 @@ namespace cw
     
     enum
     {
+      kNoVarFl     = 0x00,
       kSrcVarFl    = 0x01,
-      kSrcOptVarFl = 0x02 
+      kSrcOptVarFl = 0x02,
+      kMultVarFl   = 0x04
     };
     
     typedef struct class_members_str
@@ -165,6 +168,7 @@ namespace cw
       var_desc_t*       varDescL;  // varDescA[varDescN] value description list
       preset_t*         presetL;   // presetA[ presetN ]
       class_members_t*  members;   // member functions for this class
+      unsigned          polyLimitN; // max. poly copies of this class per network_t or 0 if no limit
     } class_desc_t;
 
 
@@ -174,6 +178,7 @@ namespace cw
     {
       struct instance_str* inst;         // pointer to this variables instance
       char*                label;        // this variables label
+      unsigned             label_sfx_id; // the label suffix id of this variable or kInvalidIdx if this has no suffix
       unsigned             vid;          // this variables numeric id ( cat(vid,chIdx) forms a unique variable identifier on this 'inst'
       var_desc_t*          varDesc;      // the variable description for this variable
       value_t              local_value[ kLocalValueN ];  // the local value instance (actual value if this is not a 'src' variable)
@@ -187,15 +192,33 @@ namespace cw
     } variable_t;
 
     
+    struct instance_str;
+
+    typedef struct network_str
+    {
+      const object_t*      procsCfg;       // network proc list
+      const object_t*      presetsCfg;     // presets designed for this network
+
+      unsigned poly_cnt; // count of duplicated networks in the list
+
+      struct instance_str** proc_array;
+      unsigned              proc_arrayAllocN;
+      unsigned              proc_arrayN;
+      
+    } network_t;
+    
     typedef struct instance_str
     {
       struct flow_str* ctx;          // global system context
+      network_t*       net;          // network which owns this proc
 
       class_desc_t*   class_desc;    //
       
-      const char*     label;         // instance label
-      const object_t* inst_cfg;      // instance configuration
+      char*           label;         // instance label
+      unsigned        label_sfx_id;  // label suffix id (set to kBaseSfxId (0) unless poly is non-null)
       
+      const object_t* proc_cfg;      // instance configuration
+            
       const char*     arg_label;     // optional args label
       const object_t* arg_cfg;       // optional args configuration
 
@@ -207,17 +230,16 @@ namespace cw
       unsigned        varMapIdN;     // max 'vid' among all variables on this instance 
       unsigned        varMapN;       // varMapN = varMapIdN * varMapChN 
       variable_t**    varMapA;       // varMapA[ varMapN ] = allows fast lookup from ('vid','chIdx) to variable
+
+      network_t*  internal_net;
       
-      struct instance_str* link;
     } instance_t;
 
-    
 
     typedef struct flow_str
     {
-      const object_t*      networkCfg;     // complete cfg used to create this network
+      const object_t*      flowCfg;     // complete cfg used to create this flow 
 
-      const object_t*      presetCfg;      // presets designed for this network
       
       unsigned             framesPerCycle;  // sample frames per cycle (64)
       bool                 multiPriPresetProbFl; // If set then probability is used to choose presets on multi-preset application
@@ -232,8 +254,8 @@ namespace cw
       external_device_t*   deviceA;        // deviceA[ deviceN ] external device description array
       unsigned             deviceN;        //
       
-      struct instance_str* network_head; // first instance
-      struct instance_str* network_tail; // last insance      
+      network_t net;
+
     } flow_t;
 
     //------------------------------------------------------------------------------------------------------------------------
@@ -278,15 +300,16 @@ namespace cw
     //
     // Network
     //
-    void           network_print(    flow_t* p );
+    void           network_print(const network_t& net );
 
     //------------------------------------------------------------------------------------------------------------------------
     //
     // Instance
     //
     
-    instance_t*        instance_find( flow_t* p, const char* inst_label );
-    rc_t               instance_find( flow_t* p, const char* inst_label, instance_t*& instPtrRef );
+    instance_t*        instance_find( network_t& net, const char* inst_label, unsigned sfx_id );
+    rc_t               instance_find( network_t& net, const char* inst_label, unsigned sfx_id, instance_t*& instPtrRef );
+    
     external_device_t* external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel=nullptr );
 
     void               instance_print( instance_t* inst );
@@ -300,14 +323,14 @@ namespace cw
 
     // Create a variable but do not assign it a value.  Return a pointer to the new variable.
     // Note: `value_cfg` is optional. Set it to NULL to ignore
-    rc_t           var_create( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
+    rc_t           var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
     // Channelizing creates a new var record with an explicit channel index to replace the
     // automatically generated variable whose channel index is set to  'all'.
-    rc_t           var_channelize( instance_t* inst, const char* var_label, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
+    rc_t           var_channelize( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
 
     // `value_cfg` is optional. Set it to NULL to ignore
-    rc_t           var_register( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
+    rc_t           var_register( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
     // Returns true if this var is connected to an external proc variable
     bool           is_connected_to_external_proc( const variable_t* var );
@@ -320,11 +343,11 @@ namespace cw
     inline rc_t _var_reg(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
     
     template< typename T0, typename T1,  typename... ARGS >
-    rc_t _var_reg( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, ARGS&&... args )
+    rc_t _var_reg( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, ARGS&&... args )
     {
       rc_t rc;
       variable_t* dummy = nullptr;
-      if((rc = var_register( inst, var_label, vid, chIdx, nullptr, dummy )) == kOkRC )        
+      if((rc = var_register( inst, var_label, sfx_id, vid, chIdx, nullptr, dummy )) == kOkRC )        
         if((rc = _var_reg( inst, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
           return rc;
       return rc;
@@ -332,8 +355,8 @@ namespace cw
 
     // Call var_register() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, ARGS&&... args )
-    {  return _var_reg( inst, chIdx, vid, var_label, std::forward<ARGS>(args)...); }
+    rc_t           var_register( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
+    {  return _var_reg( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
 
@@ -345,11 +368,11 @@ namespace cw
     inline rc_t _var_register_and_get(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
 
     template< typename T>
-    rc_t var_register_and_get( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, T& valRef )
+    rc_t var_register_and_get( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, T& valRef )
     {
       rc_t rc;
       variable_t* var;
-      if((rc = var_register(inst,var_label,vid,chIdx,nullptr,var)) == kOkRC )
+      if((rc = var_register(inst,var_label,sfx_id,vid,chIdx,nullptr,var)) == kOkRC )
         rc = var_get(var,valRef);
       return rc;
     }
@@ -358,11 +381,11 @@ namespace cw
     inline rc_t _var_reg_and_get(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
 
     template< typename T0, typename T1, typename T2, typename... ARGS >
-    rc_t _var_reg_and_get( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, T2& valRef, ARGS&&... args )
+    rc_t _var_reg_and_get( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2& valRef, ARGS&&... args )
     {
       rc_t rc;
 
-      if((rc = var_register_and_get( inst, var_label, vid, chIdx, valRef )) == kOkRC )        
+      if((rc = var_register_and_get( inst, var_label, sfx_id, vid, chIdx, valRef )) == kOkRC )        
         if((rc = _var_reg_and_get( inst, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
           return rc;
       
@@ -371,8 +394,8 @@ namespace cw
 
     // Call var_register_and_get() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register_and_get( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, ARGS&&... args )
-    {  return _var_reg_and_get( inst, chIdx, vid, var_label, std::forward<ARGS>(args)...); }
+    rc_t           var_register_and_get( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id,  ARGS&&... args )
+    {  return _var_reg_and_get( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
     
@@ -384,22 +407,22 @@ namespace cw
     // var_register_and_set().  If the variable has not yet been created then it is created and assigned a value.
     // If the variable has already been created then 'vid' and the value are updated.
     // (Note that abuf and fbuf values are not changed by this function only the 'vid' is updated.)
-    rc_t           var_register_and_set( instance_t* inst, const char* label,     unsigned vid, unsigned chIdx, variable_t*& varRef );
+    rc_t           var_register_and_set( instance_t* inst, const char* label,  unsigned sfx_id,   unsigned vid, unsigned chIdx, variable_t*& varRef );
     
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
 
     inline rc_t _var_register_and_set(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
 
     template< typename T0, typename T1, typename T2, typename... ARGS >
-    rc_t _var_register_and_set( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, T2 val, ARGS&&... args )
+    rc_t _var_register_and_set( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2 val, ARGS&&... args )
     {
       rc_t rc;
 
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, vid, chIdx, var)) == kOkRC )
+      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) == kOkRC )
       {
         var_set( inst, vid, chIdx, val );
         
@@ -412,22 +435,23 @@ namespace cw
 
     // Call var_register_and_set() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register_and_set( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, ARGS&&... args )
-    {  return _var_register_and_set( inst, chIdx, vid, var_label, std::forward<ARGS>(args)...); }
+    rc_t           var_register_and_set( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
+    {  return _var_register_and_set( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
 
     void           _var_destroy( variable_t* var );
 
-    bool           var_exists( instance_t* inst, const char* label, unsigned chIdx );
-    bool           var_has_value( instance_t* inst, const char* label, unsigned chIdx );
+    bool           var_exists(    instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_has_value( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
 
-    rc_t           var_find( instance_t* inst, const char* var_label, unsigned chIdx, const variable_t*& varRef );
-    rc_t           var_find( instance_t* inst, const char* var_label, unsigned chIdx,       variable_t*& varRef );
-    rc_t           var_find( instance_t* inst, unsigned vid,          unsigned chIdx,       variable_t*& varRef );
+    rc_t           var_find(   instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const variable_t*& varRef );
+    rc_t           var_find(   instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx,       variable_t*& varRef );
+    rc_t           var_find(   instance_t* inst, unsigned vid,                           unsigned chIdx,       variable_t*& varRef );
 
+    
     // Count of numbered channels - does not count the kAnyChIdx variable instance.
-    rc_t           var_channel_count( instance_t* inst, const char* label, unsigned& chCntRef );
+    rc_t           var_channel_count( instance_t* inst, const char* label, unsigned sfx_idx, unsigned& chCntRef );
     rc_t           var_channel_count( const variable_t* var, unsigned& chCntRef );
     
     
diff --git a/cwPresetSel.cpp b/cwPresetSel.cpp
index 0f3a420..2e07769 100644
--- a/cwPresetSel.cpp
+++ b/cwPresetSel.cpp
@@ -6,11 +6,12 @@
 #include "cwObject.h"
 #include "cwTime.h"
 #include "cwVectOps.h"
+#include "cwMidi.h"
+#include "cwMidiDecls.h"
 #include "cwFlowDecl.h"
 #include "cwPresetSel.h"
 #include "cwFile.h"
 
-#include "cwMidi.h"
 #include "cwDynRefTbl.h"
 #include "cwScoreParse.h"
 #include "cwSfScore.h"

From 78ca1b3e357e3584468940d6d395c840c441b211 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 22 Apr 2024 16:02:53 -0400
Subject: [PATCH 024/101] README.md : Updates

---
 README.md | 381 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 366 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 2a8f27c..4a0dae4 100644
--- a/README.md
+++ b/README.md
@@ -432,7 +432,7 @@ struct in_addr {
 
     export LD_LIBRARY_PATH=~/sdk/libwebsockets/build/out/lib
 
-*** Raspberry Pi Build Notes:
+### Raspberry Pi Build Notes:
 
     cd sdk
     mkdir libwebsockets
@@ -444,10 +444,10 @@ struct in_addr {
 
 
     
-*** Flow Notes:
+### Flow Notes:
 
 
-- When a variable has a variant with a numberic channel should the 'all' channel variant be removed?
+- When a variable has a variant with a numeric channel should the 'all' channel variant be removed?
 
 - Check for duplicate 'vid'-'chIdx' pairs in var_regster().
   (The concatenation of 'vid' and 'chIdx' should be unique 
@@ -469,16 +469,21 @@ specific types, to pass through. For example a 'selector' (n inputs, 1 output) o
 
 DONE:  Add a version of var_register() that both registers and returns the value of the variable.
 
-*** Flow Instance Creation:
+### Flow Instance Creation:
 
-1. Create all vars from the class description and initially set their
-value to the default value given in the class.  chIdx=kAnyChIdx.
+0. Parse the 'in' list and create any 'mult' variables whose 
+'in-var' contains an integer or underscore suffix. See
+"'in' List Syntax and Semantics" below.
+
+1. Create all vars from the class description, that were not
+already instantiated during 'in' list processing, and set their
+initial value to the default value given in the class.  chIdx=kAnyChIdx.
 
 Note that all vars must be included in the class description.
 
 
-2. Apply the preset record from the class description according to the
-label given in the instance definition. 
+2. Apply the preset records from the class description according to the
+'presets' list given in the instance definition. 
 
 If the variable values are given as a scalar then the existing
 variable is simply given a new value.
@@ -489,17 +494,23 @@ index of the value in the list. This is referred
 to as 'channelizing' the variable because the variable will then
 be represented by multiple physical variable records - one for each channel.
 This means that all variables will have their initial record, with the chIdx set to 'any',
-and then they may also have further variable records will for each explicit
+and then they may also have further variable records for each explicit
 channel number. The complete list of channelized variable record 
 is kept, in channel order, using the 'ch_link' links with the base of the list
 on the 'any' record.
 
-3. Apply the variable values defined in the instance 'args' record.
-This application is treated similarly to the 'class' 
-preset. If the variable value is presented in a list then
-the value is assigned to a specific channel if the channel
-already exists then the value is simply replaced, if the
-channel does not exist then the variable is 'channelized'.
+3. Apply the variable values defined in a instance 'args' record.
+The 'args' record may have multiple sets of args. 
+If the preset instance includes an 'argsLabel' value then this record
+is selected to be applied.  If No 'argsLabel' is given then
+the record named 'default' is selected.  If there is no record
+named 'default' then no record is applied.
+
+The application of the args record proceeds exactly the same as
+applying a 'class' preset. If the variable value is presented in a
+list then the value is assigned to a specific channel. If the channel
+already exists then the value is simply replaced. If the channel does
+not exist then the variable is 'channelized'.
 
 4. The varaibles listed in the 'in' list of the instance cfg.
 are connected to their source variables.
@@ -520,5 +531,345 @@ access to registered variables.
 
 
 
+# Notes on 'poly' and 'mult':
+
+The 'in' statement is formed by a list of _Connect Expressions_ :
+
+`<input_var>:<source_inst.source_var>`
+
+There are three forms of connect expressions:
+
+1. Simple Connect Expression: Both the input and source labels
+identify vars in the input and source instance.
+
+2. Manual Mult Connect Expression: The input identifer ends with an
+integer.  This expression indicates that an input var will be
+instantiated and connected to the source var.  The integer indicates
+the suffix (sfx) id of the input var. e.g. `in0:osc.out`,`in1:filt.out`.
+      
+3. PolyMult Connect Expression: The source identifier has an
+underscore suffix.  This form indicates that there will one instance of
+this var for each poly instance that the source var instances is
+contained by. e.g. `in:osc_.out` If `osc` is contained by an order 3
+poly then statement will create and connect three instances of `in` -
+`in0:osc0.out`,`in1:osc1.out` and `in2:osc2.out`.
+
+Notes:
+- For an input variable to be used in either of the 'Manual' or 'PolyMult' 
+forms the var class desc must have the 'mult' attribute.
+
+- If any var has an integer suffix then this is converted to it's sfx id.
+
+- If the input var of a poly mult expression has an integer suffix then this is taken to be the
+base sfx id for that poly connection.  Other connections in the same statement will be
+incremented from that base value.  e.g `in3:osc_.out` becomes
+`in3:osc0.out`,`in4:osc1.out` and `in5:osc2.out`.
+
+- The first and last poly source instance can be indicated by specifying a 
+begin poly index and count before and after the source index underscore:
+e.g. `in:osc3_3.out` becomes: `in0:osc3.out`,`in1:osc4.out` and `in2:osc5.out`.
+
+- A similar scheme can be used to indicate particular source instance vars:
+`in:osc.out1_2` becomes `in0:osc.out1`,`in1:osc.out2`
+
+- It is a compile time error to have more than one input variable with the same sfx id.
+
+'in' List Syntax and Semantics:
+===============================
+
+Syntax:
+-------
+The 'in' list has the follow syntax:
+`in: { in-stmt* }`
+`in-stmt`     -> `in-var-id`":" `src_expr`
+`src-expr`    -> `src-proc-id`"."`src-var-id`
+`in-var-id`   -> `var-id`
+`src-proc-id` -> `var-id`
+`src-var-id`  -> `var-id`
+`var-id`      -> `label` { `label-sfx` }
+`label-sfx`   -> { `pri-int`} {{"_"} `sec-int` }
+`pri-int`     -> int
+`sec-int`     -> int
+
+
+Semantics:
+----------
+
+### `in-var-id`
+
+- The `label` part of the `in-var-id`  must match to a 
+var description in the input proc class description.
+
+- If no `label-sfx` is given then no special action
+need by taken at var creation time. This var will be
+created by default and later connected to the source inst/var.
+
+
+- (0) If the "_" is given:
+    + This is an "iterating" in-stmt where multiple 
+	  input vars will be created and connected.
+	
+	+ If no `pri-int` is given  then the `pri-int` defaults to 0.
+	
+	+ If the `pri-int` is given then it indicates that 
+      an instance of this var should be created where
+      the `pri-int` becomes the sfx-id of the var instance.
+
+	+ If `sec-int` is given then it gives the 
+      count of input vars which will be created. The
+	  sfx-id of each new input var begins with `pri-int` 
+	  and increments for each new var.
+
+    + (1) If no `sec-int` is given then the `sec-int` is implied by the count
+	  of source variables indicated in the `src-expr`.
+
+
+- If no "_" is given:
+    + No `sec-int` can exist without a "_".
+	
+    + If a `pri-int` is given then a single
+	  input var is created and the `pri-int` 
+	  gives the sfx-id.  This single input
+	  var is then connected to a single src var.
+	  
+	+ If no `pri-int` is given
+	  then the default var is created
+	  with kBaseSfxId and is connected
+      to a single source var.
+
+
+### `src-proc-id`
+
+- The `label` part of the `src-proc-id` must match to a 
+previously created proc instance in the current network.
+
+- If a `label-sfx` is given then the `pri-int` gives
+the sfx-id of the first proc inst to connect to.
+If no `pri-int` is given then the first sfx-id 
+defaults to 0. 
+
+
+- If "_" is given:
+	+ This is an "iterating" src-proc and therefore
+	  the in-var must also be iterating. See (0)
+
+	+ If a `sec-int` is given then this gives the count of
+      connections across multiple proc instances with
+	  sfx-id's beginnign with `pri-int`.  Note that if
+	  `sec-int` is given then the `in-var-id` must be
+	  iterating and NOT specify an iteration count,
+	  as in (1) above.
+	  
+	+ If no `sec-int` is given then the 
+	  `sec-int` defaults to the count of
+	  available proc instances with the given `label` 
+	  following the source proc inst `pri-int`.
+
+
+
+- If "_" is not given then this is not an
+  iterating proc inst. 
+  
+    + If the input var is iterating
+      then it must specify the iteration count or
+	  the `src-var-id` must be iterating.
+	  
+	+ If the `pri-int` is given then it specifies
+	  the sfx-id of the src-proc
+	  
+	+ If the `pri-int` is not given 
+	
+	    - If the src-net is the same as the in-var net then
+	      the sfx-id of the in-var proc is used as the src-proc sfx-id
+
+
+### `src-var-id`
+
+- The `label` part of the `in-var-id`  must match to a 
+var description in the source proc class descriptions.
+
+- If a `label-sfx` is given then the `pri-int` gives
+the sfx-id of the first source var to connect to
+on the source proc instance. If no `pri-int` is
+given then the first sfx-id defaults to 0.
+
+- If a "_" is given:
+    + This is an "iterating"
+	  source var and therefore the input var
+	  must specifiy an iterating connection and
+	  the source proc inst must not specify an iterating 
+	  connection. See (0) above.
+
+	+ If a `sec-int` is given then this gives the count of
+      connections across multiple source vars with
+	  sfx-id's beginnign with `pri-int`.  Note that if
+	  `sec-int` is given then the `in-var-id` must be
+	  iterating and NOT specify an iteration count,
+	  as in (1) above.
+
+
+	+ If `sec-int` is given
+	  then the `sec-int` defaults to the count of
+	  available source vars with the given `label` 
+	  following the source var `pri-int`.
+
+- If "_" is not given then this is not an
+  iterating source var. If the input var is iterating
+  then it must specify the iteration count or
+  the `src-proc-id` must be iterating.
+
+
+### Notes:
+
+- If the `in-var-id` is iterating but neither `src-proc-id`
+or `src-var-id` are iterating then the `in-var-id` must
+specify the iteration count and the connection will be
+made to exactly one source var on the source proc inst.
+
+- If `in-var-id` is iterating then the iterations count
+must come from exactly one place:
+    + the input var `sec-int`
+	+ the source proc `sec-int`
+	+ the source var `sec-int`
+	
+This means that only one literal iter count can be 
+given per `in-stmt`.  It is a syntax error if
+more than one literal iter counts are given.
+
+- Use cases
+    + connect one input to one source
+	+ connect multiple inputs to the same var on multiple procs
+	+ connect multiple inputs to multiple vars on one proc
+	+ connect multiple inputs to one var on one proc
+
+Var Updates and Preset Application
+==================================
+
+Variable addresses are formed from the following parameters:
+`(<proc_label><proc_label_sfx_id>)*,var_label,var_label_sfx_id, ch_idx`
+
+In the cases of poly procs (procs with public internal networks) it
+may not always be possible to know the `<proc_label_sfx_id>` without
+asking for it at runtime.  For example for the cross-fader control the
+application must ask for the `<proc_label_sfx_id>` current or next
+poly channel depending on which one it is targetting.
+
+It is notable that any proc with an internal network has
+to solve this problem.  The problem is especially acute
+for proc's which change the 'current' poly channel at runtime.
+
+The alternative is to include the concept of special values 
+in the address (e.g. kInvalidIdx means the application isn't
+sure and the network should decide how to resolve the address)
+The problem with this is that the information
+to make that decision may require more information than
+just a simple 'special value' can encode. It also means
+complicating the var set/get pipeline with 'escape' routines.
+
+There are at least two known use cases which need to address 
+this issue:
+1. The cross-fader: The application may wish to address
+  updates to the current or next poly channel but this
+  channel can't be determined until runtime.
+
+- The application asks for the current or next `proc_label_sfx_id`
+  at runtime depending on what its interested in doing, 
+  and sets the update address accordingly.
+  
+  
+- Two interface objects are setup as sources for the `xfade_ctl` 
+  object.  The address of each of these objects can be 
+  determined prior to runtime. The application then simply addresses
+  the object corresponding to method (direct vs deferred) it requires.
+  This solution is particularly appealing because it means that
+  presets may be completely resolved to their potential 
+  target procs (there would be up to 'poly-count' potential targets)
+  prior to runtime.
+  
+  As it stands now the problem with this approach is that it
+  does not allow for the message to be resolved to its final
+  destination. If the message is addressed to a proxy proc
+  then that proxy must mimic all the vars on the object which
+  it is providing an interface for. (This is actually possible
+  and may be a viable solution???) 
+    
+  One solution to this is to create a data type which is an
+  address/value packet.  The packet would then be directed
+  to a router which would in turn use the value to forward
+  the packet to the next destination.  Each router that the
+  packet passed through would strip off a value and
+  pass along the message. This is sensible since the 'value'
+  associated with a router is in fact another address.
+  
+2. The polyphonic sampler: 
+
+- How can voices be addressed once they are started?
+  + A given note is started - how do we later address that note to turn it off?
+    Answer: MIDI pitch and channel - only one note may be sounding on a given MIDI pitch and channel at any one time.
+	
+    - Extending ths idea to the xfader: There are two channels: current and deferred,
+	but which are redirected to point to 2 of the 3  physical channels .... this would
+	require the idea of 'redirected' networks, i.e. networks whose proc lists were
+	really pointers to the physical procs.
+	  - sd_poly maintains the physical networks as it is currently implemnted.
+	  - xfade_ctl maintains the redirected networks - requests for proc/var addresses 
+	    on the redirected networks will naturally resolve to physical networks. 
+
+	  - Required modifications:
+	      + variable getters and setters must use a variable args scheme specify the var address:
+		    `(proc-name,proc-sfx-id)*, var-name,var-sfx-id`
+			Example: `xfad_ctl,0,pva,1,wnd_len,0,0`
+	            - The first 0 is known because there is only one `xfad_ctl`.
+				- The 1 indicates the 'deferred' channel.				
+				- The second 0 is known because there is only one `wnd_len` per `pva`.
+				- The third 0 indicates the channel index of the var.
+			
+		  + the address resolver must then recognize how to follow internal networks
+		      
+		  + Networks must be maintained as lists of pointers to procs
+		    rather than a linked list of physical pointers.
+			
+		  + `xfade_ctl` must be instantiated after `sd_poly` and be able
+			  to access the internal network built by `sd_poly`. 
+		  
+	
+Generalizing the Addressing
+---------------------------
+Change the set/get interface to include a list of (proc-label,proc-sfx-id) 
+to determine the address of the var. 
+
+Note that this still requires knowing the final address in advance.
+In general a router will not know how to resolve a msg to the 
+next destination without having a final address.
+In otherwords setting 'proc-sfx-id' to kInvalidId is not
+resolvable without more information.
+
+   
+
+
+### TODO:
+
+- Documentation w/ examples.
+
+- Compile presets: at load time the presets should be resolved
+  to the proc and vars to which they will be assigned.
+
+- flow classes and variable should have a consistent naming style: camelCase or snake_case.
+
+- Variable attributes should be meaningful. e.g. src,src_opt,mult,init, ....
+  Should we check for 'src' or 'mult' attribute on var's?
+
+- DONE: 'poly' should be implemented as a proc-inst with an internal network - but the 
+elements of the network should be visible outside of it.
+
+- 'sub' should be implemented as proc-inst with an internal network, but the
+elements of the network should not be visible outside of it. Instead it should
+include the idea of input and output ports which act as proxies to the physical
+ports of the internal elements.
+
+- 'poly' and 'sub' should be arbitrarily nestable. 
+
+
+- Reduce runtime over head for var get/set operations.
 
 

From e42dd71b09337f3d2436d1c5789d8e824a8d7b3a Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 16:58:01 -0400
Subject: [PATCH 025/101] cwLex.h/cpp : test() now returns an rc_t.  Added test
 for use of floating point suffix 'f'.

---
 cwLex.cpp | 20 +++++++++++---------
 cwLex.h   |  2 +-
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/cwLex.cpp b/cwLex.cpp
index 5eca99b..da73cc2 100644
--- a/cwLex.cpp
+++ b/cwLex.cpp
@@ -853,7 +853,7 @@ namespace cw
     //)
 
     //(
-    void test()
+    rc_t test()
     {
       rc_t     rc  = kOkRC;
       unsigned tid = kInvalidId;
@@ -866,14 +866,16 @@ namespace cw
         "/* block \n"
         "comment */"
         "\"quoted string\""
-        "ident1"
+        "ident1 "
+        "1234.56f"
+        "345u"
         "                       // last line comment";
 
       // initialize a lexer with a buffer of text
       if((rc = lex::create(h,buf,strlen(buf), kReturnSpaceLexFl | kReturnCommentsLexFl)) != kOkRC )
       {
-        cwLogError(rc,"Lexer initialization failed.");
-        return;
+        rc = cwLogError(rc,"Lexer initialization failed.");
+        goto errLabel;
       }
 
       // register some additional recoginizers
@@ -884,7 +886,7 @@ namespace cw
       while( (tid = lex::getNextToken(h)) != kEofLexTId )
       {
         // print information about each token
-        cwLogInfo("%i %i %s '%.*s' (%i) ", 
+        cwLogInfo("ln:%i col:%i tok:%s '%.*s' len:%i ", 
           lex::currentLineNumber(h), 
           lex::currentColumnNumber(h), 
           lex::idToLabel(h,tid), 
@@ -899,11 +901,9 @@ namespace cw
           int    iv = lex::tokenInt(h);
           double dv = lex::tokenDouble(h);
 
-          cwLogInfo("%i %f",iv,dv);
+          cwLogInfo("Number: int:%i dbl:%f unsigned:%i float:%i",iv,dv,tokenIsUnsigned(h),tokenIsSinglePrecision(h));
         }
 
-        cwLogInfo("\n");
-
         // handle errors
         if( tid == kErrorLexTId )
         {
@@ -912,10 +912,12 @@ namespace cw
         }
 
       }
-
+      
       // finalize the lexer 
       lex::destroy(h);
 
+    errLabel:
+      return rc;
     }
   }
 }
diff --git a/cwLex.h b/cwLex.h
index 2f25b77..c77aafd 100644
--- a/cwLex.h
+++ b/cwLex.h
@@ -129,7 +129,7 @@ namespace cw
     const char* idToLabel( handle_t h, unsigned typeId );
 
     // Lexer testing stub.
-    void test(  );
+    rc_t test(  );
   }
 }
 

From a7a38fa9f4862ed4b9efe240cf7b12ca369adcf3 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 16:59:40 -0400
Subject: [PATCH 026/101] cwObject.h/cpp : cwObject now detects and properly
 encodes floats and unsigned integers that are specified with the 'f' and 'u'
 suffix.

---
 cwObject.cpp       | 10 ++++++++--
 cwObjectTemplate.h |  6 ++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/cwObject.cpp b/cwObject.cpp
index 6fabd0b..60682f8 100644
--- a/cwObject.cpp
+++ b/cwObject.cpp
@@ -869,11 +869,17 @@ cw::rc_t cw::objectFromString( const char* s, object_t*& objRef )
         break;
         
       case lex::kRealLexTId:
-        _objCreateValueNode( cnp, lex::tokenDouble(lexH), "real" );
+        if( tokenIsSinglePrecision(lexH) )
+          _objCreateValueNode( cnp, lex::tokenFloat(lexH),"float" );
+         else
+          _objCreateValueNode( cnp, lex::tokenDouble(lexH), "double" );
         break;
         
       case lex::kIntLexTId:
-        _objCreateValueNode( cnp, lex::tokenInt(lexH), "int" );
+        if( tokenIsUnsigned(lexH) )
+          _objCreateValueNode( cnp, lex::tokenUInt(lexH), "uint" );
+        else
+          _objCreateValueNode( cnp, lex::tokenInt(lexH), "int" );
         break;
         
       case lex::kHexLexTId:
diff --git a/cwObjectTemplate.h b/cwObjectTemplate.h
index 81027b4..7fca3ec 100644
--- a/cwObjectTemplate.h
+++ b/cwObjectTemplate.h
@@ -74,6 +74,12 @@ namespace cw
     return obj;
   }
 
+  template<> object_t* _objSetLeafValue<float>( object_t* obj,  float value )
+  {
+    obj->u.f  = value;
+    obj->type = _objIdToType(kFloatTId);
+    return obj;
+  }
   
   template<> object_t* _objSetLeafValue<double>( object_t* obj,  double value )
   {

From a0b4e9c1205aa51d261183894eef9634c126a47d Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:00:58 -0400
Subject: [PATCH 027/101] cwDspTypes.h,cwDspTransforms.h/cpp : Removed the
 'real_t' and replaced it with more specific types which identify how the type
 is being used (e.g. coeff_t, ftime_t).

---
 cwDspTransforms.cpp | 32 ++++++++++-----------
 cwDspTransforms.h   | 68 ++++++++++++++++++++++-----------------------
 cwDspTypes.h        |  5 ++--
 3 files changed, 53 insertions(+), 52 deletions(-)

diff --git a/cwDspTransforms.cpp b/cwDspTransforms.cpp
index 801fea8..2195964 100644
--- a/cwDspTransforms.cpp
+++ b/cwDspTransforms.cpp
@@ -21,9 +21,9 @@ namespace cw
   {
     namespace compressor
     {
-      void _ms_to_samples( obj_t*p, real_t ms, unsigned& outRef )
+      void _ms_to_samples( obj_t*p, ftime_t ms, unsigned& outRef )
       {
-        outRef = std::max((real_t)1,(real_t)floor(ms * p->srate / 1000.0));
+        outRef = std::max(1u,(unsigned)floor(ms * p->srate / 1000.0));
       }
     }
   }
@@ -33,7 +33,7 @@ namespace cw
 // compressor
 //
 
-cw::rc_t cw::dsp::compressor::create( obj_t*& p, real_t srate, unsigned procSmpCnt, real_t inGain, real_t rmsWndMaxMs, real_t rmsWndMs, real_t threshDb, real_t ratio_num, real_t atkMs, real_t rlsMs, real_t outGain, bool bypassFl )
+cw::rc_t cw::dsp::compressor::create( obj_t*& p, srate_t srate, unsigned procSmpCnt, coeff_t inGain, ftime_t rmsWndMaxMs, ftime_t rmsWndMs, coeff_t threshDb, coeff_t ratio_num, ftime_t atkMs, ftime_t rlsMs, coeff_t outGain, bool bypassFl )
 {
   p = mem::allocZ<obj_t>();
       
@@ -105,8 +105,8 @@ cw::rc_t cw::dsp::compressor::exec( obj_t* p, const sample_t* x, sample_t* y, un
   p->rmsWnd[ p->rmsWndIdx ] = vop::rms(xx, n);               // calc and store signal RMS
   p->rmsWndIdx              = (p->rmsWndIdx + 1) % p->rmsWndCnt; // advance the RMS storage buffer
 
-  real_t rmsLin = vop::mean(p->rmsWnd,p->rmsWndCnt);                   // calc avg RMS
-  real_t rmsDb  = std::max(-100.0,20 * log10(std::max((real_t)0.00001,rmsLin)));  // convert avg RMS to dB
+  coeff_t rmsLin = vop::mean(p->rmsWnd,p->rmsWndCnt);                   // calc avg RMS
+  coeff_t rmsDb  = std::max(-100.0,20 * log10(std::max((coeff_t)0.00001,rmsLin)));  // convert avg RMS to dB
   rmsDb += 100.0;
 
   // if the compressor is bypassed
@@ -147,17 +147,17 @@ cw::rc_t cw::dsp::compressor::exec( obj_t* p, const sample_t* x, sample_t* y, un
 }
 
     
-void cw::dsp::compressor::set_attack_ms(  obj_t* p, real_t ms )
+void cw::dsp::compressor::set_attack_ms(  obj_t* p, ftime_t ms )
 {
   _ms_to_samples(p,ms,p->atkSmp);
 }
     
-void cw::dsp::compressor::set_release_ms( obj_t* p, real_t ms )
+void cw::dsp::compressor::set_release_ms( obj_t* p, ftime_t ms )
 {
   _ms_to_samples(p,ms,p->rlsSmp);
 }
     
-void cw::dsp::compressor::set_rms_wnd_ms( obj_t* p, real_t ms )
+void cw::dsp::compressor::set_rms_wnd_ms( obj_t* p, ftime_t ms )
 {
   p->rmsWndCnt = std::max((unsigned)1,(unsigned)floor(ms * p->srate / (1000.0 * p->procSmpCnt)));
 
@@ -170,7 +170,7 @@ void cw::dsp::compressor::set_rms_wnd_ms( obj_t* p, real_t ms )
 // Limiter
 //
 
-cw::rc_t cw::dsp::limiter::create( obj_t*& p, real_t srate, unsigned procSmpCnt, real_t thresh, real_t igain, real_t ogain, bool bypassFl )
+cw::rc_t cw::dsp::limiter::create( obj_t*& p, srate_t srate, unsigned procSmpCnt, coeff_t thresh, coeff_t igain, coeff_t ogain, bool bypassFl )
 {
   p = mem::allocZ<obj_t>();
 
@@ -196,7 +196,7 @@ cw::rc_t cw::dsp::limiter::exec( obj_t* p, const sample_t* x, sample_t* y, unsig
   }
   else
   {
-    real_t T = p->thresh * p->ogain;
+    coeff_t T = p->thresh * p->ogain;
   
     for(unsigned i=0; i<n; ++i)
     {
@@ -227,7 +227,7 @@ cw::rc_t cw::dsp::limiter::exec( obj_t* p, const sample_t* x, sample_t* y, unsig
 // dc-filter
 //
 
-cw::rc_t cw::dsp::dc_filter::create( obj_t*& p, real_t srate, unsigned procSmpCnt, real_t gain, bool bypassFl )
+cw::rc_t cw::dsp::dc_filter::create( obj_t*& p, srate_t srate, unsigned procSmpCnt, coeff_t gain, bool bypassFl )
 {
   p = mem::allocZ<obj_t>();
 
@@ -255,12 +255,12 @@ cw::rc_t cw::dsp::dc_filter::exec( obj_t* p, const sample_t* x, sample_t* y, uns
   if( p->bypassFl )
     vop::copy(y,x,n);
   else
-    vop::filter<sample_t,real_t>(y,n,x,n,p->b0, p->b, p->a,  p->d, 1 );
+    vop::filter<sample_t,coeff_t>(y,n,x,n,p->b0, p->b, p->a,  p->d, 1 );
 
   return kOkRC;
 }
 
-cw::rc_t cw::dsp::dc_filter::set( obj_t* p, real_t gain, bool bypassFl )
+cw::rc_t cw::dsp::dc_filter::set( obj_t* p, coeff_t gain, bool bypassFl )
 {
   p->gain = gain;
   p->bypassFl = bypassFl;
@@ -272,7 +272,7 @@ cw::rc_t cw::dsp::dc_filter::set( obj_t* p, real_t gain, bool bypassFl )
 // Recorder
 //
 
-cw::rc_t cw::dsp::recorder::create(  obj_t*& pRef, real_t srate, real_t max_secs, unsigned chN )
+cw::rc_t cw::dsp::recorder::create(  obj_t*& pRef, srate_t srate, ftime_t max_secs, unsigned chN )
 {
   obj_t* p     = mem::allocZ<obj_t>();
   p->srate     = srate;
@@ -383,7 +383,7 @@ namespace cw {
   }
 }
 
-cw::rc_t cw::dsp::audio_meter::create( obj_t*& p, real_t srate, real_t maxWndMs, real_t wndMs, real_t peakThreshDb )
+cw::rc_t cw::dsp::audio_meter::create( obj_t*& p, srate_t srate, ftime_t maxWndMs, ftime_t wndMs, coeff_t peakThreshDb )
 {
   rc_t rc = kOkRC;
 
@@ -475,7 +475,7 @@ void cw::dsp::audio_meter::reset( obj_t* p )
   p->clipCnt = 0;
 }
 
-void cw::dsp::audio_meter::set_window_ms( obj_t* p, real_t wndMs )
+void cw::dsp::audio_meter::set_window_ms( obj_t* p, ftime_t wndMs )
 {
   unsigned wndSmpN  = (unsigned)((wndMs * p->srate)/1000.0);
 
diff --git a/cwDspTransforms.h b/cwDspTransforms.h
index 0d361bc..4248c0e 100644
--- a/cwDspTransforms.h
+++ b/cwDspTransforms.h
@@ -14,36 +14,36 @@ namespace cw
 
       typedef struct
       {
-        real_t      srate;          // system sample rate
+        srate_t     srate;          // system sample rate
         unsigned    procSmpCnt;     // samples per exec cycle
-        real_t      inGain;         // input gain
-        real_t      threshDb;       // threshold in dB (max:100 min:0) 
-        real_t      ratio_num;      // numerator of the ratio
+        coeff_t      inGain;         // input gain
+        coeff_t      threshDb;       // threshold in dB (max:100 min:0) 
+        coeff_t      ratio_num;      // numerator of the ratio
         unsigned    atkSmp;         // time to reduce   the signal by 10.0 db
         unsigned    rlsSmp;         // time to increase the signal by 10.0 db
-        real_t      outGain;        // makeup gain
+        coeff_t      outGain;        // makeup gain
         bool        bypassFl;       // bypass enable
         sample_t*   rmsWnd;         // rmsWnd[rmsWndAllocCnt]
         unsigned    rmsWndAllocCnt; // 
         unsigned    rmsWndCnt;      // current RMS window size (rmsWndCnt must be <= rmsWndAllocCnt)
         unsigned    rmsWndIdx;      // next RMS window input index
         unsigned    state;          // env. state
-        real_t      rmsDb;          // current incoming signal RMS (max:100 min:0)
-        real_t      gain;           // current compressor  gain
-        real_t      timeConstDb;    // the atk/rls will incr/decr by 'timeConstDb' per atkMs/rlsMs.
-        real_t      pkDb;           //
-        real_t      accumDb;        //
+        coeff_t      rmsDb;          // current incoming signal RMS (max:100 min:0)
+        coeff_t      gain;           // current compressor  gain
+        coeff_t      timeConstDb;    // the atk/rls will incr/decr by 'timeConstDb' per atkMs/rlsMs.
+        coeff_t      pkDb;           //
+        coeff_t      accumDb;        //
 
       } obj_t;
       
-      rc_t create( obj_t*& p, real_t srate, unsigned procSmpCnt, real_t inGain, real_t rmsWndMaxMs, real_t rmsWndMs, real_t threshDb, real_t ratio, real_t atkMs, real_t rlsMs, real_t outGain, bool bypassFl );
+      rc_t create( obj_t*& p, srate_t srate, unsigned procSmpCnt, coeff_t inGain, ftime_t rmsWndMaxMs, ftime_t rmsWndMs, coeff_t threshDb, coeff_t ratio, ftime_t atkMs, ftime_t rlsMs, coeff_t outGain, bool bypassFl );
       rc_t destroy( obj_t*& pp );
       rc_t exec( obj_t* p, const sample_t* x, sample_t* y, unsigned n );
       
-      void set_attack_ms(  obj_t* p, real_t ms );
-      void set_release_ms( obj_t* p, real_t ms );
-      void set_thresh_db(  obj_t* p, real_t thresh );
-      void set_rms_wnd_ms( obj_t* p, real_t ms );
+      void set_attack_ms(  obj_t* p, ftime_t ms );
+      void set_release_ms( obj_t* p, ftime_t ms );
+      void set_thresh_db(  obj_t* p, coeff_t thresh );
+      void set_rms_wnd_ms( obj_t* p, ftime_t ms );
     }
 
     namespace limiter
@@ -51,13 +51,13 @@ namespace cw
       typedef struct
       {
         unsigned procSmpCnt;
-        real_t   igain;   // applied before thresholding
-        real_t   thresh;  // linear (0.0-1.0) threshold.
-        real_t   ogain;   // applied after thresholding
+        coeff_t   igain;   // applied before thresholding
+        coeff_t   thresh;  // linear (0.0-1.0) threshold.
+        coeff_t   ogain;   // applied after thresholding
         bool     bypassFl;
       } obj_t;
       
-      rc_t create( obj_t*& p, real_t srate, unsigned procSmpCnt, real_t thresh, real_t igain, real_t ogain, bool bypassFl );
+      rc_t create( obj_t*& p, srate_t srate, unsigned procSmpCnt, coeff_t thresh, coeff_t igain, coeff_t ogain, bool bypassFl );
       rc_t destroy( obj_t*& pp );
       rc_t exec( obj_t* p, const sample_t* x, sample_t* y, unsigned n );
     }
@@ -66,32 +66,32 @@ namespace cw
     {
       typedef struct
       {
-        real_t d[2]; //
-        real_t b[1]; // 
-        real_t a[1]; // a[dn] feedback coeff's
-        real_t b0;   // feedforward coeff 0
+        coeff_t d[2]; //
+        coeff_t b[1]; // 
+        coeff_t a[1]; // a[dn] feedback coeff's
+        coeff_t b0;   // feedforward coeff 0
         bool   bypassFl;
-        real_t gain;
+        coeff_t gain;
       } obj_t;
 
-      rc_t create( obj_t*& p, real_t srate, unsigned procSmpCnt, real_t gain, bool bypassFl );
+      rc_t create( obj_t*& p, srate_t srate, unsigned procSmpCnt, coeff_t gain, bool bypassFl );
       rc_t destroy( obj_t*& pp );
       rc_t exec( obj_t* p, const sample_t* x, sample_t* y, unsigned n );
-      rc_t set( obj_t* p, real_t gain, bool bypassFl );
+      rc_t set( obj_t* p, coeff_t gain, bool bypassFl );
     }
 
     namespace recorder
     {
       typedef struct
       {
-        real_t    srate;      //
+        srate_t    srate;      //
         unsigned  maxFrameN;  //
         unsigned  chN;        //  channel count
         unsigned  frameIdx;   //  next frame to write
         sample_t* buf;        //   [ [maxFrameN] [maxFrameN] ]
       } obj_t;                //        ch0          ch1
 
-      rc_t create(  obj_t*& pRef, real_t srate, real_t max_secs, unsigned chN );
+      rc_t create(  obj_t*& pRef, srate_t srate, ftime_t max_secs, unsigned chN );
       rc_t destroy( obj_t*& pRef);
       
       rc_t exec(    obj_t* p, const sample_t* buf,   unsigned chN, unsigned frameN );
@@ -107,10 +107,10 @@ namespace cw
 	unsigned  maxWndSmpN;
 	unsigned  wndSmpN;
 	sample_t* wndV;
-	real_t    srate;
-	real_t    peakThreshDb;
-	real_t    outLin;
-	real_t    outDb;
+	srate_t   srate;
+	coeff_t    peakThreshDb;
+	coeff_t    outLin;
+	coeff_t    outDb;
 	bool      peakFl;
 	bool      clipFl;
 	unsigned  peakCnt;
@@ -118,11 +118,11 @@ namespace cw
 	unsigned  wi;
       } obj_t;
       
-      rc_t create( obj_t*& p, real_t srate, real_t maxWndMs, real_t wndMs, real_t peakThreshDb );
+      rc_t create( obj_t*& p, srate_t srate, ftime_t maxWndMs, ftime_t wndMs, coeff_t peakThreshDb );
       rc_t destroy( obj_t*& pp );
       rc_t exec( obj_t* p, const sample_t* x, unsigned n );
       void reset( obj_t* p );
-      void set_window_ms( obj_t* p, real_t wndMs );
+      void set_window_ms( obj_t* p, ftime_t wndMs );
 
     }
   }  
diff --git a/cwDspTypes.h b/cwDspTypes.h
index 9a03f69..e8cc1ab 100644
--- a/cwDspTypes.h
+++ b/cwDspTypes.h
@@ -5,10 +5,11 @@ namespace cw
 {
   namespace dsp
   {
-    typedef float    real_t;
     typedef float   sample_t;
-    typedef float  fd_real_t;
+    typedef float   fd_sample_t; // Frequency domain sample - type used by magnitude,phase,real,imag. part of spectral values
     typedef float   srate_t;
+    typedef float   coeff_t;   // values that are directly applied to signals of sample_t.
+    typedef double   ftime_t;   // any time value expressed as a floating point value - could be seconds, milliseconds, etc
   }
 }
 #endif

From bdcb26ac726fd4f5d9a6369b20a65f8850708acf Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:04:03 -0400
Subject: [PATCH 028/101] cwFlowTypes.h : Changes to account for changed
 dsp::types. Added is_connected_to_source_proc(), var_is_source() and
 is_source_var().

---
 cwFlowTypes.cpp | 91 +++++++++++++++++++++++++++++++++++--------------
 cwFlowTypes.h   | 84 ++++++++++++++++++++++++---------------------
 2 files changed, 111 insertions(+), 64 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 0788edc..eada7df 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -24,7 +24,6 @@ namespace cw
       { kUIntTFl,  "uint" },
       { kIntTFl,   "int", },
       { kFloatTFl, "float"},
-      { kRealTFl,  "real"},
       { kDoubleTFl,"double"},
       
       { kBoolMtxTFl,  "bool_mtx" },
@@ -38,6 +37,14 @@ namespace cw
       { kMBufTFl,   "midi" },
       { kStringTFl, "string" },
       { kTimeTFl,   "time" },
+      { kCfgTFl,    "cfg" },
+
+      // alias types to map to cwDspTypes.h
+      { kFloatTFl, "srate"},
+      { kFloatTFl, "sample"},
+      { kFloatTFl, "coeff"},
+      { kDoubleTFl, "ftime" },
+
       { kInvalidTFl, nullptr }
     };
 
@@ -461,12 +468,18 @@ namespace cw
     rc_t _var_broadcast_new_value( variable_t* var )
     {
       rc_t rc = kOkRC;
-      /*
+      
       // notify each connected var that the value has changed
       for(variable_t* con_var = var->connect_link; con_var!=nullptr; con_var=con_var->connect_link)
-        if((rc = con_var->inst->class_desc->members->value( con_var->inst, con_var )) != kOkRC )
-          break;
-      */
+      {
+        // the var->local_value[] slot used by the source variable may have changed - update the destination variable
+        // so that it points to the correct value.
+        con_var->value = var->value;
+       
+        //if((rc = con_var->inst->class_desc->members->value( con_var->inst, con_var )) != kOkRC )
+        //  break;
+       
+      }
       return rc;
     }
 
@@ -548,7 +561,7 @@ namespace cw
       var->local_value[ local_value_idx ].flags  = kFBufTFl;
       cwLogMod("%s:%i.%s:%i ch:%i %s (fbuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,fbuf==nullptr ? "null" : "valid");
     }
-    
+        
     template< typename T >
     rc_t _var_set_template( variable_t* var, unsigned typeFlag, T val )
     {
@@ -604,7 +617,7 @@ namespace cw
     }
     
     
-    bool is_connected_to_external_proc( const variable_t* var )
+    bool is_connected_to_source_proc( const variable_t* var )
     {
       // if this var does not have a 'src_ptr' then it can't be connected to an external proc
       if( var->src_var == nullptr || var->value == nullptr )
@@ -618,13 +631,16 @@ namespace cw
       return true;
     }
 
+    bool is_a_source_var( const variable_t* var )
+    { return var->connect_link != nullptr; }
+
     template< typename T >
     rc_t _var_set_driver( variable_t* var, unsigned typeFlag, T value )
     {
       rc_t rc;
 
       // if this variable is fed from the output of an external proc - then it's local value cannot be set
-      if(is_connected_to_external_proc(var)   )
+      if(is_connected_to_source_proc(var)   )
         return kOkRC;
       
 
@@ -687,6 +703,7 @@ namespace cw
     {
       rc_t rc = kOkRC;
 
+      // get the variable type - note that the value type (value->flags) may be differnt
       unsigned typeFlag = var->varDesc->type & kTypeMask;
       
       switch( typeFlag )
@@ -882,7 +899,7 @@ namespace cw
 
     void _var_print( const variable_t* var )
     {
-      const char* conn_label  = is_connected_to_external_proc(var) ? "extern" : "      ";
+      const char* conn_label  = is_connected_to_source_proc(var) ? "extern" : "      ";
     
       printf("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
     
@@ -969,7 +986,7 @@ const cw::flow::sample_t*   cw::flow::abuf_get_channel( abuf_t* abuf, unsigned c
   return abuf->buf + (chIdx*abuf->frameN);
 }
 
-cw::flow::fbuf_t* cw::flow::fbuf_create( srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
+cw::flow::fbuf_t* cw::flow::fbuf_create( srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   for(unsigned i=0; i<chN; ++i)
     if( binN_V[i] > maxBinN_V[i] )
@@ -985,9 +1002,9 @@ cw::flow::fbuf_t* cw::flow::fbuf_create( srate_t srate, unsigned chN, const unsi
   f->maxBinN_V = mem::allocZ<unsigned>(chN);
   f->binN_V    = mem::allocZ<unsigned>(chN);
   f->hopSmpN_V = mem::allocZ<unsigned>(chN); 
-  f->magV      = mem::allocZ<fd_real_t*>(chN);
-  f->phsV      = mem::allocZ<fd_real_t*>(chN);
-  f->hzV       = mem::allocZ<fd_real_t*>(chN);
+  f->magV      = mem::allocZ<fd_sample_t*>(chN);
+  f->phsV      = mem::allocZ<fd_sample_t*>(chN);
+  f->hzV       = mem::allocZ<fd_sample_t*>(chN);
   f->readyFlV  = mem::allocZ<bool>(chN);
 
   vop::copy( f->binN_V, binN_V, chN );
@@ -998,17 +1015,17 @@ cw::flow::fbuf_t* cw::flow::fbuf_create( srate_t srate, unsigned chN, const unsi
   {
     for(unsigned chIdx=0; chIdx<chN; ++chIdx)
     {      
-      f->magV[ chIdx ] = (fd_real_t*)magV[chIdx];
-      f->phsV[ chIdx ] = (fd_real_t*)phsV[chIdx];
-      f->hzV[  chIdx ] = (fd_real_t*)hzV[chIdx];
+      f->magV[ chIdx ] = (fd_sample_t*)magV[chIdx];
+      f->phsV[ chIdx ] = (fd_sample_t*)phsV[chIdx];
+      f->hzV[  chIdx ] = (fd_sample_t*)hzV[chIdx];
     }
   }
   else
   {
     unsigned maxTotalBinsN = vop::sum( maxBinN_V, chN );
         
-    fd_real_t* buf       = mem::allocZ<fd_real_t>( kFbufVectN * maxTotalBinsN );
-    fd_real_t* m         = buf;
+    fd_sample_t* buf       = mem::allocZ<fd_sample_t>( kFbufVectN * maxTotalBinsN );
+    fd_sample_t* m         = buf;
     for(unsigned chIdx=0; chIdx<chN; ++chIdx)
     {   
       f->magV[chIdx] = m + 0 * f->binN_V[chIdx];
@@ -1026,7 +1043,7 @@ cw::flow::fbuf_t* cw::flow::fbuf_create( srate_t srate, unsigned chN, const unsi
 }
 
 
-cw::flow::fbuf_t*  cw::flow::fbuf_create( srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
+cw::flow::fbuf_t*  cw::flow::fbuf_create( srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   unsigned maxBinN_V[ chN ];
   unsigned binN_V[ chN ];
@@ -1249,12 +1266,10 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
     rc = cwLogError(kInvalidStateRC,"The base ('any') channel variable could not be located on '%s:%i.%s:%i'.",inst->label,inst->label_sfx_id,var_label,sfx_id);
     goto errLabel;
   }
-
-  
+ 
   // locate the variable with the stated chIdx
   var = _var_find_on_label_and_ch( inst, var_label, sfx_id, chIdx );
   
-
   // 'src' variables cannot be channelized
   if( cwIsFlag(base_var->varDesc->flags,kSrcVarFl) )
   {
@@ -1287,6 +1302,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
     // a correctly channelized var was found - but we still may need to set the value
     if( value_cfg != nullptr )
     {
+      //cwLogInfo("%s ch:%i",var_label,chIdx);
       rc = _set_var_value_from_cfg( var, value_cfg );
     }
     else
@@ -1300,7 +1316,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on instance '%s:i' ch:%i.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx );
+    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on instance '%s:%i' ch:%i.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx );
   
   return rc;
 }
@@ -1319,6 +1335,31 @@ bool cw::flow::var_has_value( instance_t* inst, const char* label, unsigned sfx_
   return varPtr->value != nullptr;
 }
 
+bool  cw::flow::var_is_a_source( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
+{
+  rc_t rc;
+  variable_t* varPtr = nullptr;
+  if((rc = var_find( inst, label, sfx_id, chIdx, varPtr)) != kOkRC )
+  {
+    cwLogError(kEleNotFoundRC,"The variable '%s:%i' was not found on proc:'%s:%i'. 'source' state query is invalid.",cwStringNullGuard(label),sfx_id,cwStringNullGuard(inst->label),inst->label_sfx_id);
+    return false;
+  }
+  
+  return is_a_source_var(varPtr);
+}
+
+bool  cw::flow::var_is_a_source( instance_t* inst, unsigned vid, unsigned chIdx )
+{
+  rc_t rc;
+  variable_t* varPtr = nullptr;
+  if((rc = var_find( inst, vid, chIdx, varPtr)) != kOkRC )
+  {
+    cwLogError(kEleNotFoundRC,"The variable with vid '%i' was not found on proc:'%s:%i'. 'source' state query is invalid.",vid,cwStringNullGuard(inst->label),inst->label_sfx_id);
+    return false;
+  }
+  
+  return is_a_source_var(varPtr);
+}
 
 cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, variable_t*& varRef )
 {
@@ -1471,7 +1512,7 @@ cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* va
   return rc;
 }
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
+cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   rc_t rc = kOkRC;
   fbuf_t* fbuf;
@@ -1499,7 +1540,7 @@ cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* va
 }
 
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV, const fd_real_t** phsV, const fd_real_t** hzV )
+cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   unsigned maxBinN_V[ chN ];
   unsigned binN_V[ chN ];
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index e111842..a0ae0c7 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -3,13 +3,13 @@ namespace cw
   namespace flow
   {
 
-    #define kRealTFl kFloatTFl
-    typedef dsp::real_t    real_t;
-    typedef dsp::sample_t  sample_t;
-    typedef dsp::fd_real_t fd_real_t;
-    typedef dsp::srate_t   srate_t;
-    typedef unsigned       uint_t;
-    typedef int            int_t;
+    typedef dsp::coeff_t     coeff_t;
+    typedef dsp::sample_t    sample_t;
+    typedef dsp::fd_sample_t fd_sample_t;
+    typedef dsp::srate_t     srate_t;
+    typedef dsp::ftime_t     ftime_t;
+    typedef unsigned         uint_t;
+    typedef int              int_t;
     
     
     typedef unsigned vid_t;
@@ -40,11 +40,11 @@ namespace cw
       unsigned*         maxBinN_V; // max value that binN_V[i] is allowed to take
       unsigned*         binN_V;    // binN_V[ chN ] count of sample frames per channel
       unsigned*         hopSmpN_V; // hopSmpN_V[ chN ] hop sample count 
-      fd_real_t**       magV;      // magV[ chN ][ binN ]
-      fd_real_t**       phsV;      // phsV[ chN ][ binN ]
-      fd_real_t**       hzV;       // hzV[ chN ][ binN ]
+      fd_sample_t**       magV;      // magV[ chN ][ binN ]
+      fd_sample_t**       phsV;      // phsV[ chN ][ binN ]
+      fd_sample_t**       hzV;       // hzV[ chN ][ binN ]
       bool*             readyFlV;  // readyFlV[chN] true if this channel is ready to be processed (used to sync. fbuf rate to abuf rate)
-      fd_real_t*        buf;       // memory used by this buffer (or NULL if magV,phsV,hzV point are proxied to another buffer)      
+      fd_sample_t*        buf;       // memory used by this buffer (or NULL if magV,phsV,hzV point are proxied to another buffer)      
     } fbuf_t;
 
     typedef struct mbuf_str
@@ -66,15 +66,15 @@ namespace cw
       kBoolMtxTFl  = 0x00000020,
       kUIntMtxTFl  = 0x00000040,
       kIntMtxTFl   = 0x00000080,
-      kRealMtxTFl  = 0x00000100,
-      kFloatMtxTFl = 0x00000200,
-      kDoubleMtxTFl= 0x00000400,
+      kFloatMtxTFl = 0x00000100,
+      kDoubleMtxTFl= 0x00000200,
       
-      kABufTFl     = 0x00000800,
-      kFBufTFl     = 0x00001000,
-      kMBufTFl     = 0x00002000,
-      kStringTFl   = 0x00004000,
-      kTimeTFl     = 0x00008000,
+      kABufTFl     = 0x00000400,
+      kFBufTFl     = 0x00000800,
+      kMBufTFl     = 0x00001000,
+      kStringTFl   = 0x00002000,
+      kTimeTFl     = 0x00004000,
+      kCfgTFl      = 0x00008000,
 
       kTypeMask    = 0x0000ffff,
 
@@ -85,7 +85,6 @@ namespace cw
       union {
         struct mtx::mtx_str< unsigned >* u;
         struct mtx::mtx_str< int >*      i;
-        struct mtx::mtx_str< real_t >*   r;
         struct mtx::mtx_str< float >*    f;
         struct mtx::mtx_str< double >*   d;
       } u;
@@ -95,20 +94,20 @@ namespace cw
     {
       unsigned flags;
       union {
-        bool      b;
-        uint_t    u;
-        int_t     i;
-        float     f;
-        double    d;
-
-        mtx_t*    mtx;
+        bool            b;
+        uint_t          u;
+        int_t           i;
+        float           f;
+        double          d;
         
-        abuf_t*   abuf;
-        fbuf_t*   fbuf;
-        mbuf_t*   mbuf;
+        mtx_t*          mtx;        
+        abuf_t*         abuf;
+        fbuf_t*         fbuf;
+        mbuf_t*         mbuf;
         
-        char*     s;
-        char*     fname;
+        char*           s;
+        
+        const object_t* cfg;
 
       } u;
       
@@ -269,8 +268,8 @@ namespace cw
     rc_t            abuf_set_channel( abuf_t* buf, unsigned chIdx, const sample_t* v, unsigned vN );
     const sample_t* abuf_get_channel( abuf_t* buf, unsigned chIdx );
 
-    fbuf_t*        fbuf_create( srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
-    fbuf_t*        fbuf_create( srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
+    fbuf_t*        fbuf_create( srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
+    fbuf_t*        fbuf_create( srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
     void           fbuf_destroy( fbuf_t*& buf );
     fbuf_t*        fbuf_duplicate( const fbuf_t* src );
 
@@ -332,8 +331,12 @@ namespace cw
     // `value_cfg` is optional. Set it to NULL to ignore
     rc_t           var_register( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
-    // Returns true if this var is connected to an external proc variable
-    bool           is_connected_to_external_proc( const variable_t* var );
+    // Returns true if this var is connected to an source proc variable
+    bool           is_connected_to_source_proc( const variable_t* var );
+
+    // Return true if this var is acting as a source for another var.
+    bool           is_a_source_var( const variable_t* var );
+
 
     //-----------------
     //
@@ -411,8 +414,8 @@ namespace cw
     
     rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
     rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_real_t** magV=nullptr, const fd_real_t** phsV=nullptr, const fd_real_t** hzV=nullptr );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
+    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
 
     inline rc_t _var_register_and_set(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
 
@@ -424,7 +427,8 @@ namespace cw
       variable_t* var = nullptr;
       if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) == kOkRC )
       {
-        var_set( inst, vid, chIdx, val );
+        if((rc = var_set( inst, vid, chIdx, val )) != kOkRC )
+          return rc;
         
         if((rc = _var_register_and_set( inst, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
           return rc;
@@ -444,6 +448,8 @@ namespace cw
 
     bool           var_exists(    instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
     bool           var_has_value( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_is_a_source( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_is_a_source( instance_t* inst, unsigned vid, unsigned chIdx );
 
     rc_t           var_find(   instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const variable_t*& varRef );
     rc_t           var_find(   instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx,       variable_t*& varRef );

From b4529aeb3fd46a1c0a4c5f1c44506ef309ea5c06 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:05:48 -0400
Subject: [PATCH 029/101] cwFlow.h.cpp : test() now takes a command line
 argument to select a particular test case. 'multi???Preset???Fl' in network
 cfg. are now optional.

---
 cwFlow.cpp | 37 +++++++++++++++++++++++++++++--------
 cwFlow.h   |  2 +-
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index ceea17f..cdea341 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -9,7 +9,7 @@
 #include "cwAudioFile.h"
 #include "cwVectOps.h"
 #include "cwMtx.h"
-#include "cwDspTypes.h" // real_t, sample_t
+#include "cwDspTypes.h" // coeff_t, sample_t, srate_t ...
 #include "cwTime.h"
 #include "cwMidiDecls.h"
 #include "cwFlowDecl.h"
@@ -54,6 +54,10 @@ namespace cw
       { "audio_marker",    &audio_marker::members },
       { "xfade_ctl",       &xfade_ctl::members },
       { "poly_mixer",      &poly_mixer::members },
+      { "sample_hold",     &sample_hold::members },
+      { "number",          &number::members },
+      { "timer",           &timer::members },
+      { "counter",         &counter::members },
       { nullptr, nullptr }
     };
 
@@ -197,7 +201,7 @@ namespace cw
             // convert the type string to a numeric type flag
             if( (type_flag = value_type_label_to_flag( type_str )) == kInvalidTId )
             {
-              rc = cwLogError(rc,"Invalid type flag: '%s' class:'%s' value:'%s'.", type_str, cd->label, vd->label );
+              rc = cwLogError(kSyntaxErrorRC,"Invalid type flag: '%s' class:'%s' value:'%s'.", type_str, cd->label, vd->label );
               goto errLabel;            
             }
 
@@ -400,9 +404,6 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
 
   // parse the main audio file processor cfg record
   if((rc = flowCfg.getv("framesPerCycle",      p->framesPerCycle,
-                        "multiPriPresetProbFl", p->multiPriPresetProbFl,
-                        "multiSecPresetProbFl", p->multiSecPresetProbFl,
-                        "multiPresetInterpFl", p->multiPresetInterpFl,
                         "network",             networkCfg)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the required flow configuration parameters.");
@@ -411,6 +412,9 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
 
   // parse the optional args
   if((rc = flowCfg.getv_opt("maxCycleCount",    p->maxCycleCount,
+                            "multiPriPresetProbFl", p->multiPriPresetProbFl,
+                            "multiSecPresetProbFl", p->multiSecPresetProbFl,
+                            "multiPresetInterpFl", p->multiPresetInterpFl,
                             "printClassDictFl", printClassDictFl,
                             "printNetworkFl",   printNetworkFl)) != kOkRC )
   {
@@ -591,20 +595,37 @@ void cw::flow::print_network( handle_t h )
 }
 
 
-cw::rc_t cw::flow::test(  const object_t* cfg )
+cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
 {
   rc_t rc = kOkRC;
   handle_t flowH;
 
   object_t* class_cfg = nullptr;
+  const object_t* test_cases_cfg = nullptr;
+  const object_t* test_cfg = nullptr;
   const char* flow_proc_fname;
+
+  if( argc < 2 || textLength(argv[1]) == 0 )
+  {
+    rc = cwLogError(kInvalidArgRC,"No 'test-case' label was given on the command line.");
+    goto errLabel;
+  }
   
-  if((rc = cfg->getv("flow_proc_fname",flow_proc_fname)) != kOkRC )
+  if((rc = cfg->getv("flow_proc_fname",flow_proc_fname,
+                     "test_cases",test_cases_cfg)) != kOkRC )
   {
     rc = cwLogError(rc,"The name of the flow_proc_dict file could not be parsed.");
     goto errLabel;
   }
 
+  // find the user requested test case
+  if((test_cfg = test_cases_cfg->find_child(argv[1])) == nullptr )
+  {
+    rc = cwLogError(kInvalidArgRC,"The test case named '%s' was not found.",argv[0]);
+    goto errLabel;
+  }  
+
+  // parse the flow-proc-cfg
   if((rc = objectFromFile(flow_proc_fname,class_cfg)) != kOkRC )
   {
     rc = cwLogError(rc,"The flow proc dict could not be read from '%s'.",cwStringNullGuard(flow_proc_fname));
@@ -612,7 +633,7 @@ cw::rc_t cw::flow::test(  const object_t* cfg )
   }
 
   // create the flow object
-  if((rc = create( flowH, *class_cfg, *cfg)) != kOkRC )
+  if((rc = create( flowH, *class_cfg, *test_cfg)) != kOkRC )
   {
     rc = cwLogError(rc,"Flow object create failed.");
     goto errLabel;
diff --git a/cwFlow.h b/cwFlow.h
index 51a767c..722775a 100644
--- a/cwFlow.h
+++ b/cwFlow.h
@@ -50,7 +50,7 @@ namespace cw
     void print_class_list( handle_t h );
     void print_network( handle_t h );
 
-    rc_t test( const object_t* cfg );
+    rc_t test( const object_t* cfg, int argc, const char* argv[] );
 
     
     

From fc8b806d97ecb41c505f766b27b20f9d5567674f Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:09:10 -0400
Subject: [PATCH 030/101] cwFlowProc.h/cpp : Added
 'sample_hold','number','timer','counter'.

---
 cwFlowProc.cpp | 799 +++++++++++++++++++++++++++++++++++++++++++++----
 cwFlowProc.h   |   5 +
 2 files changed, 753 insertions(+), 51 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index bb23ca1..b55993c 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -8,7 +8,7 @@
 #include "cwVectOps.h"
 #include "cwMtx.h"
 
-#include "cwDspTypes.h" // real_t, sample_t
+#include "cwDspTypes.h" // srate_t, sample_t, coeff_t, ...
 
 #include "cwTime.h"
 #include "cwMidiDecls.h"
@@ -43,40 +43,40 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t create( instance_t* proc )
       {
         rc_t    rc   = kOkRC;        
-        inst_t* inst = mem::allocZ<inst_t>();
-        ctx->userPtr = inst;
+        inst_t* p = mem::allocZ<inst_t>();
+        proc->userPtr = p;
 
         // Custom create code goes here
 
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( instance_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* p = (inst_t*)proc->userPtr;
 
         // Custom clean-up code goes here
 
-        mem::release(inst);
+        mem::release(p);
         
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( instance_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( instance_t* proc )
       {
-        rc_t     rc           = kOkRC;
-        //inst_t*  inst         = (inst_t*)ctx->userPtr;
+        rc_t rc      = kOkRC;
+        //inst_t*  p = (inst_t*)proc->userPtr;
         
         return rc;
       }
@@ -91,6 +91,7 @@ namespace cw
       
     }    
 
+    
     //------------------------------------------------------------------------------------------------------------------
     //
     // poly
@@ -219,14 +220,14 @@ namespace cw
       
       typedef struct
       {
-        real_t value; 
+        coeff_t value; 
       } inst_t;
 
 
       rc_t create( instance_t* ctx )
       {
         rc_t rc = kOkRC;        
-        real_t in_value = 0.5;
+        coeff_t in_value = 0.5;
         ctx->userPtr = mem::allocZ<inst_t>();
         
         if((rc  = var_register_and_get( ctx, kAnyChIdx, kInPId, "in", kBaseSfxId, in_value )) != kOkRC )
@@ -234,7 +235,7 @@ namespace cw
 
         if((rc = var_register_and_set( ctx, kAnyChIdx,
                                        kOutPId,    "out",     kBaseSfxId, in_value,
-                                       kInvOutPId, "inv_out", kBaseSfxId, (real_t)(1.0-in_value) )) != kOkRC )
+                                       kInvOutPId, "inv_out", kBaseSfxId, (coeff_t)(1.0-in_value) )) != kOkRC )
         {
           goto errLabel;
         }
@@ -259,11 +260,11 @@ namespace cw
         rc_t   rc = kOkRC;
         inst_t* inst = (inst_t*)(ctx->userPtr);
         
-        real_t value = 1;
+        coeff_t value = 1;
         
         var_get(ctx, kInPId,     kAnyChIdx, value);
         var_set(ctx, kOutPId,    kAnyChIdx, value);
-        var_set(ctx, kInvOutPId, kAnyChIdx, (real_t)(1.0 - value) );
+        var_set(ctx, kInvOutPId, kAnyChIdx, (coeff_t)(1.0 - value) );
 
         if( inst->value != value )
         {
@@ -748,7 +749,7 @@ namespace cw
       {
         rc_t rc = kOkRC;
         audiofile::info_t info;
-        real_t seekSecs;
+        ftime_t seekSecs;
         inst_t* inst = mem::allocZ<inst_t>();
         ctx->userPtr = inst;
 
@@ -808,7 +809,7 @@ namespace cw
       rc_t value( instance_t* ctx, variable_t* var )
       {
         rc_t rc = kOkRC;
-        real_t seekSecs = 0;
+        ftime_t seekSecs = 0;
         inst_t* inst = (inst_t*)ctx->userPtr;
 
         if((rc = var_get(ctx,kSeekSecsPId,kAnyChIdx,seekSecs)) != kOkRC )
@@ -1005,8 +1006,8 @@ namespace cw
       typedef struct inst_str
       {
         unsigned n;
-        real_t vgain;
-        real_t gain;
+        coeff_t vgain;
+        coeff_t gain;
       } inst_t;
 
       rc_t create( instance_t* ctx )
@@ -1041,7 +1042,7 @@ namespace cw
 
       rc_t value( instance_t* ctx, variable_t* var )
       {
-        real_t value = 0;
+        coeff_t value = 0;
         inst_t* inst = (inst_t*)ctx->userPtr;
         var_get(ctx,kGainPId,0,value);
         
@@ -1631,7 +1632,7 @@ namespace cw
           {
             const sample_t* isig = ibuf->buf + i*ibuf->frameN;
             sample_t*       osig = obuf->buf + i*obuf->frameN;
-            real_t          gain = 1;
+            coeff_t          gain = 1;
 
             if((rc = var_get(ctx, gainPId, kAnyChIdx, gain)) != kOkRC )
               goto errLabel;
@@ -1694,13 +1695,15 @@ namespace cw
         kSratePId,
         kChCntPid,
         kFreqHzPId,
+        kPhasePId,
+        kDcPId,
         kGainPId,
         kOutPId
       };
       
       typedef struct
       {
-        real_t *phaseA;
+        double *phaseA;
       } inst_t;
       
       rc_t create( instance_t* ctx )
@@ -1709,8 +1712,10 @@ namespace cw
         inst_t*  inst  = mem::allocZ<inst_t>();
         srate_t  srate = 0;
         unsigned chCnt = 0;
-        real_t   gain;
-        real_t   hz;
+        coeff_t   gain;
+        coeff_t   hz;
+        coeff_t   phase;
+        coeff_t   dc;
         
         ctx->userPtr = inst;
 
@@ -1725,6 +1730,8 @@ namespace cw
           if((rc = var_register_and_get( ctx, i,
                                          kSratePId,  "srate", kBaseSfxId, srate,
                                          kFreqHzPId, "hz",    kBaseSfxId, hz,
+                                         kPhasePId,  "phase", kBaseSfxId, phase,
+                                         kDcPId,     "dc",    kBaseSfxId, dc,
                                          kGainPId,   "gain",  kBaseSfxId, gain)) != kOkRC )
           {
             goto errLabel;
@@ -1733,7 +1740,7 @@ namespace cw
         // create one output audio buffer
         rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, chCnt, ctx->ctx->framesPerCycle );
 
-        inst->phaseA = mem::allocZ<real_t>( chCnt );
+        inst->phaseA = mem::allocZ<double>( chCnt );
         
 
       errLabel:
@@ -1772,13 +1779,15 @@ namespace cw
         {
           for(unsigned i=0; i<abuf->chN; ++i)
           {
-            real_t    gain  = val_get<real_t>( ctx, kGainPId, i );
-            real_t    hz    = val_get<real_t>( ctx, kFreqHzPId, i );
-            srate_t   srate = val_get<srate_t>( ctx, kSratePId, i );                        
+            coeff_t    gain  = val_get<coeff_t>( ctx, kGainPId, i );
+            coeff_t    hz    = val_get<coeff_t>( ctx, kFreqHzPId, i );
+            coeff_t    phase = val_get<coeff_t>( ctx, kPhasePId, i );
+            coeff_t    dc    = val_get<coeff_t>( ctx, kDcPId, i );
+            srate_t   srate = val_get<srate_t>(ctx, kSratePId, i );                        
             sample_t* v     = abuf->buf + (i*abuf->frameN);
             
             for(unsigned j=0; j<abuf->frameN; ++j)
-              v[j] = (sample_t)(gain * sin( inst->phaseA[i] + (2.0 * M_PI * j * hz/srate)));
+              v[j] = (sample_t)((gain * sin( inst->phaseA[i] + phase + (2.0 * M_PI * j * hz/srate)))+dc);
 
             inst->phaseA[i] += 2.0 * M_PI * abuf->frameN * hz/srate;            
           }
@@ -1803,7 +1812,7 @@ namespace cw
     //
     namespace pv_analysis
     {
-      typedef struct dsp::pv_anl::obj_str<sample_t,fd_real_t> pv_t;
+      typedef struct dsp::pv_anl::obj_str<sample_t,fd_sample_t> pv_t;
 
       enum {
         kInPId,
@@ -1843,9 +1852,9 @@ namespace cw
           inst->pvN = srcBuf->chN;
           inst->pvA = mem::allocZ<pv_t*>( inst->pvN );  // allocate pv channel array
           
-          const fd_real_t* magV[ srcBuf->chN ];
-          const fd_real_t* phsV[ srcBuf->chN ];
-          const fd_real_t* hzV[  srcBuf->chN ];
+          const fd_sample_t* magV[ srcBuf->chN ];
+          const fd_sample_t* phsV[ srcBuf->chN ];
+          const fd_sample_t* hzV[  srcBuf->chN ];
           unsigned maxBinNV[ srcBuf->chN ];
           unsigned binNV[ srcBuf->chN ];
           unsigned hopNV[ srcBuf->chN ];
@@ -1991,7 +2000,7 @@ namespace cw
     //
     namespace pv_synthesis
     {
-      typedef struct dsp::pv_syn::obj_str<sample_t,fd_real_t> pv_t;
+      typedef struct dsp::pv_syn::obj_str<sample_t,fd_sample_t> pv_t;
 
       enum {
         kInPId,
@@ -2117,7 +2126,7 @@ namespace cw
     //
     namespace spec_dist
     {
-      typedef struct dsp::spec_dist::obj_str<fd_real_t,fd_real_t> spec_dist_t;
+      typedef struct dsp::spec_dist::obj_str<fd_sample_t,fd_sample_t> spec_dist_t;
 
       enum
       {
@@ -2160,9 +2169,9 @@ namespace cw
           inst->sdN = srcBuf->chN;
           inst->sdA = mem::allocZ<spec_dist_t*>( inst->sdN );  
 
-          const fd_real_t* magV[ srcBuf->chN ];
-          const fd_real_t* phsV[ srcBuf->chN ];
-          const fd_real_t*  hzV[ srcBuf->chN ];
+          const fd_sample_t* magV[ srcBuf->chN ];
+          const fd_sample_t* phsV[ srcBuf->chN ];
+          const fd_sample_t*  hzV[ srcBuf->chN ];
 
           //if((rc = var_register(ctx, kAnyChIdx, kInPId, "in")) != kOkRC )
           //  goto errLabel;
@@ -2351,7 +2360,8 @@ namespace cw
           // create a compressor object for each input channel
           for(unsigned i=0; i<srcBuf->chN; ++i)
           {
-            real_t igain, maxWnd_ms, wnd_ms, thresh, ratio, atk_ms, rls_ms, ogain;
+            coeff_t igain, thresh, ratio, ogain;
+            ftime_t maxWnd_ms, wnd_ms, atk_ms, rls_ms;
             bool bypassFl;
 
 
@@ -2406,7 +2416,7 @@ namespace cw
       {
         rc_t    rc   = kOkRC;
         inst_t* inst = (inst_t*)ctx->userPtr;
-        real_t  tmp;
+        ftime_t  tmp;
 
         if( var->chIdx != kAnyChIdx && var->chIdx < inst->cmpN )
         {
@@ -2539,7 +2549,7 @@ namespace cw
           // create a limiter object for each input channel
           for(unsigned i=0; i<srcBuf->chN; ++i)
           {
-            real_t igain, thresh, ogain;
+            coeff_t igain, thresh, ogain;
             bool bypassFl;
 
 
@@ -2589,7 +2599,7 @@ namespace cw
       {
         rc_t    rc   = kOkRC;
         inst_t* inst = (inst_t*)ctx->userPtr;
-        real_t  rtmp;
+        coeff_t  rtmp;
         bool btmp;
 
         if( var->chIdx != kAnyChIdx && var->chIdx < inst->limN )
@@ -2693,8 +2703,8 @@ namespace cw
         rc_t          rc         = kOkRC;
         const abuf_t* abuf       = nullptr; //
         inst_t*       inst       = mem::allocZ<inst_t>();
-        real_t        delayMs    = 0;
-        real_t        maxDelayMs = 0;
+        ftime_t        delayMs    = 0;
+        ftime_t        maxDelayMs = 0;
 
         ctx->userPtr = inst;
 
@@ -2755,7 +2765,7 @@ namespace cw
         rc_t     rc          = kOkRC;
         inst_t*  inst        = (inst_t*)ctx->userPtr;
         abuf_t*  ibuf        = nullptr;
-        real_t   delayMs     = 0;
+        ftime_t   delayMs     = 0;
         unsigned delayFrameN = 0;
         
         if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
@@ -2903,7 +2913,7 @@ namespace cw
           // create a dc_filter object for each input channel
           for(unsigned i=0; i<srcBuf->chN; ++i)
           {
-            real_t gain;
+            coeff_t gain;
             bool bypassFl;
 
 
@@ -2972,7 +2982,7 @@ namespace cw
        
         for(unsigned i=0; i<chN; ++i)
         {
-          real_t gain   = val_get<real_t>( ctx, kGainPId,   i );
+          coeff_t gain   = val_get<coeff_t>( ctx, kGainPId,   i );
           bool bypassFl = val_get<bool>(   ctx, kBypassPId, i );
 
           dsp::dc_filter::set( inst->dcfA[i], gain, bypassFl );
@@ -3059,7 +3069,8 @@ namespace cw
           // create a audio_meter object for each input channel
           for(unsigned i=0; i<srcBuf->chN; ++i)
           {
-            real_t wndMs, peakThreshDb;
+            ftime_t wndMs;
+            coeff_t peakThreshDb;
             bool dbFl;
 	    
             // get the audio_meter variable values
@@ -3080,7 +3091,7 @@ namespace cw
               goto errLabel;
             }
 	    
-            unsigned maxWndMs = std::max(wndMs,1000.0f);
+            unsigned maxWndMs = std::max(wndMs,1000.0);
 	    
             // create the audio_meter instance
             if((rc = dsp::audio_meter::create( inst->mtrA[i], srcBuf->srate, maxWndMs, wndMs, peakThreshDb)) != kOkRC )
@@ -3179,7 +3190,7 @@ namespace cw
 
       typedef struct inst_str
       {
-        real_t mark;
+        sample_t mark;
       } inst_t;
 
       rc_t create( instance_t* ctx )
@@ -3562,8 +3573,694 @@ namespace cw
       };
       
     }    
+
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // sample_hold
+    //
+    namespace sample_hold
+    {
+      enum
+      {
+        kInPId,
+        kPeriodMsPId,
+        kOutPId,
+        kMeanPId,
+      };
+
+      typedef struct inst_str
+      {
+        unsigned chN;            // count of audio input channels and output sample variables.
+        unsigned bufAllocFrmN;   // count of sample frames allocated in the sample buffer
+        unsigned periodFrmN;     // count of sample frames in the sample period
+        unsigned ii;             // next buf[][] frame index to receive an incoming audio sample
+        sample_t** buf;          // buf[chN][bufSmpAllocN]
+      } inst_t;
+
+      unsigned _period_ms_to_smp( srate_t srate, unsigned framesPerCycle, double periodMs )
+      {
+        unsigned frmN =  (unsigned)(srate * periodMs / 1000.0);
+        return std::max(framesPerCycle,frmN);
+      }
+
+      unsigned _period_ms_to_smp( srate_t srate, unsigned framesPerCycle, unsigned bufSmpAllocN, double periodMs )
+      {
+        unsigned frmN = _period_ms_to_smp(srate,framesPerCycle, periodMs );
+        
+        // clip sample period to the max. buffer length.
+        return std::min(bufSmpAllocN,frmN);
+      }
+
+      sample_t _mean( inst_t* p, unsigned chIdx, unsigned oi, unsigned n0, unsigned n1 )
+      {
+        sample_t sum = 0;
+        
+        for(unsigned i=0; i<n0; ++i)
+          sum += p->buf[chIdx][oi + i ];
+        
+        for(unsigned i=0; i<n1; ++i)
+          sum += p->buf[chIdx][i];
+        
+        return n0+n1==0 ? 0 : sum/(n0+n1);
+      }
+
+      void _destroy( inst_t* p )
+      {
+        for(unsigned i=0; i<p->chN; ++i)
+          mem::release(p->buf[i]);
+        mem::release(p->buf);
+        mem::release(p);        
+      }
+      
+      rc_t create( instance_t* ctx )
+      {
+        rc_t          rc       = kOkRC;
+        const abuf_t* abuf     = nullptr; //
+        double        periodMs = 0;
+        
+        ctx->userPtr = mem::allocZ<inst_t>();
+        inst_t* p = (inst_t*)ctx->userPtr;
+
+        // get the source audio buffer
+        if((rc = var_register_and_get(ctx, kAnyChIdx,
+                                      kInPId,       "in",       kBaseSfxId, abuf,
+                                      kPeriodMsPId, "period_ms",kBaseSfxId, periodMs)) != kOkRC )
+        {
+          goto errLabel;
+        }
+        
+        p->chN          = abuf->chN;
+        p->bufAllocFrmN = _period_ms_to_smp( abuf->srate, ctx->ctx->framesPerCycle, periodMs );
+        p->periodFrmN   = p->bufAllocFrmN;
+        p->buf          = mem::allocZ<sample_t*>(abuf->chN);
+
+        for(unsigned i=0; i<abuf->chN; ++i)
+        {
+          p->buf[i] = mem::allocZ<sample_t>(p->bufAllocFrmN);
+          if((rc = var_register_and_set(ctx, i,
+                                        kOutPId,  "out",  kBaseSfxId, 0.0f,
+                                        kMeanPId, "mean", kBaseSfxId, 0.0f)) != kOkRC )
+          {
+            goto errLabel;
+          }
+        }
+
+      errLabel:
+        if(rc != kOkRC )
+          _destroy(p);
+        return rc;
+      }
+
+      rc_t destroy( instance_t* ctx )
+      {
+        inst_t* p = (inst_t*)(ctx->userPtr);
+        _destroy(p);
+        return kOkRC;
+      }
+
+      rc_t value( instance_t* ctx, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        
+        switch( var->vid )
+        {
+          case kPeriodMsPId:
+            {
+              double periodMs;
+              const abuf_t* abuf;
+              inst_t*  p = (inst_t*)(ctx->userPtr);
+                      
+              var_get(ctx,kInPId,kAnyChIdx,abuf);
+              
+              if((rc = var_get(var,periodMs)) == kOkRC )
+              {
+                p->periodFrmN = _period_ms_to_smp( abuf->srate, ctx->ctx->framesPerCycle, p->bufAllocFrmN, periodMs );
+              }
+            }
+            break;
+            
+          default:
+            break;
+            
+        }
+        
+        return rc;
+      }
+
+      rc_t exec( instance_t* ctx )
+      {
+        rc_t          rc   = kOkRC;
+        const abuf_t* ibuf = nullptr;
+        inst_t*       p    = (inst_t*)(ctx->userPtr);
+        unsigned      chN  = 0;
+        unsigned      oi   = 0;
+        unsigned      n0   = 0;
+       unsigned       n1   = 0;
+
+        // get the src buffer
+        if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+          goto errLabel;
+
+        chN = std::min(ibuf->chN,p->chN);
+        
+        // Copy samples into buf.
+        for(unsigned i=0; i<ibuf->chN; ++i)
+        {
+          sample_t* isig = ibuf->buf + i*ibuf->frameN;
+          sample_t* obuf = p->buf[i];
+          unsigned  k = p->ii;
+          
+          for(unsigned j=0; j<ibuf->frameN; ++j)
+          {
+            obuf[k++] = isig[j];
+            if( k>= p->bufAllocFrmN )
+              k -= p->bufAllocFrmN;
+          }
+        }
+
+        // advance the input index
+        p->ii += ibuf->frameN;
+        if( p->ii >= p->bufAllocFrmN )
+          p->ii -= p->bufAllocFrmN;
+
+        
+        // if the sampling buf is in range oi:ii
+        if( p->ii >= p->periodFrmN )
+        {
+          oi = p->ii - p->periodFrmN;
+          n0 = p->ii - oi;
+          n1 = 0;
+        }
+        else // the sampling buf is in two parts: bufAllocN-ii:bufAllocN, 0:ii
+        {
+          oi = p->bufAllocFrmN - (p->periodFrmN - p->ii);
+          n0 = p->bufAllocFrmN - oi;
+          n1 = p->ii;
+        }
+        
+        for(unsigned i=0; i<ibuf->chN; ++i)
+        {
+          // the output is the first sample in the buffer
+          var_set(ctx,kOutPId,i, p->buf[i][oi] );
+
+          if( var_is_a_source(ctx,kMeanPId,i) )
+            var_set(ctx,kMeanPId,i, _mean(p,i,oi,n0,n1));
+        }
+                
+      errLabel:
+        return rc;
+      }
+
+      
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // Number
+    //
+    namespace number
+    {
+      enum {
+        kInPId,
+        kBoolPId,
+        kUIntPId,
+        kIntPId,
+        kFloatPId,
+        kOutPId
+      };
+      
+      typedef struct
+      {
+        bool delta_fl;
+        double value;
+      } inst_t;
+
+
+      rc_t create( instance_t* proc )
+      {
+        rc_t    rc   = kOkRC;        
+        inst_t* p = mem::allocZ<inst_t>();
+        proc->userPtr = p;
+
+        if((rc  = var_register_and_get(proc,kAnyChIdx,
+                                       kInPId,"in",kBaseSfxId,p->value)) != kOkRC )
+        {
+          goto errLabel;
+        }
+        
+        if((rc = var_register_and_set(proc,kAnyChIdx,
+                                      kBoolPId,"bool",kBaseSfxId,p->value != 0,
+                                      kUIntPId,"uint",kBaseSfxId,(unsigned)p->value,
+                                      kIntPId,"int",kBaseSfxId,(int)p->value,
+                                      kFloatPId,"float",kBaseSfxId,(float)p->value,
+                                      kOutPId,"out",kBaseSfxId,p->value )) != kOkRC )
+        {
+          goto errLabel;
+        }
+        
+        p->delta_fl = true;
+
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        rc_t rc = kOkRC;
+
+        inst_t* p = (inst_t*)proc->userPtr;
+        mem::release(p);        
+        return rc;
+      }
+
+      rc_t value( instance_t* proc, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        if( var->vid == kInPId )
+        {
+          double v;
+          if((rc = var_get(var,v)) == kOkRC )
+          {
+            inst_t* p = (inst_t*)proc->userPtr;
+            if( !p->delta_fl )
+              p->delta_fl = v != p->value;
+            p->value    = v;
+            
+          }
+        }
+        return rc;
+      }
+
+      rc_t exec( instance_t* proc )
+      {
+        rc_t rc      = kOkRC;
+        inst_t*  p = (inst_t*)proc->userPtr;
+
+        if( p->delta_fl )
+        {
+          p->delta_fl = false;
+          var_set(proc,kBoolPId,kAnyChIdx,p->value!=0);
+          var_set(proc,kUIntPId,kAnyChIdx,(unsigned)fabs(p->value));
+          var_set(proc,kIntPId,kAnyChIdx,(int)p->value);
+          var_set(proc,kFloatPId,kAnyChIdx,(float)p->value);
+          var_set(proc,kOutPId,kAnyChIdx,p->value);
+        }
+        
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // Timer
+    //
+    namespace timer
+    {
+      enum {
+        kSratePId,
+        kPeriodMsPId,
+        kOutPId,
+      };
+      
+      typedef struct
+      {
+        unsigned periodFrmN;
+        unsigned periodPhase;
+      } inst_t;
+
+      unsigned _period_ms_to_frame_count( instance_t* proc, inst_t* p, srate_t srate, ftime_t periodMs )
+      {
+        return std::max((unsigned)(srate * periodMs / 1000.0), proc->ctx->framesPerCycle);
+      }
+
+      rc_t create( instance_t* proc )
+      {
+        rc_t    rc       = kOkRC;
+        ftime_t  periodMs = 0;
+        srate_t srate    = 0;
+        inst_t* p        = mem::allocZ<inst_t>();
+        proc->userPtr    = p;
+        
+
+        if((rc = var_register_and_get(proc,kAnyChIdx,
+                                      kSratePId,    "srate",    kBaseSfxId,srate,
+                                      kPeriodMsPId, "period_ms",kBaseSfxId,periodMs)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        if((rc = var_register_and_set(proc,kAnyChIdx,
+                                      kOutPId,       "out",     kBaseSfxId,false)) != kOkRC )
+        {
+          goto errLabel;
+        }
+        
+        p->periodFrmN = _period_ms_to_frame_count(proc,p,srate,periodMs);
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        rc_t    rc = kOkRC;
+        inst_t* p  = (inst_t*)proc->userPtr;
+        mem::release(p);        
+        return rc;
+      }
+
+      rc_t value( instance_t* proc, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        switch( var->vid )
+        {
+          case kPeriodMsPId:
+            {
+              double periodMs;
+              srate_t srate;
+              inst_t*  p = (inst_t*)(proc->userPtr);
+                      
+              var_get(proc,kSratePId,kAnyChIdx,srate);
+              
+              if((rc = var_get(var,periodMs)) == kOkRC )
+                p->periodFrmN = _period_ms_to_frame_count( proc, p, srate, periodMs );
+            }
+            break;
+            
+          default:
+            break;
+        }
+        return rc;
+      }
+
+      rc_t exec( instance_t* proc )
+      {
+        rc_t    rc = kOkRC;
+        inst_t* p  = (inst_t*)proc->userPtr;
+
+        p->periodPhase += proc->ctx->framesPerCycle;
+
+        
+        if( p->periodPhase >= p->periodFrmN )
+        {
+          p->periodPhase -= p->periodFrmN;
+          
+          bool val = false;
+          var_get(proc,kOutPId,kAnyChIdx,val);
+
+          //printf("%i %i %i\n",p->periodPhase,p->periodFrmN,val);
+          
+          var_set(proc,kOutPId,kAnyChIdx,!val);
+        }
+        
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
     
     
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // Counter
+    //
+    namespace counter
+    {
+      enum {
+        kTriggerPId,
+        kResetPId,
+        kInitPId,
+        kMinPId,
+        kMaxPId,
+        kIncPId,
+        kRepeatPId,
+        kModePId,
+        kOutPId
+      };
+
+      enum {        
+        kModuloModeId,
+        kReverseModeId,
+        kClipModeId,
+        kInvalidModeId
+      };
+      
+      typedef struct
+      {
+        unsigned mode_id;
+        
+        bool trig_val;
+        bool delta_fl;
+
+        bool reset_val;
+        bool reset_fl;
+
+        bool done_fl;
+
+        double dir;
+        
+      } inst_t;
+
+      idLabelPair_t modeArray[] = {
+        { kModuloModeId, "modulo" },
+        { kReverseModeId, "reverse" },
+        { kClipModeId,    "clip" },
+        { kInvalidId, "<invalid>"}
+      };
+
+
+      unsigned _string_to_mode_id( const char* mode_label, unsigned& mode_id_ref )
+      {
+        rc_t rc = kOkRC;
+        mode_id_ref = kInvalidId;
+        for(unsigned i=0; modeArray[i].id != kInvalidId; ++i)
+          if( textIsEqual(modeArray[i].label,mode_label) )
+          {
+            mode_id_ref = modeArray[i].id;
+            return kOkRC;            
+          }
+        
+        return cwLogError(kInvalidArgRC,"'%s' is not a valid counter 'mode'.",cwStringNullGuard(mode_label));
+      }
+
+      rc_t create( instance_t* proc )
+      {
+        rc_t    rc    = kOkRC;        
+        inst_t* p     = mem::allocZ<inst_t>();
+        proc->userPtr = p;
+        double  init_val;
+        const char* mode_label;
+
+        if((rc = var_register_and_get(proc, kAnyChIdx,
+                                      kTriggerPId, "trigger", kBaseSfxId, p->trig_val,
+                                      kResetPId,   "reset",   kBaseSfxId, p->reset_val,
+                                      kInitPId,    "init",    kBaseSfxId, init_val,
+                                      kModePId,    "mode",    kBaseSfxId, mode_label)) != kOkRC )
+        {
+          goto errLabel;
+        }
+                                      
+        
+        if((rc = var_register(proc, kAnyChIdx,
+                              kMinPId,     "min",     kBaseSfxId,
+                              kMaxPId,     "max",     kBaseSfxId,
+                              kIncPId,     "inc",     kBaseSfxId,
+                              kRepeatPId,  "repeat_fl",  kBaseSfxId)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        if((rc = var_register_and_set(proc,kAnyChIdx,
+                                      kOutPId,"out",kBaseSfxId,init_val)) != kOkRC )
+        {
+          goto errLabel;
+        }
+                                      
+
+        if((rc = _string_to_mode_id(mode_label,p->mode_id)) != kOkRC )
+          goto errLabel;
+        
+        p->dir = 1.0;
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        rc_t rc = kOkRC;
+
+        inst_t* p = (inst_t*)proc->userPtr;
+        mem::release(p);
+        
+        return rc;
+      }
+
+      rc_t value( instance_t* proc, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        inst_t* p = (inst_t*)proc->userPtr;
+
+        switch( var->vid )
+        {
+          case kTriggerPId:
+            {
+              bool v;
+              
+              if((rc = var_get(var,v)) == kOkRC )
+              {
+                if( !p->delta_fl )
+                  p->delta_fl = p->trig_val != v;
+                
+                p->trig_val = v;            
+              }
+            }
+            break;
+
+          case kModePId:
+            {
+              const char* s;
+              if((rc = var_get(var,s)) == kOkRC )
+                rc = _string_to_mode_id(s,p->mode_id);
+            }
+            break;
+              
+        }
+        
+        return rc;
+      }
+
+      rc_t exec( instance_t* proc )
+      {
+        rc_t rc      = kOkRC;
+        inst_t* p = (inst_t*)proc->userPtr;
+
+        
+        bool v;
+        if((rc = var_get(proc,kTriggerPId,kAnyChIdx,v)) != kOkRC )
+        {
+          cwLogError(rc,"Fail!");
+          goto errLabel;
+        }
+
+        p->delta_fl = v != p->trig_val;
+        p->trig_val = v;
+
+        if( p->delta_fl )
+        {
+          p->delta_fl = false;
+          
+          double cnt,inc,minv,maxv;
+          var_get(proc,kOutPId,kAnyChIdx,cnt);
+          var_get(proc,kIncPId,kAnyChIdx,inc);
+          var_get(proc,kMinPId,kAnyChIdx,minv);
+          var_get(proc,kMaxPId,kAnyChIdx,maxv);
+
+          double incr = p->dir * inc;
+          cnt += incr;
+
+          if( minv > cnt || cnt > maxv )
+          {
+            bool repeat_fl;
+            var_get(proc,kRepeatPId,kAnyChIdx,repeat_fl);
+
+            if( !repeat_fl )
+              p->done_fl = true;
+            else
+            {
+              if( cnt > maxv)
+              {
+                switch( p->mode_id )
+                {
+                  case kModuloModeId:
+                    cnt -= (maxv-minv) + incr;
+                    break;
+
+                  case kReverseModeId:
+                    p->dir = -1 * p->dir;
+                    cnt = maxv - (cnt - maxv);
+                    break;
+
+                  case kClipModeId:
+                    cnt = maxv;
+                    break;
+
+                  default:
+                    assert(0);
+                    
+                }
+              }
+
+              if( cnt < minv)
+              {
+                switch( p->mode_id )
+                {
+                  case kModuloModeId:
+                    cnt += (maxv - minv) + incr;
+                    break;
+                    
+                  case kReverseModeId:
+                    p->dir = -1 * p->dir;
+                    cnt = minv + (minv-cnt);
+                    break;
+                    
+                  case kClipModeId:
+                    cnt = minv;
+                    break;
+                    
+                  default:
+                    assert(0);
+                }                
+              }
+            }
+          }
+
+          if( !p->done_fl )
+          {
+            printf("cnt:%f\n",cnt);
+            var_set(proc,kOutPId,kAnyChIdx,cnt);
+          }
+        }
+
+      errLabel:
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
+    
   } // flow
 } // cw
 
diff --git a/cwFlowProc.h b/cwFlowProc.h
index 3898cb1..d09b0e0 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -27,5 +27,10 @@ namespace cw
     namespace audio_marker    { extern class_members_t members;  }
     namespace xfade_ctl       { extern class_members_t members;  }
     namespace poly_mixer      { extern class_members_t members;  }
+    namespace sample_hold     { extern class_members_t members;  }
+    namespace number          { extern class_members_t members;  }
+    namespace timer           { extern class_members_t members;  }
+    namespace counter         { extern class_members_t members;  }
+    
   }
 }

From e2a307c2accf16870bb1fd392f30139ad6026b6a Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:09:45 -0400
Subject: [PATCH 031/101] cwIoPresetSelApp.cpp : Changes to reflect new
 cwDspTypes.

---
 cwIoPresetSelApp.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/cwIoPresetSelApp.cpp b/cwIoPresetSelApp.cpp
index ca18f98..64227e3 100644
--- a/cwIoPresetSelApp.cpp
+++ b/cwIoPresetSelApp.cpp
@@ -983,9 +983,9 @@ namespace cw
         // apply the fragment defined gain settings
         if( app->ioFlowH.isValid() )
         {
-          io_flow::set_variable_value( app->ioFlowH, flow_cross::kNextDestId, "wet_in_gain", "gain", flow::kAnyChIdx, (dsp::real_t)frag->igain );
-          io_flow::set_variable_value( app->ioFlowH, flow_cross::kNextDestId, "wet_out_gain","gain", flow::kAnyChIdx, (dsp::real_t)frag->ogain );
-          io_flow::set_variable_value( app->ioFlowH, flow_cross::kNextDestId, "wd_bal",      "in",   flow::kAnyChIdx, (dsp::real_t)frag->wetDryGain );
+          io_flow::set_variable_value( app->ioFlowH, flow_cross::kNextDestId, "wet_in_gain", "gain", flow::kAnyChIdx, (dsp::coeff_t)frag->igain );
+          io_flow::set_variable_value( app->ioFlowH, flow_cross::kNextDestId, "wet_out_gain","gain", flow::kAnyChIdx, (dsp::coeff_t)frag->ogain );
+          io_flow::set_variable_value( app->ioFlowH, flow_cross::kNextDestId, "wd_bal",      "in",   flow::kAnyChIdx, (dsp::coeff_t)frag->wetDryGain );
 
           // activate the cross-fade
           io_flow::begin_cross_fade( app->ioFlowH, frag->fadeOutMs );
@@ -2848,7 +2848,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
       else
       {
         if( app->ioFlowH.isValid() )
-          if((rc = io_flow::set_variable_value( app->ioFlowH, flow_cross::kAllDestId, inst_label,  var_label,    flow::kAnyChIdx, (dsp::real_t)value )) != kOkRC )
+          if((rc = io_flow::set_variable_value( app->ioFlowH, flow_cross::kAllDestId, inst_label,  var_label,    flow::kAnyChIdx, (dsp::coeff_t)value )) != kOkRC )
             rc = cwLogError(rc,"Master value send failed on %s.%s.",cwStringNullGuard(inst_label),cwStringNullGuard(var_label));
       }
       return rc;
@@ -2943,7 +2943,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
       }
 
       if( m.value->tid == ui::kDoubleTId && app->ioFlowH.isValid() )
-        rc = io_flow::set_variable_value( app->ioFlowH, flow_cross::kAllDestId, "sd",  var_label,    flow::kAnyChIdx, (dsp::real_t)m.value->u.d );
+        rc = io_flow::set_variable_value( app->ioFlowH, flow_cross::kAllDestId, "sd",  var_label,    flow::kAnyChIdx, (dsp::coeff_t)m.value->u.d );
 
       if(rc != kOkRC )
         rc = cwLogError(rc,"Attempt to set a spec-dist variable '%s'",var_label );
@@ -2954,7 +2954,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
     rc_t _on_live_midi_checkbox( app_t* app, bool useLiveMidiFl )
     {
       rc_t rc = kOkRC;
-      dsp::real_t value;
+      dsp::ftime_t value;
       
       if( useLiveMidiFl )
       {
@@ -2974,7 +2974,7 @@ rc_t _on_ui_play_loc(app_t* app, unsigned appId, unsigned loc);
       }
 
       if( app->ioFlowH.isValid() )
-        if((rc = io_flow::set_variable_value( app->ioFlowH, flow_cross::kAllDestId, "sync_delay",  "delayMs",    flow::kAnyChIdx, (dsp::real_t)value )) != kOkRC )
+        if((rc = io_flow::set_variable_value( app->ioFlowH, flow_cross::kAllDestId, "sync_delay",  "delayMs",    flow::kAnyChIdx, (dsp::ftime_t)value )) != kOkRC )
           rc = cwLogError(rc,"Error setting sync delay 'flow' value.");
       
       

From 964df1dc23346950f9859d6c79a325ba86225279 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:12:18 -0400
Subject: [PATCH 032/101] cwFlowNet.cpp : Minor changes to reflect changed
 function names - is_connected_to_source_proc().

---
 cwFlowNet.cpp | 33 +++++++++++----------------------
 1 file changed, 11 insertions(+), 22 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index 19be4ec..1a4c5e2 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -147,7 +147,7 @@ namespace cw
     void _complete_input_connections( instance_t* inst )
     {
       for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
-        if(var->chIdx == kAnyChIdx && is_connected_to_external_proc(var) )
+        if(var->chIdx == kAnyChIdx && is_connected_to_source_proc(var) )
         {
 
           variable_t* base_src_var = var->src_var;
@@ -238,6 +238,9 @@ namespace cw
       {
         const object_t* value       = preset_cfg->child_ele(i)->pair_value();
         const char*     value_label = preset_cfg->child_ele(i)->pair_label();
+
+        //cwLogInfo("variable:%s",value_label);
+        
         if((rc = _var_channelize( inst, preset_label, type_src_label, value_label, value )) != kOkRC )
           goto errLabel;
         
@@ -1285,14 +1288,12 @@ namespace cw
               goto errLabel;
             }
           }
-        }
-        
+        }        
       }
 
     errLabel:
       
-      return rc;
-      
+      return rc;      
     }
 
     bool _is_var_inst_already_created( const char* var_label, const proc_inst_parse_state_t& pstate )
@@ -1368,7 +1369,7 @@ namespace cw
             goto errLabel;
           }
 
-          // locate source value
+          // locate source variable
           if((rc = var_find( src_proc, src_var_label, src_var_sfx_id, kAnyChIdx, src_var)) != kOkRC )
           {
             rc = cwLogError(rc,"The src-var '%s:i' was not found.", in_stmt.src_var_ele.label, src_var_sfx_id);
@@ -1567,11 +1568,13 @@ namespace cw
       // All the class presets values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
-      // Apply the proc instance preset values.
+      // Apply the proc instance 'args:{}' values.
       if( pstate.arg_cfg != nullptr )
+      {
         if((rc = _proc_inst_args_channelize_vars( inst, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
           goto errLabel;
-
+      }
+      
       // All the instance arg values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
@@ -1608,20 +1611,6 @@ namespace cw
       
       inst_ref = inst;
       
-      /*
-      // insert an instance in the network
-      if( net.network_tail == nullptr )
-      {
-        net.network_head = inst;
-        net.network_tail = inst;
-      }
-      else
-      {
-        net.network_tail->link = inst;
-        net.network_tail       = inst;
-      }      
-      */
-      
     errLabel:
       if( rc != kOkRC )
         _destroy_inst(inst);

From 2437a7453988e9d13ceda4e31637bface50a5e01 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:12:45 -0400
Subject: [PATCH 033/101] flow_doc.md : initial commit.

---
 flow/flow_doc.md | 192 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 192 insertions(+)
 create mode 100644 flow/flow_doc.md

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
new file mode 100644
index 0000000..45eac60
--- /dev/null
+++ b/flow/flow_doc.md
@@ -0,0 +1,192 @@
+
+
+
+# Flow Documentation:
+
+Flow is an audio processing framework that is designed to 
+facilitate the specification of real-time and non-real-time music 
+and audio processing networks and the application of network state data. 
+
+
+
+
+
+
+## Building Neworks:
+
+
+### A Simple Network.
+```
+```
+
+
+
+### Polyphonic Network.
+
+3. Network with sub-nets.
+
+
+## Processing Unit Class
+
+type   | Description
+-------|-------------------------------------
+string | 
+bool   |
+int    | `int32_t`
+uint   | `uint32_t`
+float  | f32
+double | f64
+srate  | (float) Sample rate type
+sample | (float) Audio sample type
+coeff  | (float) Value that will be directly applied to a sample value (e.g added or multiplied)
+ftime  | (double) Fractional seconds
+
+See list in cwFlowTypes.cpp : typeLabelFlagsA[]
+
+
+### Processing Units (proc)
+
+A 'process' or **proc** is a set of functions and **variables**.
+
+A **network** is a set of proc's with interconnected variable.
+By default most proc variables can be connected to, or act as sources for,
+other proc variables.  A variable consists of a label, a type (e.g. int,real,audio,...),
+some attribtes (more about those below), a default value, and a documentation string. 
+
+One of the goals of 'flow' is to naturally handle multi-channel audio signals.
+To this end many audio processors create multiple internal sub-processes
+to handle each audio channel based on the number of input audio channels.
+
+For example an audio gain processor consists of three variables: an input audio variable,
+an output audio variable and a gain coefficient. When the gain unit is
+created it will create an independent sub-process to handle each channel.
+If the input audio signal has multiple channels than the gain processor
+will internally duplicate each of the three variables. This allows
+independent control of the gain of each of the audio channels.
+In 'flow' parlance each of the sub-processes is referred to as a **channel**.
+A variable that can duplicated in this way is referred to as a **multi-channel variable**.
+
+'flow' has a second form of variable multiplicity. This form occurs when
+a variable is duplicated based on how it is connected in the network.
+For example a simple audio mixer might have an undefined number of audio inputs
+and a single audio output. The number of audio inputs is only defined
+once it is connected in the network.  This notion of variable multiplicity
+is different from a **channel** because each of the incoming audio
+signals may themselves contain multiple channels - each of which should
+be individually addressable.  However, it should also be possible
+to address each of the incoming signals as a single entity. To
+accomplish this we use the concept of the **mult-variable**. A mult-variable
+amounts to creating an array of variables based on a single variable description,
+where the array length is determined at network compile time. mult-variables
+are distinguished by labels with integer suffixes.
+
+
+
+
+
+
+
+
+The functions are:
+
+Name     | Description
+---------|------------------------------------------------------------------------
+create   | Implements the custom elements of the proc instantiation.
+destroy  | Destroy resources that were acquired in create().
+value    | Variable values will pass through this function as they are assigned.
+exec     | Implements the custom execution functionality of this process.
+report   | Print the state of the process.
+
+
+
+
+
+
+
+### Var Syntax
+
+__label__ : { type: __type__, value: __value__, doc:"q-string" }
+
+Part   | Description
+-------|-------------------------------------------------------
+label  | Variable name
+type   | Variable type.  See Data types below.
+value  | The default value of the variable.
+doc    | Documentation string for this variable.
+
+Notes:
+
+- Whenever possible default values should be provided for the
+variable - even if the value is meaningless - like 0.0.  This is
+important because during proc instantiation, prior to the custom
+create() call, variables listed in the proc instance's 'in' statement
+are connected to their respective sources.  If the source does not
+have a valid value then the instantiation will fail.  This consitutes
+a failure because it is guaranteed that when the custom create()
+function is called all variables in the 'in' statement will be
+resolved to a source variable with a valid value.  This allows the
+proc instance to have the information it needs to configure itself.
+
+There is one subtle case where the default value becomes important. When the
+variables in an 'in' statement are initially connected to their source they are
+connected to the 'any-channel' source variable because they
+do not have a specific channel yet.  Specific channel can only be known
+during or after the custom create() function is called.  Since the way
+a given proc. distributes channels will vary from one proc. to the
+next.
+
+If during initial variable connection the source happens to be a
+variable with channels then the values that were assigned to those
+channels, in the source proc. create() function, will not show up on
+the 'any-channel'.  If no default value was assigned to the source
+variable then the 'any-channel' will have no value, and the connection
+will fail with an error message like this: 
+
+```
+"The source value is null on the connection input:foo:0 source:blah:0.bar:0".
+```
+
+Note that although variables are initially connected to the
+'any-channel' source variable, prior to the their proc's create() call,
+after the create() call, when the variables do have a valid channel
+number, they are reconnected to a specific channel on the source
+variable.
+
+
+### Preset Syntax:
+
+
+### Data Types:
+
+Types    | Description             |
+---------|-------------------------|
+bool     | `bool`
+int      | `int32_t`
+uint     | `uint32_t`
+real     | `double`
+audio    | multi-channel audio
+spectrum | multi-channel spectrum
+
+### Variable Flags:
+
+Flag             | Description
+-----------------|-------------------------------------------------------------------------------------------
+`init`           | This variale is set at proc instantation and never changes.
+`src`            | This variable must be connect to a source variable in the instance 'in' statement or be set to a default value. See 1.
+`no_src`         | This variable may not be connected to a source variable. See 1.
+`no_dflt_create` | This variable is not created automatically as part of the proc instantiation. See 2.
+`mult`           | This variable may be duplicated in the instance 'in' statement. See 3.
+
+
+Notes:
+1. Unless the `no_src` attribute is set any variable may be connected to a source variable
+in the proc instantation 'in' statement.
+
+2. By default all variables are created prior to the proc `create()` function being called.
+Variable with the `no_dflt_create` attribute will not be created.  This is useful in cases
+where information needs to be accessed in the `create()` function in order to determine
+some basic parameters of the variable  For example a proc that needs to create multiple output
+variables based on the number of input audio channels cannot know how many output variables
+it may need until it accesses the number of audio channels it has been instantiated with.
+
+

From 6c65dec3c79c8f6b8dee6cdcbebcda7f51818e36 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:13:00 -0400
Subject: [PATCH 034/101] README.md : Updates.

---
 README.md | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4a0dae4..85e121e 100644
--- a/README.md
+++ b/README.md
@@ -845,7 +845,7 @@ In otherwords setting 'proc-sfx-id' to kInvalidId is not
 resolvable without more information.
 
    
-
+   
 
 ### TODO:
 
@@ -872,4 +872,18 @@ ports of the internal elements.
 
 - Reduce runtime over head for var get/set operations.
 
+- enforce var attributes 
 
+- Allow multiple types on an input.
+   For example 'adder' should have a single input 
+   which can by any numeric type.
+   
+- Allow min/max values on numeric variables.
+
+- Make a standard way to turn on output printing from any port on any instance
+This might be a better approach to logging than having a 'printer' object.
+Add proc instance field: `log:[ var_label_0, var_label_1 ] `
+
+- The 'poly' frawework is not quite complete. 
+
+- 

From 6e3b59adb61e7bed5a839eab5628b96127ec4ecf Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:44:33 -0400
Subject: [PATCH 035/101] cwFlowProc.cpp : Fix bugs in 'counter'.

---
 cwFlowProc.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index b55993c..2e32245 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -4198,12 +4198,12 @@ namespace cw
                 switch( p->mode_id )
                 {
                   case kModuloModeId:
-                    cnt -= (maxv-minv) + incr;
+                    cnt = minv + (cnt-maxv);
                     break;
 
                   case kReverseModeId:
                     p->dir = -1 * p->dir;
-                    cnt = maxv - (cnt - maxv);
+                    cnt = maxv - (cnt-maxv);
                     break;
 
                   case kClipModeId:
@@ -4221,7 +4221,7 @@ namespace cw
                 switch( p->mode_id )
                 {
                   case kModuloModeId:
-                    cnt += (maxv - minv) + incr;
+                    cnt = maxv - (minv-cnt);
                     break;
                     
                   case kReverseModeId:

From 95ae6d0525f566f5a6f75dabe32d5fc733dc14cc Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:45:12 -0400
Subject: [PATCH 036/101] README.md : Updates.

---
 README.md | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 85e121e..99611e6 100644
--- a/README.md
+++ b/README.md
@@ -850,6 +850,10 @@ resolvable without more information.
 ### TODO:
 
 - Documentation w/ examples.
+  + Write the rules for each member function.
+    
+- value() should return a special return-code value to indicate that the
+value should not be updated.
 
 - Compile presets: at load time the presets should be resolved
   to the proc and vars to which they will be assigned.
@@ -858,6 +862,8 @@ resolvable without more information.
 
 - Variable attributes should be meaningful. e.g. src,src_opt,mult,init, ....
   Should we check for 'src' or 'mult' attribute on var's?
+  
+- Enforce var attributes.
 
 - DONE: 'poly' should be implemented as a proc-inst with an internal network - but the 
 elements of the network should be visible outside of it.
@@ -867,12 +873,11 @@ elements of the network should not be visible outside of it. Instead it should
 include the idea of input and output ports which act as proxies to the physical
 ports of the internal elements.
 
-- 'poly' and 'sub' should be arbitrarily nestable. 
+- 'poly' and 'sub' should be arbitrarily nestable. DONE?
 
 
 - Reduce runtime over head for var get/set operations.
 
-- enforce var attributes 
 
 - Allow multiple types on an input.
    For example 'adder' should have a single input 
@@ -882,8 +887,13 @@ ports of the internal elements.
 
 - Make a standard way to turn on output printing from any port on any instance
 This might be a better approach to logging than having a 'printer' object.
-Add proc instance field: `log:[ var_label_0, var_label_1 ] `
+Add proc instance field: `log:{ var_label_0:0, var_label_1:0 } `
 
-- The 'poly' frawework is not quite complete. 
 
-- 
+Next:
+
+- Implement 'preset' proc. This will involve implementing the 'cfg' datatype.
+
+- Finish the 'poly' frawework. We are making 'mult' var's, but do any of the procs explicitly deal with them?
+
+- Turn on variable 'broadcast'.  Why was it turned off? ... maybe multiple updates?

From c7cd952fcccd6aa5fd506b95bab79f7aa00bde8c Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 26 Apr 2024 17:47:34 -0400
Subject: [PATCH 037/101] cwFlowProc.cpp : More counter improvements.

---
 cwFlowProc.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 2e32245..a0695b0 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -4198,12 +4198,14 @@ namespace cw
                 switch( p->mode_id )
                 {
                   case kModuloModeId:
-                    cnt = minv + (cnt-maxv);
+                    while(cnt > maxv )
+                      cnt = minv + (cnt-maxv);
                     break;
 
                   case kReverseModeId:
                     p->dir = -1 * p->dir;
-                    cnt = maxv - (cnt-maxv);
+                    while( cnt > maxv )
+                      cnt = maxv - (cnt-maxv);
                     break;
 
                   case kClipModeId:
@@ -4221,12 +4223,14 @@ namespace cw
                 switch( p->mode_id )
                 {
                   case kModuloModeId:
-                    cnt = maxv - (minv-cnt);
+                    while( cnt < minv )
+                      cnt = maxv - (minv-cnt);
                     break;
                     
                   case kReverseModeId:
                     p->dir = -1 * p->dir;
-                    cnt = minv + (minv-cnt);
+                    while(cnt < minv )
+                      cnt = minv + (minv-cnt);
                     break;
                     
                   case kClipModeId:

From 4b08aeabde536de0526331e2ff0c244f334c400f Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Tue, 30 Apr 2024 19:52:13 -0400
Subject: [PATCH 038/101] cwObject.h : Added is_<numric_type> predicate
 functions.

---
 cwObject.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/cwObject.h b/cwObject.h
index e86bc12..494b17c 100644
--- a/cwObject.h
+++ b/cwObject.h
@@ -141,6 +141,11 @@ namespace cw
     inline bool is_dict()      const { return type != nullptr && type->id == kDictTId; }
     inline bool is_list()      const { return type != nullptr && type->id == kListTId; }
     inline bool is_string()    const { return type != nullptr && (type->id == kStringTId || type->id == kCStringTId); }
+    inline bool is_unsigned_integer() const { return type->id==kCharTId || type->id==kUInt8TId || type->id==kUInt16TId || type->id==kUInt32TId || type->id==kUInt64TId; }
+    inline bool is_signed_integer()   const { return                   type->id==kInt8TId  || type->id==kInt16TId  || type->id==kInt32TId  || type->id==kInt64TId;  }
+    inline bool is_floating_point()   const { return type->id==kFloatTId || type->id==kDoubleTId; }
+    inline bool is_integer()          const { return is_unsigned_integer() || is_signed_integer(); }
+    inline bool is_numeric()          const { return is_integer() || is_floating_point(); }
     inline bool is_type( unsigned tid ) const { return type != nullptr && type->id == tid; }
 
     rc_t value( void* dst, unsigned dstTypeId );

From 4619fc43a1c1d7c087158a02393ad50a7cec12ad Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Tue, 30 Apr 2024 19:52:40 -0400
Subject: [PATCH 039/101] cwMath.cpp : Fixed isPowerOfTwo() to recognize 1 as a
 power of 2.

---
 cwMath.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwMath.cpp b/cwMath.cpp
index 9f855d3..d5a737a 100644
--- a/cwMath.cpp
+++ b/cwMath.cpp
@@ -93,7 +93,7 @@ void cw::math::doubleToX80(double val, unsigned char rate[10])
 
 bool		cw::math::isPowerOfTwo( unsigned x )
 {
-  return !( (x < 2) || (x & (x-1)) );
+  return x==1 || (!( (x < 2) || (x & (x-1)) ));
 }
 
 unsigned 	cw::math::nextPowerOfTwo(	unsigned val )

From b57693f4e4f71813d5701367f13096214a1d5d72 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Tue, 30 Apr 2024 19:58:10 -0400
Subject: [PATCH 040/101] cwFlow,cwFlowNet,cwFlowTypes,cwFlowProc : Many
 changes. Added ability to set types at proc instantiation time. Added ability
 to have multi-type variables which get resolved at proc. instantiation time.
 Added ability to proc 'log' attribute to print selected variables as they
 change. Values are now coerced to the variable type in var_set(). Added new
 proc's : list,add,preset.

---
 cwFlow.cpp       |   9 +-
 cwFlowNet.cpp    | 138 +++++--
 cwFlowProc.cpp   | 859 ++++++++++++++++++++++++++++++++++-------
 cwFlowProc.h     |   7 +-
 cwFlowTypes.cpp  | 965 +++++++++++++++++++++++++++++++++++++----------
 cwFlowTypes.h    | 143 ++++---
 flow/flow_doc.md |  38 +-
 7 files changed, 1745 insertions(+), 414 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index cdea341..078ff79 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -34,8 +34,8 @@ namespace cw
       { "midi_out",        &midi_out::members },
       { "audio_in",        &audio_in::members },
       { "audio_out",       &audio_out::members },
-      { "audioFileIn",     &audioFileIn::members },
-      { "audioFileOut",    &audioFileOut::members },
+      { "audio_file_in",   &audio_file_in::members },
+      { "audio_file_out",  &audio_file_out::members },
       { "audio_gain",      &audio_gain::members },
       { "audio_split",     &audio_split::members },
       { "audio_duplicate", &audio_duplicate::members },
@@ -58,6 +58,9 @@ namespace cw
       { "number",          &number::members },
       { "timer",           &timer::members },
       { "counter",         &counter::members },
+      { "list",            &list::members },
+      { "add",             &add::members },
+      { "preset",          &preset::members },
       { nullptr, nullptr }
     };
 
@@ -621,7 +624,7 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
   // find the user requested test case
   if((test_cfg = test_cases_cfg->find_child(argv[1])) == nullptr )
   {
-    rc = cwLogError(kInvalidArgRC,"The test case named '%s' was not found.",argv[0]);
+    rc = cwLogError(kInvalidArgRC,"The test case named '%s' was not found.",argv[1]);
     goto errLabel;
   }  
 
diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index 1a4c5e2..01f2cd8 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -66,8 +66,10 @@ namespace cw
     void _connect_vars( variable_t* src_var, variable_t* in_var )
     {
       // connect in_var into src_var's outgoing var chain
-      in_var->connect_link  = src_var->connect_link;
-      src_var->connect_link = in_var;
+      in_var->dst_link  = src_var->dst_tail;
+      src_var->dst_tail = in_var;
+      if( src_var->dst_head == nullptr )
+        src_var->dst_head = in_var;
 
       assert( src_var->value != nullptr );
           
@@ -171,7 +173,42 @@ namespace cw
           }
         }
     }
-    
+
+    rc_t _set_log_flags(instance_t* proc, const object_t* log_labels)
+    {
+      rc_t rc = kOkRC;
+      
+      if( log_labels == nullptr )
+        return rc;
+
+      if( !log_labels->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The log spec on '%s:%i' is not a dictionary.",cwStringNullGuard(proc->label),proc->label_sfx_id);
+        goto errLabel;
+      }
+
+      for(unsigned i=0; i<log_labels->child_count(); ++i)
+      {
+        const object_t* pair;
+        unsigned sfx_id;
+        
+        if((pair = log_labels->child_ele(i)) == nullptr || pair->pair_label()==nullptr || pair->pair_value()==nullptr || (rc=pair->pair_value()->value(sfx_id))!=kOkRC )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Syntax error on log var identifier.");
+          goto errLabel;
+        }
+
+        if((rc = var_set_flags( proc, kAnyChIdx, pair->pair_label(), sfx_id, kLogVarFl )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to set var flags on '%s:%i' var:'%s:%i'.",cwStringNullGuard(proc->label),proc->label_sfx_id,pair->pair_label(),sfx_id);
+          goto errLabel;          
+        }
+      }
+
+    errLabel:
+      return rc;
+    }
+
     rc_t _call_value_func_on_all_variables( instance_t* inst )
     {
       rc_t rc  = kOkRC;
@@ -181,40 +218,49 @@ namespace cw
         if( inst->varMapA[i] != nullptr && inst->varMapA[i]->vid != kInvalidId )
         {
           variable_t* var = inst->varMapA[i];
-          
-          if((rc = var->inst->class_desc->members->value( var->inst, var )) != kOkRC )
+
+          if((rc = var_call_custom_value_func( var )) != kOkRC )
             rc1 = cwLogError(rc,"The proc instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->inst->label, var->inst->label_sfx_id, var->label, var->chIdx );
         }
       
       return rc1;
     }
 
-    rc_t _var_channelize( instance_t* inst, const char* preset_label,  const char* type_src_label, const char* value_label, const object_t* value )
+    rc_t _var_channelize( instance_t* inst, const char* preset_label,  const char* type_src_label, const char* var_label, const object_t* value )
     {
       rc_t rc = kOkRC;
       
-      variable_t*     dummy       = nullptr;
+      variable_t* dummy = nullptr;
+      var_desc_t* vd    = nullptr;
 
       // verify that a valid value exists
       if( value == nullptr )
       {
-        rc = cwLogError(kSyntaxErrorRC,"Unexpected missig value on %s preset '%s' instance '%s' variable '%s'.", type_src_label, preset_label, inst->label, cwStringNullGuard(value_label) );
+        rc = cwLogError(kSyntaxErrorRC,"Unexpected missig value on %s preset '%s' instance '%s' variable '%s'.", type_src_label, preset_label, inst->label, cwStringNullGuard(var_label) );
         goto errLabel;
       }
-
-      // if a list of values was given
-      if( value->is_list() )
+      else
       {
-        for(unsigned chIdx=0; chIdx<value->child_count(); ++chIdx)
-          if((rc = var_channelize( inst, value_label, kBaseSfxId, chIdx, value->child_ele(chIdx), kInvalidId, dummy )) != kOkRC )
-            goto errLabel;
-      }
-      else // otherwise a single value was given
-      {          
-        if((rc = var_channelize( inst, value_label, kBaseSfxId, kAnyChIdx, value, kInvalidId, dummy )) != kOkRC )
-          goto errLabel;
-      }
+        bool is_var_cfg_type_fl = (vd = var_desc_find( inst->class_desc, var_label ))!=nullptr && cwIsFlag(vd->type,kCfgTFl);
+        bool is_list_fl         = value->is_list();
+        bool is_list_of_list_fl = is_list_fl && value->child_count() > 0 && value->child_ele(0)->is_list();
+        bool parse_list_fl      = (is_list_fl && !is_var_cfg_type_fl) || (is_list_of_list_fl && is_var_cfg_type_fl);
 
+        // if a list of values was given and the var type is not a 'cfg' type or if a list of lists was given
+        if( parse_list_fl )
+        {
+          // then each value in the list is assigned to the associated channel
+          for(unsigned chIdx=0; chIdx<value->child_count(); ++chIdx)
+            if((rc = var_channelize( inst, var_label, kBaseSfxId, chIdx, value->child_ele(chIdx), kInvalidId, dummy )) != kOkRC )
+              goto errLabel;
+        }
+        else // otherwise a single value was given
+        {          
+          if((rc = var_channelize( inst, var_label, kBaseSfxId, kAnyChIdx, value, kInvalidId, dummy )) != kOkRC )
+            goto errLabel;
+        }
+      }
+        
     errLabel:
       return rc;
     }
@@ -236,12 +282,12 @@ namespace cw
       // for each preset variable
       for(unsigned i=0; i<preset_cfg->child_count(); ++i)
       {
-        const object_t* value       = preset_cfg->child_ele(i)->pair_value();
-        const char*     value_label = preset_cfg->child_ele(i)->pair_label();
+        const object_t* value     = preset_cfg->child_ele(i)->pair_value();
+        const char*     var_label = preset_cfg->child_ele(i)->pair_label();
 
         //cwLogInfo("variable:%s",value_label);
         
-        if((rc = _var_channelize( inst, preset_label, type_src_label, value_label, value )) != kOkRC )
+        if((rc = _var_channelize( inst, preset_label, type_src_label, var_label, value )) != kOkRC )
           goto errLabel;
         
         
@@ -707,6 +753,7 @@ namespace cw
       const char*     arg_label;        //
       const object_t* preset_labels;    //
       const object_t* arg_cfg;          //
+      const object_t* log_labels;       // 
       const object_t* in_dict;          // cfg. node to the in-list
       in_stmt_t*      in_array;         // in_array[ in_arrayN ] in-stmt array
       unsigned        in_arrayN;        // count of in-stmt's in the in-list.
@@ -1253,9 +1300,16 @@ namespace cw
       {
         in_stmt_t&      in_stmt          = pstate.in_array[i];
         const object_t* in_pair          = pstate.in_dict->child_ele(i); // in:src pair
-        const char*     in_var_str       = in_pair->pair_label(); // 'in' var string
+        const char*     in_var_str       = nullptr;
         const char*     src_proc_var_str = nullptr;
 
+        // validate the basic syntax
+        if( in_pair == nullptr || (in_var_str = in_pair->pair_label()) == nullptr || in_pair->pair_value()==nullptr )
+        {
+          cwLogError(rc,"Malformed dictionary encountered in 'in' statement.");
+          goto errLabel;
+        }
+
         // get the src net/proc/var string
         if((rc = in_pair->pair_value()->value(src_proc_var_str)) != kOkRC )
         {
@@ -1282,6 +1336,7 @@ namespace cw
                                  kInvalidId,
                                  kAnyChIdx,
                                  in_stmt.in_var_desc->val_cfg,
+                                 kInvalidTFl,
                                  dum )) != kOkRC )
             {
               rc = cwLogError(rc,"in-stmt var create failed on '%s:%s'.",cwStringNullGuard(in_var_str),cwStringNullGuard(src_proc_var_str));
@@ -1432,9 +1487,10 @@ namespace cw
       
       // parse the optional args
       if((rc = proc_inst_cfg->pair_value()->getv_opt("args",     arg_dict,
-                                                "in",       pstate.in_dict,
-                                                "argLabel", pstate.arg_label,
-                                                "preset",   pstate.preset_labels)) != kOkRC )
+                                                     "in",       pstate.in_dict,
+                                                     "argLabel", pstate.arg_label,
+                                                     "preset",   pstate.preset_labels,
+                                                     "log",      pstate.log_labels )) != kOkRC )
       {
         rc = cwLogError(kSyntaxErrorRC,"The instance cfg. '%s' missing: 'type'.",pstate.inst_label);
         goto errLabel;        
@@ -1550,16 +1606,16 @@ namespace cw
 
       // Instantiate all the variables in the class description - that were not already created in _parse_in_list()
       for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
-        if( !_is_var_inst_already_created( vd->label, pstate ) )
+        if( !_is_var_inst_already_created( vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
         {
           variable_t* var = nullptr;        
-          if((rc = var_create( inst, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, var )) != kOkRC )
+          if((rc = var_create( inst, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, kInvalidTFl, var )) != kOkRC )
             goto errLabel;
         }
 
       // All the variables that can be used by this instance have now been created
       // and the chIdx of each variable is set to 'any'.
-
+      
       // If a 'preset' field was included in the class cfg then apply the specified class preset
       if( pstate.preset_labels != nullptr )      
         if((rc = _class_apply_presets(inst, pstate.preset_labels )) != kOkRC )
@@ -1584,36 +1640,52 @@ namespace cw
       // Connect the in-list variables to their sources.
       if((rc = _connect_in_vars(net, inst, pstate)) != kOkRC )
       {
-        rc = cwLogError(rc,"Creation of the proc instance '%s:%i' failed during input connection processing.",cwStringNullGuard(inst->label),inst->label_sfx_id);
+        rc = cwLogError(rc,"Input connection processing failed.");
         goto errLabel;
       }
-      
+
       // Complete the instantiation of the proc instance by calling the custom instance creation function.
 
       // Call the custom instance create() function.
       if((rc = class_desc->members->create( inst )) != kOkRC )
       {
-        rc = cwLogError(kInvalidArgRC,"Instantiation failed on instance '%s:%i'.", inst->label,inst->label_sfx_id );
+        rc = cwLogError(kInvalidArgRC,"Custom instantiation failed." );
         goto errLabel;
       }
 
       // Create the instance->varMap[] lookup array
       if((rc =_create_instance_var_map( inst )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Variable map creation failed.");
         goto errLabel;
+      }
 
       // the custom creation function may have added channels to in-list vars fix up those connections here.
       _complete_input_connections(inst);
 
+      // set the log flags again so that vars created by the instance can be included in the log output
+      if((rc = _set_log_flags(inst,pstate.log_labels)) != kOkRC )
+        goto errLabel;
+      
       // call the 'value()' function to inform the instance of the current value of all of it's variables.
       if((rc = _call_value_func_on_all_variables( inst )) != kOkRC )
         goto errLabel;
 
+      if((rc = instance_validate(inst)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Proc instance validation failed.");
+        goto errLabel;
+      }
       
       inst_ref = inst;
       
     errLabel:
       if( rc != kOkRC )
+      {
+        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.inst_label),sfx_id);
         _destroy_inst(inst);
+      }
+      
       _destroy_pstate(pstate);
       
       return rc;      
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index a0695b0..e9f640a 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -724,10 +724,10 @@ namespace cw
     
     //------------------------------------------------------------------------------------------------------------------
     //
-    // AudioFileIn
+    // audio_file_in
     //
     
-    namespace audioFileIn
+    namespace audio_file_in
     {
       enum
       {
@@ -881,10 +881,10 @@ namespace cw
 
     //------------------------------------------------------------------------------------------------------------------
     //
-    // AudioFileOut
+    // audio_file_out
     //
     
-    namespace audioFileOut
+    namespace audio_file_out
     {
       enum
       {
@@ -1753,6 +1753,7 @@ namespace cw
 
         inst_t* inst = (inst_t*)ctx->userPtr;
 
+        mem::release(inst->phaseA);
         mem::release(inst);
         
         return rc;
@@ -3346,7 +3347,7 @@ namespace cw
         bool        trigFl        = false;
         variable_t* gainVar       = nullptr;
         abuf_t*     srateSrc      = nullptr;
-        double      dum;
+        double      dum_dbl;
 
         inst_t* p = mem::allocZ<inst_t>();
 
@@ -3360,7 +3361,7 @@ namespace cw
                                       kSrateRefPId,       "srateSrc",  kBaseSfxId, srateSrc,
                                       kDurMsPId,          "durMs",     kBaseSfxId, p->xfadeDurMs,
                                       kTriggerPId,         "trigger",  kBaseSfxId, trigFl,
-                                      kGainPId,            "gain",     kBaseSfxId, dum)) != kOkRC )
+                                      kGainPId,            "gain",     kBaseSfxId, dum_dbl)) != kOkRC )
         {
           goto errLabel; 
         }
@@ -3383,7 +3384,7 @@ namespace cw
         for(unsigned i=1; i<p->net_proc->internal_net->poly_cnt; ++i)
         {
           variable_t* dum;
-          if((rc = var_create(ctx, "gain", i, kGainPId+i, kAnyChIdx, nullptr, dum )) != kOkRC )
+          if((rc = var_create(ctx, "gain", i, kGainPId+i, kAnyChIdx, nullptr, kInvalidTFl, dum )) != kOkRC )
           {
             cwLogError(rc,"'gain:%i' create failed.",i);
             goto errLabel;
@@ -3790,44 +3791,21 @@ namespace cw
     namespace number
     {
       enum {
-        kInPId,
-        kBoolPId,
-        kUIntPId,
-        kIntPId,
-        kFloatPId,
-        kOutPId
+        kValuePId,
       };
       
-      typedef struct
-      {
-        bool delta_fl;
-        double value;
-      } inst_t;
 
 
       rc_t create( instance_t* proc )
       {
-        rc_t    rc   = kOkRC;        
-        inst_t* p = mem::allocZ<inst_t>();
-        proc->userPtr = p;
+        rc_t        rc    = kOkRC;        
+        double      value = 0;
 
         if((rc  = var_register_and_get(proc,kAnyChIdx,
-                                       kInPId,"in",kBaseSfxId,p->value)) != kOkRC )
+                                       kValuePId,"value",kBaseSfxId,value)) != kOkRC )
         {
           goto errLabel;
         }
-        
-        if((rc = var_register_and_set(proc,kAnyChIdx,
-                                      kBoolPId,"bool",kBaseSfxId,p->value != 0,
-                                      kUIntPId,"uint",kBaseSfxId,(unsigned)p->value,
-                                      kIntPId,"int",kBaseSfxId,(int)p->value,
-                                      kFloatPId,"float",kBaseSfxId,(float)p->value,
-                                      kOutPId,"out",kBaseSfxId,p->value )) != kOkRC )
-        {
-          goto errLabel;
-        }
-        
-        p->delta_fl = true;
 
       errLabel:
         return rc;
@@ -3836,45 +3814,18 @@ namespace cw
       rc_t destroy( instance_t* proc )
       {
         rc_t rc = kOkRC;
-
-        inst_t* p = (inst_t*)proc->userPtr;
-        mem::release(p);        
         return rc;
       }
 
       rc_t value( instance_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
-        if( var->vid == kInPId )
-        {
-          double v;
-          if((rc = var_get(var,v)) == kOkRC )
-          {
-            inst_t* p = (inst_t*)proc->userPtr;
-            if( !p->delta_fl )
-              p->delta_fl = v != p->value;
-            p->value    = v;
-            
-          }
-        }
         return rc;
       }
 
       rc_t exec( instance_t* proc )
       {
         rc_t rc      = kOkRC;
-        inst_t*  p = (inst_t*)proc->userPtr;
-
-        if( p->delta_fl )
-        {
-          p->delta_fl = false;
-          var_set(proc,kBoolPId,kAnyChIdx,p->value!=0);
-          var_set(proc,kUIntPId,kAnyChIdx,(unsigned)fabs(p->value));
-          var_set(proc,kIntPId,kAnyChIdx,(int)p->value);
-          var_set(proc,kFloatPId,kAnyChIdx,(float)p->value);
-          var_set(proc,kOutPId,kAnyChIdx,p->value);
-        }
-        
         return rc;
       }
 
@@ -3978,6 +3929,7 @@ namespace cw
 
         p->periodPhase += proc->ctx->framesPerCycle;
 
+        //printf("%i %i\n",p->periodPhase,p->periodFrmN);
         
         if( p->periodPhase >= p->periodFrmN )
         {
@@ -4020,6 +3972,7 @@ namespace cw
         kIncPId,
         kRepeatPId,
         kModePId,
+        kOutTypePId,
         kOutPId
       };
 
@@ -4075,12 +4028,16 @@ namespace cw
         proc->userPtr = p;
         double  init_val;
         const char* mode_label;
+        variable_t* dum = nullptr;
+        const char* out_type_label;
+        unsigned out_type_fl;
 
         if((rc = var_register_and_get(proc, kAnyChIdx,
                                       kTriggerPId, "trigger", kBaseSfxId, p->trig_val,
                                       kResetPId,   "reset",   kBaseSfxId, p->reset_val,
                                       kInitPId,    "init",    kBaseSfxId, init_val,
-                                      kModePId,    "mode",    kBaseSfxId, mode_label)) != kOkRC )
+                                      kModePId,    "mode",    kBaseSfxId, mode_label,
+                                      kOutTypePId, "out_type",kBaseSfxId, out_type_label)) != kOkRC )
         {
           goto errLabel;
         }
@@ -4095,12 +4052,25 @@ namespace cw
           goto errLabel;
         }
 
-        if((rc = var_register_and_set(proc,kAnyChIdx,
-                                      kOutPId,"out",kBaseSfxId,init_val)) != kOkRC )
+        // get the type of the output
+        if(out_type_label==nullptr || (out_type_fl = value_type_label_to_flag( out_type_label )) == kInvalidTFl )
+        {
+          rc = cwLogError(kInvalidArgRC,"The output type '%s' is not a valid type.",cwStringNullGuard(out_type_label));
+          goto errLabel;
+        }
+
+
+        if((rc = var_create( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, nullptr, out_type_fl, dum )) != kOkRC )
         {
           goto errLabel;
         }
-                                      
+
+        if((rc = var_set( proc, kOutPId, kAnyChIdx, 0u )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to set the initial counter value to %f.",init_val);
+          goto errLabel;
+        }
+                                                                    
 
         if((rc = _string_to_mode_id(mode_label,p->mode_id)) != kOkRC )
           goto errLabel;
@@ -4131,7 +4101,6 @@ namespace cw
           case kTriggerPId:
             {
               bool v;
-              
               if((rc = var_get(var,v)) == kOkRC )
               {
                 if( !p->delta_fl )
@@ -4159,98 +4128,93 @@ namespace cw
       {
         rc_t rc      = kOkRC;
         inst_t* p = (inst_t*)proc->userPtr;
-
-        
+        double cnt,inc,minv,maxv;        
         bool v;
+
+        if( !p->delta_fl )
+          return rc;
+        
+        p->delta_fl = false;
         if((rc = var_get(proc,kTriggerPId,kAnyChIdx,v)) != kOkRC )
         {
           cwLogError(rc,"Fail!");
           goto errLabel;
         }
-
-        p->delta_fl = v != p->trig_val;
+         
         p->trig_val = v;
 
-        if( p->delta_fl )
+        var_get(proc,kOutPId,kAnyChIdx,cnt);
+        var_get(proc,kIncPId,kAnyChIdx,inc);
+        var_get(proc,kMinPId,kAnyChIdx,minv);
+        var_get(proc,kMaxPId,kAnyChIdx,maxv);
+
+        cnt += p->dir * inc;
+
+        if( minv > cnt || cnt > maxv )
         {
-          p->delta_fl = false;
-          
-          double cnt,inc,minv,maxv;
-          var_get(proc,kOutPId,kAnyChIdx,cnt);
-          var_get(proc,kIncPId,kAnyChIdx,inc);
-          var_get(proc,kMinPId,kAnyChIdx,minv);
-          var_get(proc,kMaxPId,kAnyChIdx,maxv);
+          bool repeat_fl;
+          var_get(proc,kRepeatPId,kAnyChIdx,repeat_fl);
 
-          double incr = p->dir * inc;
-          cnt += incr;
-
-          if( minv > cnt || cnt > maxv )
+          if( !repeat_fl )
+            p->done_fl = true;
+          else
           {
-            bool repeat_fl;
-            var_get(proc,kRepeatPId,kAnyChIdx,repeat_fl);
-
-            if( !repeat_fl )
-              p->done_fl = true;
-            else
+            if( cnt > maxv)
             {
-              if( cnt > maxv)
+              switch( p->mode_id )
               {
-                switch( p->mode_id )
-                {
-                  case kModuloModeId:
-                    while(cnt > maxv )
-                      cnt = minv + (cnt-maxv);
-                    break;
+                case kModuloModeId:
+                  while(cnt > maxv )
+                    cnt = minv + (cnt-maxv);
+                  break;
 
-                  case kReverseModeId:
-                    p->dir = -1 * p->dir;
-                    while( cnt > maxv )
-                      cnt = maxv - (cnt-maxv);
-                    break;
+                case kReverseModeId:
+                  p->dir = -1 * p->dir;
+                  while( cnt > maxv )
+                    cnt = maxv - (cnt-maxv);
+                  break;
 
-                  case kClipModeId:
-                    cnt = maxv;
-                    break;
+                case kClipModeId:
+                  cnt = maxv;
+                  break;
 
-                  default:
-                    assert(0);
+                default:
+                  assert(0);
                     
-                }
-              }
-
-              if( cnt < minv)
-              {
-                switch( p->mode_id )
-                {
-                  case kModuloModeId:
-                    while( cnt < minv )
-                      cnt = maxv - (minv-cnt);
-                    break;
-                    
-                  case kReverseModeId:
-                    p->dir = -1 * p->dir;
-                    while(cnt < minv )
-                      cnt = minv + (minv-cnt);
-                    break;
-                    
-                  case kClipModeId:
-                    cnt = minv;
-                    break;
-                    
-                  default:
-                    assert(0);
-                }                
               }
             }
-          }
 
-          if( !p->done_fl )
-          {
-            printf("cnt:%f\n",cnt);
-            var_set(proc,kOutPId,kAnyChIdx,cnt);
+            if( cnt < minv)
+            {
+              switch( p->mode_id )
+              {
+                case kModuloModeId:
+                  while( cnt < minv )
+                    cnt = maxv - (minv-cnt);
+                  break;
+                    
+                case kReverseModeId:
+                  p->dir = -1 * p->dir;
+                  while(cnt < minv )
+                    cnt = minv + (minv-cnt);
+                  break;
+                    
+                case kClipModeId:
+                  cnt = minv;
+                  break;
+                    
+                default:
+                  assert(0);
+              }                
+            }
           }
         }
 
+        // if the counter has not reached it's terminal state
+        if( !p->done_fl )
+          var_set(proc,kOutPId,kAnyChIdx,cnt);
+        
+
       errLabel:
         return rc;
       }
@@ -4264,6 +4228,631 @@ namespace cw
       };
       
     }    
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // List
+    //
+    namespace list
+    {
+      enum
+      {
+        kInPId,
+        kListPId,
+        kOutPId
+      };
+      
+      typedef struct
+      {
+        unsigned        listN;   // the length of the list
+        const object_t* list;    // the list
+        unsigned        typeFl;  // the output type
+        unsigned        index;     // the last index referenced
+        bool            deltaFl;
+      } inst_t;
+
+      rc_t _determine_type( const object_t* list, unsigned& typeFl_ref )
+      {
+        rc_t rc = kOkRC;
+
+        typeFl_ref = kInvalidTFl;
+        
+        enum { bool_idx, uint_idx, int_idx, float_idx, double_idx, string_idx, cfg_idx, typeN };
+        typedef struct type_map_str
+        {
+          unsigned idx;
+          unsigned typeFl;
+          unsigned cnt;
+        } type_map_t;
+
+        type_map_t typeA[] = {
+          { bool_idx,   kBoolTFl,   0 },
+          { uint_idx,   kUIntTFl,   0 },
+          { int_idx,    kIntTFl,    0 },
+          { float_idx,  kFloatTFl,  0 },
+          { double_idx, kDoubleTFl, 0 },
+          { string_idx, kStringTFl, 0 },
+          { cfg_idx,    kCfgTFl,    0 },          
+        };
+
+
+        // count the number of each type of element in the list.
+        for(unsigned i=0; i<list->child_count(); ++i)
+        {
+          const object_t* c = list->child_ele(i);
+
+          switch( c->type->id )
+          {
+            case kCharTId:   typeA[uint_idx].cnt+=1; break;
+            case kInt8TId:   typeA[int_idx].cnt +=1; break;             
+            case kUInt8TId:  typeA[uint_idx].cnt+=1; break;
+            case kInt16TId:  typeA[int_idx].cnt +=1; break;
+            case kUInt16TId: typeA[uint_idx].cnt+=1; break;
+            case kInt32TId:  typeA[int_idx].cnt +=1; break;
+            case kUInt32TId: typeA[uint_idx].cnt+=1; break;
+            case kFloatTId:  typeA[float_idx].cnt+=1; break;
+            case kDoubleTId: typeA[double_idx].cnt+=1; break;
+            case kBoolTId:   typeA[bool_idx].cnt+=1; break;
+            case kStringTId: typeA[string_idx].cnt+=1; break;
+            case kCStringTId:typeA[string_idx].cnt+=1; break;
+              break;
+              
+            default:
+              switch( c->type->id )
+              {
+                case kVectTId:
+                case kPairTId:
+                case kListTId:
+                case kDictTId:
+                  typeA[cfg_idx].cnt +=1;
+                  break;
+                
+                default:
+                  rc = cwLogError(kSyntaxErrorRC,"The object type '0x%x' is not a valid list entry type. %i",c->type->flags,list->child_count());
+                  goto errLabel;
+              }
+          }
+
+          unsigned type_flag = kInvalidTFl; // type flag of one of the reference types
+          unsigned type_cnt = 0;            // count of types
+
+          for(unsigned i=0; i<typeN; ++i)
+            if( typeA[i].cnt > 0 )
+            {
+              type_cnt += 1;
+              type_flag = typeA[i].typeFl;
+            }
+
+          // it is an error if more than one type of element was included in the list - 
+          // and one of those types was string or cfg - having multiple numeric types
+          // is ok because they can be converted between each other - but string, and cfg's
+          // cannot be converted to numbers, nor can the be converted between each other.
+          if( type_cnt > 1 && (typeA[string_idx].cnt>0 || typeA[cfg_idx].cnt>0) )
+          {
+            rc = cwLogError(kInvalidArgRC,"The list types. The list must be all numerics, all strings, or all cfg. types.");
+            for(unsigned i=0; i<typeN; ++i)
+              if( typeA[i].cnt > 0 )
+                cwLogInfo("%i %s",typeA[i].cnt, value_type_flag_to_label(typeA[i].typeFl));
+            
+            goto errLabel;
+          }
+
+          typeFl_ref = type_flag;
+        }
+
+
+      errLabel:
+        return rc;
+      }
+
+      template< typename T >
+      rc_t _set_out_tmpl( instance_t* proc, inst_t* p, unsigned idx, T& v )
+      {
+        rc_t rc;
+        const object_t* ele;        
+
+        // get the list element to output
+        if((ele = p->list->child_ele(idx)) == nullptr )
+        {
+          rc = cwLogError(kEleNotFoundRC,"The list element at index %i could not be accessed.",idx);
+          goto errLabel;
+        }
+
+        // get the value of the list element
+        if((rc = ele->value(v)) != kOkRC )
+        {
+          rc = cwLogError(rc,"List value access failed on index %i",idx);
+          goto errLabel;
+        }
+
+        // set the output
+        if((rc = var_set(proc,kOutPId,kAnyChIdx,v)) != kOkRC )
+        {
+          rc = cwLogError(rc,"List output failed on index %i",idx);
+          goto errLabel;          
+        }
+
+      errLabel:
+        return rc;
+      }
+
+      rc_t _set_output( instance_t* proc, inst_t* p )
+      {
+        rc_t rc;
+        unsigned idx;
+        
+        if((rc = var_get(proc,kInPId,kAnyChIdx,idx)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to get the list index.");
+          goto errLabel;
+        }
+
+        // if the index has not changed then there is nothing to do
+        if( idx == p->index )
+          goto errLabel;
+
+        switch( p->typeFl )
+        {
+          case kUIntTFl:
+            {
+              unsigned v;
+              rc = _set_out_tmpl(proc,p,idx,v);
+            }
+            break;
+            
+          case kIntTFl:
+            {
+              int v;
+              rc = _set_out_tmpl(proc,p,idx,v);
+            }
+            break;
+            
+          case kFloatTFl:
+            {
+              float v;
+              rc = _set_out_tmpl(proc,p,idx,v);
+            }
+            break;
+            
+          case kDoubleTFl:
+            {
+              double v;
+              rc = _set_out_tmpl(proc,p,idx,v); 
+            }
+            break;
+            
+          case kStringTFl:
+            {
+              const char* v;
+              rc = _set_out_tmpl(proc,p,idx,v);
+            }
+            break;
+            
+          case kCfgTFl:
+            {
+              const object_t* v;
+              rc = _set_out_tmpl(proc,p,idx,v);
+            }
+            break;
+            
+          default:
+            rc = cwLogError(kInvalidArgRC,"The list type flag %s (0x%x) is not valid.",value_type_flag_to_label(p->typeFl),p->typeFl);
+            break;
+            
+        }
+
+        if(rc != kOkRC )
+          goto errLabel;
+
+        p->index = idx;
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t create( instance_t* proc )
+      {
+        rc_t    rc   = kOkRC;        
+        inst_t* p = mem::allocZ<inst_t>();
+        unsigned index;
+        proc->userPtr = p;
+        
+        variable_t* dum = nullptr;
+
+        p->index = kInvalidIdx;
+        p->typeFl = kInvalidTFl;
+        p->deltaFl = false;
+        
+        if((rc = var_register_and_get(proc, kAnyChIdx,
+                                      kInPId, "in",    kBaseSfxId, index,
+                                      kListPId,"list", kBaseSfxId, p->list)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        if( !p->list->is_list() )
+        {
+          cwLogError(kSyntaxErrorRC,"The list cfg. value is not a list.");
+          goto errLabel;
+        }
+
+        p->listN = p->list->child_count();
+
+        // determine what type of element is in the list
+        // (all elements in the this list must be of the same type: numeric,string,cfg)
+        if((rc = _determine_type( p->list, p->typeFl )) != kOkRC )
+          goto errLabel;
+
+        // create the output variable
+        if((rc = var_create( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, nullptr, p->typeFl, dum )) != kOkRC )
+        {
+          rc = cwLogError(rc,"'out' var create failed.");
+          goto errLabel;
+        }
+
+        // set the initial value of the output 
+        if((rc = _set_output(proc,p)) != kOkRC )
+          goto errLabel;
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        rc_t rc = kOkRC;
+
+        inst_t* p = (inst_t*)proc->userPtr;
+
+        mem::release(p);
+        
+        return rc;
+      }
+
+      rc_t value( instance_t* proc, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        if( var->vid == kInPId )
+        {
+          inst_t*  p   = (inst_t*)proc->userPtr;
+          unsigned idx;
+          if( var_get(var,idx) == kOkRC && idx != p->index)
+            p->deltaFl = true;
+        }
+        return rc;
+      }
+
+      rc_t exec( instance_t* proc )
+      {
+        rc_t rc = kOkRC;
+        inst_t*  p   = (inst_t*)proc->userPtr;
+
+        if( p->deltaFl )
+        {
+          rc = _set_output(proc, p );
+          p->deltaFl = false;
+        }
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // add
+    //
+    namespace add
+    {
+      enum {
+        kOutPId,
+        kOTypePId,
+        kInPId
+      };
+      
+      typedef struct
+      {
+        bool delta_fl;
+        unsigned inN;
+      } inst_t;
+
+
+      template< typename T >
+      rc_t _sum( instance_t* proc, variable_t* var )
+      {
+        rc_t rc      = kOkRC;
+        inst_t*  p = (inst_t*)proc->userPtr;
+        
+        T sum = 0;
+        
+        // read and sum the inputs
+        for(unsigned i=0; i<p->inN; ++i)
+        {
+          T val;
+          if((rc = var_get(proc,kInPId+i,kAnyChIdx,val)) == kOkRC )            
+            sum += val;
+          else
+          {
+            rc = cwLogError(rc,"Operand index %i read failed.",i);
+            goto errLabel;
+          }
+        }
+
+        // set the output
+        if((rc = var_set(var,sum)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Result set failed.");
+          goto errLabel;
+        }
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t _exec( instance_t* proc, variable_t* out_var=nullptr )
+      {
+        rc_t rc = kOkRC;
+        inst_t* p = (inst_t*)(proc->userPtr);
+
+        if( !p->delta_fl )
+          return rc;
+
+        p->delta_fl = false;
+
+        if( out_var == nullptr )
+          if((rc = var_find(proc,kOutPId,kAnyChIdx,out_var)) != kOkRC )
+          {
+            rc = cwLogError(rc,"The output variable could not be found.");
+            goto errLabel;
+          }
+        
+        switch( out_var->varDesc->type )
+        {
+          case kBoolTFl:   rc = _sum<bool>(proc,out_var);     break;
+          case kUIntTFl:   rc = _sum<unsigned>(proc,out_var); break; 
+          case kIntTFl:    rc = _sum<int>(proc,out_var);      break;
+          case kFloatTFl:  rc = _sum<float>(proc,out_var);    break;
+          case kDoubleTFl: rc = _sum<double>(proc,out_var);   break;
+          default:
+            rc = cwLogError(kInvalidArgRC,"The output type %s (0x%x) is not valid.",value_type_flag_to_label(out_var->value->tflag),out_var->value->tflag);
+            goto errLabel;
+        }
+
+        if(rc != kOkRC )
+          rc = cwLogError(kOpFailRC,"Sum failed.");
+
+      errLabel:
+        return rc;
+
+      }
+      
+      rc_t create( instance_t* proc )
+      {
+        rc_t    rc   = kOkRC;        
+        inst_t* p = mem::allocZ<inst_t>();
+        proc->userPtr = p;
+
+        variable_t* out_var        = nullptr;
+        const char* out_type_label = nullptr;
+        unsigned    out_type_flag  = kInvalidTFl;
+        unsigned    sfxIdAllocN    = instance_var_count(proc);
+        unsigned    sfxIdA[ sfxIdAllocN ];
+        p->inN = 0;
+
+        // get a count of the number of input variables
+        if((rc = var_mult_sfx_id_array(proc, "in", sfxIdA, sfxIdAllocN, p->inN )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to obtain the array of mult label-sfx-id's for the variable 'in'.");
+          goto errLabel;
+        }
+
+        // if the adder has no inputs
+        if( p->inN == 0 )
+        {
+          rc = cwLogError(rc,"The 'add' unit '%s' appears to not have any inputs.",cwStringNullGuard(proc->label));
+          goto errLabel;
+        }
+
+        // sort the input id's in ascending order
+        std::sort(sfxIdA, sfxIdA + p->inN, [](unsigned& a,unsigned& b){ return a<b; } );
+
+        // register each of the input vars
+        for(unsigned i=0; i<p->inN; ++i)
+        {
+          variable_t* dum;
+          if((rc = var_register(proc, "in", sfxIdA[i], kInPId+i, kAnyChIdx, nullptr, dum )) != kOkRC )
+          {
+            rc = cwLogError(rc,"Variable registration failed for the variable 'in:%i'.",sfxIdA[i]);;
+            goto errLabel;
+          }
+        }
+
+        // Get the output type label as a string
+        if((rc = var_register_and_get(proc,kAnyChIdx,kOTypePId,"otype",kBaseSfxId,out_type_label)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Variable registration failed for the variable 'otype:0'.");;
+          goto errLabel;          
+        }
+
+        // Convert the output type label into a flag
+        if((out_type_flag = value_type_label_to_flag(out_type_label)) == kInvalidTFl )
+        {
+          rc = cwLogError(rc,"The type label '%s' does not identify a valid type.",cwStringNullGuard(out_type_label));;
+          goto errLabel;          
+        }
+
+        // Create the output var
+        if((rc = var_create( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, nullptr, out_type_flag, out_var )) != kOkRC )
+        {          
+          rc = cwLogError(rc,"The output variable create failed.");
+          goto errLabel;
+        }
+
+        /*
+        if((rc = var_set(proc,kOutPId,kAnyChIdx,0.0)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Initial output variable set failed.");
+          goto errLabel;          
+        }
+        */
+        
+        p->delta_fl=true;
+        _exec(proc,out_var);
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        rc_t rc = kOkRC;
+
+        inst_t* p = (inst_t*)proc->userPtr;
+
+        mem::release(p);
+        
+        return rc;
+      }
+
+      rc_t value( instance_t* proc, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        inst_t* p = (inst_t*)(proc->userPtr);
+        
+        if( kInPId <= var->vid && var->vid < kInPId+p->inN )
+          p->delta_fl = true;
+        
+        return rc;
+      }
+
+      rc_t exec( instance_t* proc )
+      {
+        return _exec(proc);
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };      
+    }    
+
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // preset
+    //
+    namespace preset
+    {
+      enum { kInPId };
+      
+      enum { kPresetLabelCharN=255 };
+      
+      typedef struct
+      {
+        char preset_label[ kPresetLabelCharN+1];
+      } inst_t;
+
+
+      rc_t _set_preset( instance_t* proc, inst_t* p, const char* preset_label )
+      {
+        rc_t rc = kOkRC;
+
+        if( preset_label == nullptr )
+        {
+          if((rc = var_get(proc, kInPId, kAnyChIdx, preset_label)) != kOkRC )
+          {
+            rc = cwLogError(rc,"The variable 'in read failed.");
+            goto errLabel;
+          }
+        }
+
+        if( preset_label == nullptr )
+        {
+          rc = cwLogError(kInvalidArgRC,"Preset application failed due to blank preset label.");
+          goto errLabel;
+        }
+
+        if((rc = network_apply_preset(*proc->net, preset_label)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Appy preset '%s' failed.",cwStringNullGuard(preset_label));
+          goto errLabel;
+        }
+        
+        if( textLength(preset_label) >= kPresetLabelCharN )
+          strncpy(p->preset_label,preset_label,kPresetLabelCharN);
+        else
+        {
+          rc = cwLogError(kBufTooSmallRC,"The preset label '%s' is to long.",cwStringNullGuard(preset_label));
+          goto errLabel;
+        }
+
+      errLabel:
+        return rc;
+        
+      }
+      
+      rc_t create( instance_t* proc )
+      {
+        rc_t    rc   = kOkRC;        
+        inst_t* p = mem::allocZ<inst_t>();
+        proc->userPtr = p;
+        const char* label = nullptr;
+
+        p->preset_label[0] = 0;
+        
+        if((rc = var_register_and_get(proc,kAnyChIdx,kInPId,"in",kBaseSfxId,label)) != kOkRC )
+          goto errLabel;
+
+      errLabel:
+        return rc;
+      }
+
+      rc_t destroy( instance_t* proc )
+      {
+        rc_t rc = kOkRC;
+
+        inst_t* p = (inst_t*)proc->userPtr;
+
+        // Custom clean-up code goes here
+
+        mem::release(p);
+        
+        return rc;
+      }
+
+      rc_t value( instance_t* proc, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        return rc;
+      }
+
+      rc_t exec( instance_t* proc )
+      {
+        rc_t rc      = kOkRC;
+        //inst_t*  p = (inst_t*)proc->userPtr;
+        
+        return rc;
+      }
+
+      class_members_t members = {
+        .create = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec = exec,
+        .report = nullptr
+      };
+      
+    }    
+
+
     
   } // flow
 } // cw
diff --git a/cwFlowProc.h b/cwFlowProc.h
index d09b0e0..30e3588 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -7,8 +7,8 @@ namespace cw
     namespace midi_out        { extern class_members_t members;  }
     namespace audio_in        { extern class_members_t members;  }
     namespace audio_out       { extern class_members_t members;  }
-    namespace audioFileIn     { extern class_members_t members;  }
-    namespace audioFileOut    { extern class_members_t members;  }
+    namespace audio_file_in   { extern class_members_t members;  }
+    namespace audio_file_out  { extern class_members_t members;  }
     namespace audio_gain      { extern class_members_t members;  }    
     namespace audio_split     { extern class_members_t members;  }
     namespace audio_merge     { extern class_members_t members;  }
@@ -31,6 +31,9 @@ namespace cw
     namespace number          { extern class_members_t members;  }
     namespace timer           { extern class_members_t members;  }
     namespace counter         { extern class_members_t members;  }
+    namespace list            { extern class_members_t members;  }
+    namespace add             { extern class_members_t members;  }
+    namespace preset          { extern class_members_t members;  }
     
   }
 }
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index eada7df..6474233 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -2,6 +2,7 @@
 #include "cwLog.h"
 #include "cwCommonImpl.h"
 #include "cwMem.h"
+#include "cwMath.h"
 #include "cwText.h"
 #include "cwObject.h"
 #include "cwVectOps.h"
@@ -45,6 +46,10 @@ namespace cw
       { kFloatTFl, "coeff"},
       { kDoubleTFl, "ftime" },
 
+      { kUIntTFl | kIntTFl | kFloatTFl | kDoubleTFl, "numeric" },
+
+      { kRuntimeTFl, "runtime" },
+
       { kInvalidTFl, nullptr }
     };
 
@@ -63,7 +68,7 @@ namespace cw
       if( v == nullptr )
         return;
         
-      switch( v->flags & kTypeMask )
+      switch( v->tflag & kTypeMask )
       {
         case kInvalidTFl:
           break;
@@ -98,22 +103,25 @@ namespace cw
         case kStringTFl:
           mem::release( v->u.s );
           break;
-                    
+          
         case kTimeTFl:
           assert(0);
           break;
 
+        case kCfgTFl:
+          break;
+
         default:
           assert(0);
           break;
       }
 
-      v->flags = kInvalidTFl;
+      v->tflag = kInvalidTFl;
     }
 
     void _value_duplicate( value_t& dst, const value_t& src )
     {        
-      switch( src.flags & kTypeMask )
+      switch( src.tflag & kTypeMask )
       {
         case kInvalidTFl:
           break;
@@ -129,17 +137,17 @@ namespace cw
         case kABufTFl:
           
           dst.u.abuf = src.u.abuf == nullptr ? nullptr : abuf_duplicate(src.u.abuf);
-          dst.flags = src.flags;
+          dst.tflag = src.tflag;
           break;
           
         case kFBufTFl:
           dst.u.fbuf = src.u.fbuf == nullptr ? nullptr : fbuf_duplicate(src.u.fbuf);
-          dst.flags = src.flags;
+          dst.tflag = src.tflag;
           break;
 
         case kMBufTFl:
           dst.u.mbuf = src.u.mbuf == nullptr ? nullptr : mbuf_duplicate(src.u.mbuf);
-          dst.flags = src.flags;
+          dst.tflag = src.tflag;
           break;
           
         case kBoolMtxTFl:
@@ -152,13 +160,17 @@ namespace cw
           
         case kStringTFl:
           dst.u.s = mem::duplStr( dst.u.s );
-          dst.flags = src.flags;
+          dst.tflag = src.tflag;
           break;
                     
         case kTimeTFl:
           assert(0);
           break;
 
+        case kCfgTFl:
+          dst = src;
+          break;
+          
         default:
           assert(0);
           break;
@@ -171,16 +183,16 @@ namespace cw
       if( v == nullptr )
         return;
         
-      switch( v->flags & kTypeMask )
+      switch( v->tflag & kTypeMask )
       {
         case kInvalidTFl:
           break;
           
-        case kBoolTFl:  printf("%s ", v->u.b ? "True" : "False" ); break;          
-        case kUIntTFl:  printf("%i ", v->u.u ); break;
-        case kIntTFl:   printf("%i ", v->u.i ); break;          
-        case kFloatTFl: printf("%f ", v->u.f ); break;
-        case kDoubleTFl:printf("%f ", v->u.d ); break;
+        case kBoolTFl:  printf("b:%s ", v->u.b ? "true" : "false" ); break;          
+        case kUIntTFl:  printf("u:%i ", v->u.u ); break;
+        case kIntTFl:   printf("i:%i ", v->u.i ); break;          
+        case kFloatTFl: printf("f:%f ", v->u.f ); break;
+        case kDoubleTFl:printf("d:%f ", v->u.d ); break;
         case kABufTFl:
           if( v->u.abuf == nullptr )
             printf("abuf: <null>");
@@ -224,6 +236,11 @@ namespace cw
           assert(0);
           break;
 
+        case kCfgTFl:
+          if( v->u.cfg != nullptr )
+            v->u.cfg->print();
+          break;
+          
         default:
           assert(0);
           break;
@@ -235,23 +252,46 @@ namespace cw
     rc_t _val_get( const value_t* val, bool& valRef )
     {
       rc_t rc = kOkRC;
-      switch( val->flags & kTypeMask )
+      switch( val->tflag & kTypeMask )
       {
         case kBoolTFl:   valRef = val->u.b; break;
         case kUIntTFl:   valRef = val->u.u!=0; break;
         case kIntTFl:    valRef = val->u.i!=0; break;
         case kFloatTFl:  valRef = val->u.f!=0; break;
-        case kDoubleTFl: valRef = val->u.d!=0; break;
+        case kDoubleTFl: valRef = val->u.d!=0; break;        
         default:
-          rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to a bool.",val->flags);
+          rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to a bool.",_typeFlagToLabel(val->tflag),val->tflag);
       }
       return rc;
     }
+
+    rc_t _val_set( value_t* val, bool v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kBoolTFl:   val->u.b=v; break;
+        case kUIntTFl:   val->u.u=v; break;
+        case kIntTFl:    val->u.i=v; break;
+        case kFloatTFl:  val->u.f=v; break;
+        case kDoubleTFl: val->u.d=v; break;
+        case kInvalidTFl:
+          val->u.b   = v;
+          val->tflag = kBoolTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A bool could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
     
     rc_t _val_get( const value_t* val, uint_t& valRef )
     {
       rc_t rc = kOkRC;
-      switch( val->flags & kTypeMask )
+      switch( val->tflag & kTypeMask )
       {
         case kBoolTFl:   valRef = val->u.b ? 1 : 0; break;
         case kUIntTFl:   valRef = val->u.u; break;
@@ -259,15 +299,38 @@ namespace cw
         case kFloatTFl:  valRef = (uint_t)val->u.f; break;
         case kDoubleTFl: valRef = (uint_t)val->u.d; break;
         default:
-          rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to a uint_t.",val->flags);
+          rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to a uint.",_typeFlagToLabel(val->tflag),val->tflag);
       }
       return rc;
     }
+
+    rc_t _val_set( value_t* val, uint_t v )
+    {
+      rc_t rc = kOkRC;
       
+      switch( val->tflag & kTypeMask )
+      {
+        case kBoolTFl:   val->u.b=v!=0; break;
+        case kUIntTFl:   val->u.u=v; break;
+        case kIntTFl:    val->u.i=v; break;
+        case kFloatTFl:  val->u.f=v; break;
+        case kDoubleTFl: val->u.d=v; break;
+        case kInvalidTFl:
+          val->u.u  = v;
+          val->tflag = kUIntTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A uint could not be converted to a  %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+    
     rc_t _val_get( const value_t* val, int_t& valRef )
     {
       rc_t rc = kOkRC;
-      switch( val->flags & kTypeMask )
+      switch( val->tflag & kTypeMask )
       {
         case kBoolTFl:   valRef = val->u.b ? 1 : 0; break;
         case kUIntTFl:   valRef = (int_t)val->u.u; break;
@@ -275,15 +338,40 @@ namespace cw
         case kFloatTFl:  valRef = (int_t)val->u.f; break;
         case kDoubleTFl: valRef = (int_t)val->u.d; break;
         default:
-          rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to a int_t.",val->flags);
+          rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to an int.",_typeFlagToLabel(val->tflag),val->tflag);
+          
       }
       return rc;
     }
 
+    rc_t _val_set( value_t* val, int_t v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kBoolTFl:   val->u.b=v!=0; break;
+        case kUIntTFl:   val->u.u=v; break;
+        case kIntTFl:    val->u.i=v; break;
+        case kFloatTFl:  val->u.f=v; break;
+        case kDoubleTFl: val->u.d=v; break;
+        case kInvalidTFl:
+          val->u.i   = v;
+          val->tflag = kIntTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"An int could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+    
+
     rc_t _val_get( const value_t* val, float& valRef )
     {
       rc_t rc = kOkRC;
-      switch( val->flags & kTypeMask )
+      switch( val->tflag & kTypeMask )
       {
         case kBoolTFl:   valRef = val->u.b ? 1 : 0; break;
         case kUIntTFl:   valRef = (float)val->u.u; break;
@@ -291,15 +379,38 @@ namespace cw
         case kFloatTFl:  valRef = (float)val->u.f; break;
         case kDoubleTFl: valRef = (float)val->u.d; break;
         default:
-          rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to a float.", val->flags);
+          rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to a float.",_typeFlagToLabel(val->tflag),val->tflag);
       }
       return rc;
     }
 
+    rc_t _val_set( value_t* val, float v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kBoolTFl:   val->u.b=v!=0; break;
+        case kUIntTFl:   val->u.u=(unsigned)v; break;
+        case kIntTFl:    val->u.i=(int)v; break;
+        case kFloatTFl:  val->u.f=v; break;
+        case kDoubleTFl: val->u.d=v; break;
+        case kInvalidTFl:
+          val->u.f   = v;
+          val->tflag = kFloatTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A float could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+    
     rc_t _val_get( const value_t* val, double& valRef )
     {
       rc_t rc = kOkRC;
-      switch( val->flags & kTypeMask )
+      switch( val->tflag & kTypeMask )
       {
         case kBoolTFl:   valRef = val->u.b ? 1 : 0; break;
         case kUIntTFl:   valRef = (double)val->u.u; break;
@@ -307,33 +418,77 @@ namespace cw
         case kFloatTFl:  valRef = (double)val->u.f; break;
         case kDoubleTFl: valRef =         val->u.d; break;
         default:
-          rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to a double.",val->flags);
+          rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to a double.",_typeFlagToLabel(val->tflag),val->tflag);
       }
       return rc;
     }
 
+    rc_t _val_set( value_t* val, double v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kBoolTFl:   val->u.b=v!=0; break;
+        case kUIntTFl:   val->u.u=(unsigned)v; break;
+        case kIntTFl:    val->u.i=(int)v; break;
+        case kFloatTFl:  val->u.f=(float)v; break;
+        case kDoubleTFl: val->u.d=v; break;
+        case kInvalidTFl:
+          val->u.d   = v;
+          val->tflag = kDoubleTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A double could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+    
     rc_t _val_get( const value_t* val, const char*& valRef )
     {
       rc_t rc = kOkRC;
-      if( cwIsFlag(val->flags & kTypeMask, kStringTFl) )
+      if( cwIsFlag(val->tflag & kTypeMask, kStringTFl) )
         valRef = val->u.s;
       else
       {
-        rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to a string.",val->flags);
+        rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to a string.",_typeFlagToLabel(val->tflag),val->tflag);        
         valRef = nullptr;
       }
       
       return rc;
     }
 
+    rc_t _val_set( value_t* val, const char* v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kStringTFl:
+          val->u.s=mem::duplStr(v); break;
+          
+        case kInvalidTFl:
+          val->u.s   = mem::duplStr(v);
+          val->tflag = kStringTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A string could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+    
     rc_t _val_get( value_t* val, abuf_t*& valRef )
     {
       rc_t rc = kOkRC;
-      if( cwIsFlag(val->flags & kTypeMask, kABufTFl) )
+      if( cwIsFlag(val->tflag & kTypeMask, kABufTFl) )
         valRef = val->u.abuf;
       else
       {
-        rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to an abuf_t.",val->flags);
+        rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to an abuf.",_typeFlagToLabel(val->tflag),val->tflag);        
         valRef = nullptr;
       }
       return rc;
@@ -348,15 +503,37 @@ namespace cw
       return rc;        
     }
 
+    rc_t _val_set( value_t* val, abuf_t* v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kABufTFl:
+          val->u.abuf=v;
+          break;
+          
+        case kInvalidTFl:
+          val->u.abuf=v;
+          val->tflag = kABufTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A audio signal could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+        
     rc_t _val_get( value_t* val, fbuf_t*& valRef )
     {
       rc_t rc = kOkRC;
-      if( cwIsFlag(val->flags & kTypeMask, kFBufTFl) )
+      if( cwIsFlag(val->tflag & kTypeMask, kFBufTFl) )
         valRef = val->u.fbuf;
       else
       {
         valRef = nullptr;
-        rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to an fbuf_t.",val->flags);
+        rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to an fbuf.",_typeFlagToLabel(val->tflag),val->tflag);        
       }
       return rc;
     }
@@ -370,18 +547,63 @@ namespace cw
       return rc;        
     }
 
+    rc_t _val_set( value_t* val, fbuf_t* v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kFBufTFl:
+          val->u.fbuf=v;
+          break;
+          
+        case kInvalidTFl:
+          val->u.fbuf=v;
+          val->tflag = kFBufTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A spectrum signal could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+        
     rc_t _val_get( value_t* val, mbuf_t*& valRef )
     {
       rc_t rc = kOkRC;
-      if( cwIsFlag(val->flags & kTypeMask, kMBufTFl) )
+      if( cwIsFlag(val->tflag & kTypeMask, kMBufTFl) )
         valRef = val->u.mbuf;
       else
       {
         valRef = nullptr;
-        rc = cwLogError(kTypeMismatchRC,"The type 0x%x could not be converted to an mbuf_t.",val->flags);
+        rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to an mbuf.",_typeFlagToLabel(val->tflag),val->tflag);        
       }
       return rc;
     }
+
+    rc_t _val_set( value_t* val, mbuf_t* v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kMBufTFl:
+          val->u.mbuf=v;
+          break;
+          
+        case kInvalidTFl:
+          val->u.mbuf=v;
+          val->tflag = kMBufTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A MIDI signal could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
+    
     
     rc_t _val_get( value_t* val, const mbuf_t*& valRef )
     {
@@ -391,7 +613,43 @@ namespace cw
         valRef = non_const_val;
       return rc;        
     }
+
+    rc_t _val_get( value_t* val, const object_t*& valRef )
+    {
+      rc_t rc = kOkRC;
+      
+      if( cwIsFlag(val->tflag & kTypeMask, kCfgTFl) )
+        valRef = val->u.cfg;
+      else
+      {
+        valRef = nullptr;
+        rc = cwLogError(kTypeMismatchRC,"The type %s (0x%x) could not be converted to a cfg.",_typeFlagToLabel(val->tflag),val->tflag);        
+        
+      }
+      return rc;        
+    }
     
+    rc_t _val_set( value_t* val, const object_t* v )
+    {
+      rc_t rc = kOkRC;
+      
+      switch( val->tflag & kTypeMask )
+      {
+        case kCfgTFl:
+          val->u.cfg=v;
+          break;
+          
+        case kInvalidTFl:
+          val->u.cfg=v;
+          val->tflag = kCfgTFl;
+          break;
+
+        default:
+          rc = cwLogError(kTypeMismatchRC,"A cfg. could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
+      }
+      
+      return rc;
+    }
 
     template< typename T >
     rc_t _val_get_driver( const variable_t* var, T& valRef )
@@ -403,8 +661,8 @@ namespace cw
         return cwLogError(kInvalidStateRC,"No value has been assigned to the variable: %s:%i.%s:%i ch:%i.",cwStringNullGuard(var->inst->label),var->inst->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id,var->chIdx);
 
       return _val_get(var->value,valRef);
-    }
-
+    
+}
     rc_t _var_find_to_set( instance_t* inst, unsigned vid, unsigned chIdx, unsigned typeFl, variable_t*& varRef )
     {
       rc_t rc = kOkRC;
@@ -414,8 +672,14 @@ namespace cw
       if((rc = var_find(inst,vid,chIdx,varRef)) == kOkRC )
       {
         // validate the type of the variable against the description
+        /*
         if( !cwIsFlag(varRef->varDesc->type,typeFl ) )
-          rc = cwLogError(kTypeMismatchRC,"Type mismatch. Instance:%s:%i variable:%s:%i with type 0x%x does not match requested type:0x%x.",varRef->inst->label,varRef->inst->label_sfx_id,varRef->label,varRef->label_sfx_id,varRef->varDesc->type,typeFl);
+          rc = cwLogError(kTypeMismatchRC,"Type mismatch. Instance:%s:%i variable:%s:%i with type %s (0x%x) does not match requested type: %s (0x%x).",
+                          varRef->inst->label,varRef->inst->label_sfx_id,
+                          varRef->label,
+                          varRef->label_sfx_id,_typeFlagToLabel(varRef->varDesc->type),varRef->varDesc->type,
+                          _typeFlagToLabel(typeFl),typeFl);
+        */
     
       }
 
@@ -453,137 +717,119 @@ namespace cw
       return nullptr;
     }
     
+    rc_t _var_find_on_label_and_ch( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, variable_t*& var_ref )
+    {
+      rc_t rc = kOkRC;
+      if((var_ref = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx)) == nullptr )
+        rc = cwLogError(kEleNotFoundRC,"The variable '%s:%i' cannot be found on the proc:%s.",cwStringNullGuard(var_label),sfx_id,cwStringNullGuard(inst->label));
+      return rc;
+    }
     
     rc_t _validate_var_assignment( variable_t* var, unsigned typeFl )
     {
       if( cwIsFlag(var->varDesc->flags, kSrcVarFl ) )
         return cwLogError(kInvalidStateRC, "The variable '%s:%i' on instance '%s:%i' cannot be set because it is a 'src' variable.", var->label, var->label_sfx_id, var->inst->label,var->inst->label_sfx_id);
-      
+      /*
       if( !cwIsFlag(var->varDesc->type, typeFl ) )
         return cwLogError(kTypeMismatchRC, "The variable '%s:%i' on instance '%s:%i' is not a  '%s'.", var->label, var->label_sfx_id, var->inst->label, var->inst->label_sfx_id, _typeFlagToLabel( typeFl ));
-
+      */
+      
       return kOkRC;
     }
 
+    void _var_print( const variable_t* var )
+    {
+      const char* conn_label  = is_connected_to_source_proc(var) ? "extern" : "      ";
+    
+      printf("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
+    
+      if( var->value == nullptr )
+        _value_print( &var->local_value[0] );
+      else
+        _value_print( var->value );
+
+      if( var->src_var != nullptr )
+        printf(" src:%s:%i.%s:%i",var->src_var->inst->label,var->src_var->inst->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
+
+      printf("\n");    
+    }
+    
+    
     rc_t _var_broadcast_new_value( variable_t* var )
     {
       rc_t rc = kOkRC;
       
       // notify each connected var that the value has changed
-      for(variable_t* con_var = var->connect_link; con_var!=nullptr; con_var=con_var->connect_link)
+      for(variable_t* con_var = var->dst_head; con_var!=nullptr; con_var=con_var->dst_link)
       {
         // the var->local_value[] slot used by the source variable may have changed - update the destination variable
         // so that it points to the correct value.
         con_var->value = var->value;
-       
-        //if((rc = con_var->inst->class_desc->members->value( con_var->inst, con_var )) != kOkRC )
-        //  break;
-       
+        
+        cwLogMod("%s:%i %s:%i -> %s:%i %s:%i\n",
+                 var->inst->label,var->inst->label_sfx_id,
+                 var->label,var->label_sfx_id,
+                 con_var->inst->label,con_var->inst->label_sfx_id,
+                 con_var->label,con_var->label_sfx_id );
+
+        // Call the value() function on the connected variable
+        if((rc = var_call_custom_value_func(con_var)) != kOkRC )
+          break;
+               
       }
       return rc;
     }
 
-    template< typename T >
-    void _var_setter( variable_t* var, unsigned local_value_idx, T val )
-    {
-      cwLogError(kAssertFailRC,"Unimplemented variable setter.");
-      assert(0);
-    }
 
-    template<>
-    void _var_setter<bool>( variable_t* var, unsigned local_value_idx, bool val )
-    {
-      var->local_value[ local_value_idx ].u.b   = val;
-      var->local_value[ local_value_idx ].flags = kBoolTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %i (bool).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
-    }
-
-    template<>
-    void _var_setter<unsigned>( variable_t* var, unsigned local_value_idx, unsigned val )
-    {
-      var->local_value[ local_value_idx ].u.u   = val;
-      var->local_value[ local_value_idx ].flags = kUIntTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %i (uint).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
-    }
-
-    template<>
-    void _var_setter<int>( variable_t* var, unsigned local_value_idx, int val )
-    {
-      var->local_value[ local_value_idx ].u.i   = val;
-      var->local_value[ local_value_idx ].flags = kIntTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %i (int).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
-    }
-
-    template<>
-    void _var_setter<float>( variable_t* var, unsigned local_value_idx, float val )
-    {
-      var->local_value[ local_value_idx ].u.f   = val;
-      var->local_value[ local_value_idx ].flags = kFloatTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %f (float).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
-    }
-
-    template<>
-    void _var_setter<double>( variable_t* var, unsigned local_value_idx, double val )
-    {
-      var->local_value[ local_value_idx ].u.d   = val;
-      var->local_value[ local_value_idx ].flags = kDoubleTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %f (double).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
-    }
-
-    template<>
-    void _var_setter<const char*>( variable_t* var, unsigned local_value_idx, const char* val )
-    {      
-      var->local_value[ local_value_idx ].u.s   = mem::duplStr(val);
-      var->local_value[ local_value_idx ].flags = kStringTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %s (string).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,val);
-    }
-
-    template<>
-    void _var_setter<abuf_t*>( variable_t* var, unsigned local_value_idx, abuf_t* val )
-    {
-      var->local_value[ local_value_idx ].u.abuf   = val;
-      var->local_value[ local_value_idx ].flags = kABufTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %s (abuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,abuf==nullptr ? "null" : "valid");
-    }
-
-    template<>
-    void _var_setter<mbuf_t*>( variable_t* var, unsigned local_value_idx, mbuf_t* val )
-    {
-      var->local_value[ local_value_idx ].u.mbuf   = val;
-      var->local_value[ local_value_idx ].flags = kMBufTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %s (abuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,mbuf==nullptr ? "null" : "valid");
-    }
     
-    template<>
-    void _var_setter<fbuf_t*>( variable_t* var, unsigned local_value_idx, fbuf_t* val )
-    {
-      var->local_value[ local_value_idx ].u.fbuf = val;
-      var->local_value[ local_value_idx ].flags  = kFBufTFl;
-      cwLogMod("%s:%i.%s:%i ch:%i %s (fbuf).",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->chIdx,fbuf==nullptr ? "null" : "valid");
-    }
-        
-    template< typename T >
-    rc_t _var_set_template( variable_t* var, unsigned typeFlag, T val )
+    // 'typeFlag' is the type (tflag) of 'val'.
+    template< typename T >    
+    rc_t _var_set_template( variable_t* var, unsigned argTypeFlag, T val )
     {
       rc_t rc;
-      
+      // var->type is the allowable type for this var's value.
+      unsigned value_type_flag    = var->type;
+
       unsigned next_local_value_idx = (var->local_value_idx + 1) % kLocalValueN;
       
       // store the pointer to the current value of this variable
       value_t* original_value     = var->value;
       unsigned original_value_idx = var->local_value_idx;
-
+      
       // verify that this is a legal assignment
-      if((rc = _validate_var_assignment( var, typeFlag )) != kOkRC )
-      {        
+      if((rc = _validate_var_assignment( var, argTypeFlag )) != kOkRC )
         goto errLabel;
-      }
       
       // release the previous value in the next slot
       _value_release(&var->local_value[next_local_value_idx]);
 
+      // if the value type of this variable has not been established
+      if( value_type_flag == kInvalidTFl  )
+      {
+        // if the var desc is a single type then use that ....
+        if( math::isPowerOfTwo(var->varDesc->type) )
+          value_type_flag = var->varDesc->type;
+        else // ... Otherwise select a type from the one of the possible flags given by the var desc
+          value_type_flag = var->varDesc->type & argTypeFlag;
+
+        // if the incoming type is not in the set of allowable types then it is an error
+        if( value_type_flag == 0  )
+        {
+          rc = cwLogError(kTypeMismatchRC,"The type 0x%x is not valid for the variable: %s:%i %s:%i type:0x%x.",
+                          argTypeFlag,var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->varDesc->type);
+          goto errLabel;
+        }
+      }
+      
+      // set the type of the LHS to force the incoming value to be coerced to this type
+      var->local_value[ next_local_value_idx ].tflag = value_type_flag;
+
       // set the new local value
-      _var_setter(var,next_local_value_idx,val);
+      if((rc = _val_set(var->local_value + next_local_value_idx, val )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Value set failed on '%s:%i %s:%i",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id);
+        goto errLabel;
+      }
 
       // make the new local value current
       var->value           = var->local_value + next_local_value_idx;
@@ -597,9 +843,11 @@ namespace cw
         // call because calls' to 'proc.value()' will see the instance in a incomplete state)
         // Note 2: If this call returns an error then the value assignment is cancelled
         // and the value does not change.
-        rc = var->inst->class_desc->members->value( var->inst, var );        
+        var_call_custom_value_func( var );
       }
 
+      //printf("%p set: %s:%s  0x%x\n",var->value, var->inst->label,var->label,var->value->tflag);
+
       if( rc == kOkRC )
       {
         // send the value to connected downstream proc's
@@ -617,25 +865,11 @@ namespace cw
     }
     
     
-    bool is_connected_to_source_proc( const variable_t* var )
-    {
-      // if this var does not have a 'src_ptr' then it can't be connected to an external proc
-      if( var->src_var == nullptr || var->value == nullptr )
-        return false;
-
-      // if this var is using a local value then it can't be connected to an external proc
-      for(unsigned i=0; i<kLocalValueN; ++i)
-        if( var->value == var->local_value + i )
-          return false;
-
-      return true;
-    }
-
-    bool is_a_source_var( const variable_t* var )
-    { return var->connect_link != nullptr; }
+    
 
+    // 'valueTypeFlag' is the type (tflag) of 'value'
     template< typename T >
-    rc_t _var_set_driver( variable_t* var, unsigned typeFlag, T value )
+    rc_t _var_set_driver( variable_t* var, unsigned valueTypeFlag, T value )
     {
       rc_t rc;
 
@@ -647,15 +881,18 @@ namespace cw
       // if this assignment targets a specific channel ...
       if( var->chIdx != kAnyChIdx )
       {
-        rc = _var_set_template( var, typeFlag, value ); // ...  then set it alone
+        rc = _var_set_template( var, valueTypeFlag, value ); // ...  then set it alone
       }
       else // ... otherwise set all channels.
       {
         for(; var!=nullptr; var=var->ch_link)
-          if((rc = _var_set_template( var, typeFlag, value )) != kOkRC)
+          if((rc = _var_set_template( var, valueTypeFlag, value )) != kOkRC)
             break;
       }
 
+      if(rc != kOkRC )
+        rc = cwLogError(rc,"Variable value set failed on '%s:%i %s:%i",cwStringNullGuard(var->inst->label),var->inst->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id);
+      
       return rc;
     }
 
@@ -703,24 +940,77 @@ namespace cw
     {
       rc_t rc = kOkRC;
 
-      // get the variable type - note that the value type (value->flags) may be differnt
-      unsigned typeFlag = var->varDesc->type & kTypeMask;
+      // Determine the flow variable type of cfg. argument 'value'.
+      unsigned value_flag = 0;
       
-      switch( typeFlag )
+      switch( value->type->id )
+      {
+        case kCharTId:  
+        case kUInt8TId:
+        case kUInt16TId:
+        case kUInt32TId:
+          value_flag = kUIntTFl;
+          break;
+          
+        case kInt8TId:
+        case kInt16TId:
+        case kInt32TId:
+          value_flag = kIntTFl;
+          break;
+          
+        case kInt64TId:
+        case kUInt64TId:
+          rc = cwLogError(kInvalidArgRC,"The flow system does not currently implement 64bit integers.");
+          goto errLabel;
+          break;
+          
+        case kFloatTId:
+          value_flag = kFloatTFl;
+          break;
+          
+        case kDoubleTId:
+          value_flag = kDoubleTFl;
+          break;
+          
+        case kBoolTId:
+          value_flag = kBoolTFl;
+          break;
+          
+        case kStringTId:
+        case kCStringTId:
+          value_flag = kStringTFl;
+          break;
+          
+        default:
+          value_flag = kCfgTFl;
+        
+      }
+
+      /*
+      if( !cwIsFlag(var->varDesc->type & kTypeMask, value_flag) )
+      {
+        rc = cwLogError(kTypeMismatchRC,"The var desc class type 0x%x does not permit the var to be instantiated with the type %s (0x%x).",var->varDesc->type,_typeFlagToLabel(value_flag),value_flag);
+        goto errLabel;
+      }
+      */
+      
+      switch( value_flag )
       {
         case kBoolTFl:
           {
             bool v;
+            // assign the value of 'value' to to 'v' (do type conversion if necessary)
             if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, typeFlag, v );
+              // set the value of 'var' where 'v' is the new value and 'value_flag' is the type of 'v'.
+              rc = _var_set_driver( var, value_flag, v );
           }
-          break;
+           break;
           
         case kUIntTFl:
           {
             unsigned v;
             if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, typeFlag, v );
+              rc = _var_set_driver( var, value_flag, v );
           }
           break;
           
@@ -728,7 +1018,7 @@ namespace cw
           {
             int v;
             if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, typeFlag, v );
+              rc = _var_set_driver( var, value_flag, v );
           }
           break;
           
@@ -736,7 +1026,7 @@ namespace cw
           {
             float v;
             if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, typeFlag, v );
+              rc = _var_set_driver( var, value_flag, v );
           }
           break;
 
@@ -744,7 +1034,7 @@ namespace cw
           {
             double v;
             if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, typeFlag, v );
+              rc = _var_set_driver( var, value_flag, v );
           }
           break;
           
@@ -752,21 +1042,31 @@ namespace cw
           {
             const char* v;
             if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, typeFlag, v );
+              rc = _var_set_driver( var, value_flag, v );
           }
           break;
 
-        default:
-          rc = cwLogError(kOpFailRC,"The variable type 0x%x cannot yet be set via a preset.", var->varDesc->type );
+        case kCfgTFl:
+          {
+            //const object_t* v;
+            //if((rc = value->value(v)) == kOkRC )
+            rc = _var_set_driver( var, value_flag, value );
+          }
+          break;
+          
+       default:
+          rc = cwLogError(kOpFailRC,"The variable type 0x%x cannot yet be set via a cfg.", var->varDesc->type );
           goto errLabel;
       }
 
     errLabel:
       if( rc != kOkRC )
         rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
+      
       return rc;
       
     }
+    
 
     rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef )
     {
@@ -830,9 +1130,51 @@ namespace cw
       
     }
 
+    /*
+    void _var_set_value_to_typed_null( variable_t* var, unsigned type_flag )
+    {
+      for(unsigned i=0; i<kLocalValueN; ++i)
+      {
+        assert( var->local_value[i].tflag == kInvalidTFl );
+        
+        // set the var-value to a typed null value - this will force later settings to be coerced to this type
+        set_null( var->local_value[i], type_flag );
+      }
+
+      var->value = var->local_value;
+      
+    }
+    */
+    
+    rc_t _var_set_type( variable_t* var, unsigned type_flag )
+    {
+      rc_t rc = kOkRC;
+
+      if( cwIsNotFlag(var->classVarDesc->type,kRuntimeTFl) )
+      {
+        rc = cwLogError(kOpFailRC,"It is invalid to change the type of a statically (non-runtime) type variable.");
+        goto errLabel;
+      }
+      
+      if( var->localVarDesc == nullptr )
+      {
+        var->localVarDesc    = mem::allocZ<var_desc_t>();
+        *(var->localVarDesc) = *(var->classVarDesc);
+        var->localVarDesc->link = nullptr;    
+      }
+  
+      var->localVarDesc->type = type_flag;
+      var->varDesc            = var->localVarDesc;
+
+      //_var_set_value_to_typed_null(var,type_flag);
+      
+    errLabel:
+      return rc;
+    }
+    
     // Create a variable and set it's value from 'value_cfg'.
     // If 'value_cfg' is null then use the value from var->varDesc->val_cfg.
-    rc_t _var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
+    rc_t _var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFl, variable_t*& varRef )
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
@@ -858,19 +1200,24 @@ namespace cw
       var = mem::allocZ<variable_t>();
 
       var->varDesc      = vd;
+      var->classVarDesc = vd;
       var->inst         = inst;
       var->label        = mem::duplStr(var_label);
       var->label_sfx_id = sfx_id;
       var->vid          = id;
       var->chIdx        = chIdx;
       var->value        = nullptr;
+      var->type         = kInvalidTFl;
 
+      if( altTypeFl != kInvalidTFl )
+        _var_set_type(var,altTypeFl);
+      
       // if no value was given then set the value to the value given in the class
       if( value_cfg == nullptr )
         value_cfg = var->varDesc->val_cfg;
 
       // if value_cfg is valid set the variable value
-      if( value_cfg != nullptr )
+      if( value_cfg != nullptr && cwIsNotFlag(vd->type,kRuntimeTFl))
         if((rc = _set_var_value_from_cfg( var, value_cfg )) != kOkRC )
           goto errLabel;
 
@@ -897,23 +1244,6 @@ namespace cw
       return rc;
     }
 
-    void _var_print( const variable_t* var )
-    {
-      const char* conn_label  = is_connected_to_source_proc(var) ? "extern" : "      ";
-    
-      printf("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
-    
-      if( var->value == nullptr )
-        _value_print( &var->local_value[0] );
-      else
-        _value_print( var->value );
-
-      if( var->src_var != nullptr )
-        printf(" src:%s:%i.%s:%i",var->src_var->inst->label,var->src_var->inst->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
-
-      printf("\n");    
-    }
-    
     
     rc_t _preset_set_var_value( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value )
     {
@@ -932,9 +1262,6 @@ namespace cw
 
       return rc;
     }
-
-
-    
   }
 }
 
@@ -1042,7 +1369,6 @@ cw::flow::fbuf_t* cw::flow::fbuf_create( srate_t srate, unsigned chN, const unsi
   return f;  
 }
 
-
 cw::flow::fbuf_t*  cw::flow::fbuf_create( srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   unsigned maxBinN_V[ chN ];
@@ -1053,11 +1379,8 @@ cw::flow::fbuf_t*  cw::flow::fbuf_create( srate_t srate, unsigned chN, unsigned
   vop::fill( binN_V, chN, binN );
   vop::fill( hopSmpN_V, chN, binN );
   return fbuf_create( srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV );
-
 }
 
-
-
 void cw::flow::fbuf_destroy( fbuf_t*& fbuf )
 {
   if( fbuf == nullptr )
@@ -1120,6 +1443,9 @@ unsigned cw::flow::value_type_label_to_flag( const char* s )
   return flags;
 }
 
+const char* cw::flow::value_type_flag_to_label( unsigned flag )
+{  return _typeFlagToLabel(flag); }
+  
 
 cw::flow::class_desc_t* cw::flow::class_desc_find( flow_t* p, const char* label )
 {
@@ -1186,6 +1512,48 @@ void cw::flow::network_print( const network_t& net )
   }
 }
 
+cw::rc_t cw::flow::instance_validate( instance_t* inst )
+{
+  rc_t rc = kOkRC;
+
+  for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+  {
+    if( var->label == nullptr )
+    {
+      rc = cwLogError(kInvalidStateRC,"A var with no label was encountered.");
+      continue;      
+    }
+    
+    if( var->value == nullptr )
+    {
+      rc = cwLogError(kInvalidStateRC,"The var '%s:%i' has no value.",var->label,var->label_sfx_id);
+      continue;      
+    }
+
+    if(!math::isPowerOfTwo( var->value->tflag ) )
+    {
+      rc = cwLogError(kInvalidStateRC,"The var '%s:%i' has the invalid type flag:0x%x",var->label,var->label_sfx_id,var->value->tflag);
+      continue;
+    }
+
+    if( !(var->varDesc->type & var->value->tflag) )
+    {
+      rc = cwLogError(kInvalidStateRC, "The value type flag '%s' (0x%x) of the var '%s:%i' is not found in the variable class type flags: '%s' (0x%x)",
+                      _typeFlagToLabel(var->value->tflag),var->value->tflag,
+                      var->label,var->label_sfx_id,
+                      _typeFlagToLabel(var->varDesc->type),var->varDesc->type);
+      continue;
+    }
+
+    // By setting the var->type field all future assignments to this variable
+    // must be coercible to this type.  See _var_set_template()
+    var->type = var->value->tflag;
+  }
+  
+  return rc;
+}
+
+
 cw::flow::instance_t* cw::flow::instance_find( network_t& net, const char* inst_label, unsigned sfx_id )
 {
   for(unsigned i=0; i<net.proc_arrayN; ++i)
@@ -1231,6 +1599,14 @@ void cw::flow::instance_print( instance_t* inst )
     inst->class_desc->members->report( inst );
 }
 
+unsigned cw::flow::instance_var_count( instance_t* inst )
+{
+  unsigned n = 0;
+  for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+    ++n;
+
+  return n;
+}
 
 
 void cw::flow::_var_destroy( variable_t* var )
@@ -1239,17 +1615,21 @@ void cw::flow::_var_destroy( variable_t* var )
   {
     for(unsigned i=0; i<kLocalValueN; ++i)
       _value_release(var->local_value+i);
+
+    if( var->localVarDesc != nullptr )
+      mem::release(var->localVarDesc);
+    
     mem::release(var->label);
     mem::release(var);
   }
 }
 
 
-cw::rc_t cw::flow::var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
+cw::rc_t cw::flow::var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFl, variable_t*& varRef )
 {
   rc_t rc = kOkRC;
- 
-  rc = _var_create( inst, var_label, sfx_id, id, chIdx, value_cfg, varRef );
+
+  rc = _var_create( inst, var_label, sfx_id, id, chIdx, value_cfg, altTypeFl, varRef );
 
   return rc;
 }
@@ -1281,7 +1661,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   if( var == nullptr && chIdx != kAnyChIdx )
   {
     // create the channelized var
-    if((rc = _var_create( inst, var_label, sfx_id, vid, chIdx, value_cfg, var )) != kOkRC )
+    if((rc = _var_create( inst, var_label, sfx_id, vid, chIdx, value_cfg, kInvalidTFl, var )) != kOkRC )
       goto errLabel;
 
     // if no value was set then set the value from the 'any' channel
@@ -1321,6 +1701,85 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   return rc;
 }
 
+cw::rc_t cw::flow::var_call_custom_value_func( variable_t* var )
+{
+  rc_t rc;
+  if((rc = var->inst->class_desc->members->value( var->inst, var )) != kOkRC )
+    goto errLabel;
+  
+  if( var->flags & kLogVarFl )
+  {
+    printf("%10s:%5i", var->inst->label,var->inst->label_sfx_id);
+    _var_print(var);
+  }
+  
+errLabel:
+  return rc;
+  
+}
+
+cw::rc_t cw::flow::var_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref )
+{
+  rc_t        rc  = kOkRC;
+  variable_t* var = nullptr;
+  
+  flags_ref = 0;
+  
+  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+    goto errLabel;
+
+  flags_ref = var->flags;
+
+errLabel:
+  return rc;
+}
+    
+cw::rc_t cw::flow::var_set_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flag )
+{
+  rc_t        rc  = kOkRC;
+  variable_t* var = nullptr;
+  
+  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+    goto errLabel;
+  
+
+  var->flags |= flag;
+
+errLabel:
+  return rc;
+}
+    
+cw::rc_t cw::flow::var_clr_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flag )
+{
+  rc_t        rc  = kOkRC;
+  variable_t* var = nullptr;
+  
+  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+    goto errLabel;
+
+  var->flags = cwClrFlag(var->flags,flag);
+errLabel:
+  return rc;
+}
+/*
+cw::rc_t cw::flow::var_set_type( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned type_flag )  
+{
+  rc_t rc = kOkRC;
+  variable_t* var = nullptr;
+  
+  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+    goto errLabel;
+
+  rc = _var_set_type(var,type_flag);
+  
+errLabel:
+  if( rc != kOkRC )
+    rc = cwLogError(rc,"Type set failed on the variable:'%s:%i",cwStringNullGuard(var_label),sfx_id);
+  
+  return rc;
+}
+*/            
+
 bool cw::flow::var_exists( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
 { return _var_find_on_label_and_ch(inst,label,sfx_id,chIdx) != nullptr; }
 
@@ -1492,6 +1951,60 @@ cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsign
   return rc;
 }
 
+bool cw::flow::is_connected_to_source_proc( const variable_t* var )
+{
+  // if this var does not have a 'src_ptr' then it can't be connected to an external proc
+  if( var->src_var == nullptr || var->value == nullptr )
+    return false;
+
+  // if this var is using a local value then it can't be connected to an external proc
+  for(unsigned i=0; i<kLocalValueN; ++i)
+    if( var->value == var->local_value + i )
+      return false;
+
+  return true;
+}
+
+bool cw::flow::is_a_source_var( const variable_t* var )
+{ return var->dst_head != nullptr; }
+
+cw::rc_t  cw::flow::var_mult_sfx_id_array( instance_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref )
+{
+  rc_t rc = kOkRC;
+
+  idN_ref = 0;
+
+  // for each variable whose 'label' is 'var_label'
+  for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+    if( textIsEqual(var->label,var_label) )
+    {
+      // scan idA[] for a matching sfx_id
+      unsigned i=0;
+      for(; i<idN_ref; ++i)
+        if( idA[i] == var->label_sfx_id )
+          break;
+
+      // if the sfx_id of this var has not yet been included in idA[]
+      if( i == idN_ref )
+      {
+        // ... and we still have space left in the output arrau
+        if( idN_ref >= idAllocN )
+        {
+          rc = cwLogError(kBufTooSmallRC,"The mult-sfx-id result array is too small for the var:'%s'.",cwStringNullGuard(var_label));
+          goto errLabel;
+        }
+
+        // store this sfx_id in idA[]
+        idA[idN_ref++] = var->label_sfx_id;
+      }
+    }
+  
+errLabel:
+  if( rc != kOkRC )
+    idN_ref = 0;
+  
+  return rc;
+}
 
 cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, variable_t*& varRef )
 {
@@ -1588,6 +2101,54 @@ cw::rc_t  cw::flow::var_get( const variable_t* var, const mbuf_t*& valRef )
 cw::rc_t  cw::flow::var_get( variable_t* var, mbuf_t*& valRef )
 { return _val_get_driver(var,valRef); }
 
+cw::rc_t  cw::flow::var_get( const variable_t* var, const object_t*& valRef )
+{ return _val_get_driver(var,valRef); }
+
+cw::rc_t cw::flow::var_set( variable_t* var, const value_t* val )
+{
+  rc_t rc = kOkRC;
+  
+  switch( val->tflag )
+  {
+    case kBoolTFl:   rc = _var_set_driver(var,val->tflag,val->u.b); break;
+    case kUIntTFl:   rc = _var_set_driver(var,val->tflag,val->u.u); break;
+    case kIntTFl:    rc = _var_set_driver(var,val->tflag,val->u.i); break;
+    case kFloatTFl:  rc = _var_set_driver(var,val->tflag,val->u.f); break;
+    case kDoubleTFl: rc = _var_set_driver(var,val->tflag,val->u.d); break;
+    case kStringTFl: rc = _var_set_driver(var,val->tflag,val->u.s); break;
+    case kCfgTFl:    rc = _var_set_driver(var,val->tflag,val->u.cfg); break;
+    case kABufTFl:   rc = _var_set_driver(var,val->tflag,val->u.abuf); break;
+    case kFBufTFl:   rc = _var_set_driver(var,val->tflag,val->u.fbuf); break;
+    case kMBufTFl:   rc = _var_set_driver(var,val->tflag,val->u.mbuf); break;
+    default:
+      rc = cwLogError(kNotImplementedRC,"The var_set() from value_t has not been implemented for the type 0x%x.",val->tflag);
+  }
+
+  return rc;
+}
+
+
+cw::rc_t cw::flow::var_set( variable_t* var, bool val )            { return _var_set_driver(var,kBoolTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, uint_t val )          { return _var_set_driver(var,kUIntTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, int_t val )           { return _var_set_driver(var,kIntTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, float val )           { return _var_set_driver(var,kFloatTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, double val )          { return _var_set_driver(var,kDoubleTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, const char* val )     { return _var_set_driver(var,kStringTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, abuf_t* val )         { return _var_set_driver(var,kABufTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, fbuf_t* val )         { return _var_set_driver(var,kFBufTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, mbuf_t* val )         { return _var_set_driver(var,kMBufTFl,val); }
+cw::rc_t cw::flow::var_set( variable_t* var, const object_t* val ) { return _var_set_driver(var,kCfgTFl,val); }
+
+cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, const value_t* val )
+{
+  rc_t        rc  = kOkRC;
+  variable_t* var = nullptr;
+  
+  if((rc = _var_find_to_set(inst, vid, chIdx, val->tflag, var )) == kOkRC )
+    rc = var_set(var,val);
+  
+  return rc;
+}    
 
 cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool val )
 {
@@ -1595,7 +2156,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool
   variable_t* var = nullptr;
   
   if((rc = _var_find_to_set(inst, vid, chIdx, kBoolTFl, var )) == kOkRC )
-    _var_set_driver( var, kBoolTFl, val );
+    rc = _var_set_driver( var, kBoolTFl, val );
   
   return rc;    
 }
@@ -1606,7 +2167,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, uint
   variable_t* var = nullptr;
   
   if((rc = _var_find_to_set(inst, vid, chIdx, kUIntTFl, var )) == kOkRC )
-    _var_set_driver( var, kUIntTFl, val );
+    rc = _var_set_driver( var, kUIntTFl, val );
   
   return rc;    
 }
@@ -1617,7 +2178,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, int_
   variable_t* var = nullptr;
   
   if((rc = _var_find_to_set(inst, vid, chIdx, kIntTFl, var )) == kOkRC )
-    _var_set_driver( var, kIntTFl, val );
+    rc = _var_set_driver( var, kIntTFl, val );
   
   return rc;    
 }
@@ -1628,7 +2189,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, floa
   variable_t* var = nullptr;
   
   if((rc = _var_find_to_set(inst, vid, chIdx, kFloatTFl, var )) == kOkRC )
-    _var_set_driver( var, kFloatTFl, val );
+    rc = _var_set_driver( var, kFloatTFl, val );
   
   return rc;    
 }
@@ -1639,7 +2200,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, doub
   variable_t* var = nullptr;
   
   if((rc = _var_find_to_set(inst, vid, chIdx, kDoubleTFl, var )) == kOkRC )
-    _var_set_driver( var, kDoubleTFl, val );
+    rc = _var_set_driver( var, kDoubleTFl, val );
   
   return rc;    
 }
@@ -1650,11 +2211,23 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, cons
   variable_t* var = nullptr;
   
   if((rc = _var_find_to_set(inst, vid, chIdx, kStringTFl, var )) == kOkRC )
-    _var_set_driver( var, kStringTFl, val );
+    rc = _var_set_driver( var, kStringTFl, val );
   
   return rc;    
 }
 
+cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, const object_t* val )
+{
+  rc_t        rc  = kOkRC;
+  variable_t* var = nullptr;
+  
+  if((rc = _var_find_to_set(inst, vid, chIdx, kCfgTFl, var )) == kOkRC )
+    rc = _var_set_driver( var, kCfgTFl, val );
+  
+  return rc;    
+}
+
+
 const cw::flow::preset_t* cw::flow::class_preset_find( class_desc_t* cd, const char* preset_label )
 {
   const preset_t* pr;
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index a0ae0c7..3116516 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -40,11 +40,11 @@ namespace cw
       unsigned*         maxBinN_V; // max value that binN_V[i] is allowed to take
       unsigned*         binN_V;    // binN_V[ chN ] count of sample frames per channel
       unsigned*         hopSmpN_V; // hopSmpN_V[ chN ] hop sample count 
-      fd_sample_t**       magV;      // magV[ chN ][ binN ]
-      fd_sample_t**       phsV;      // phsV[ chN ][ binN ]
-      fd_sample_t**       hzV;       // hzV[ chN ][ binN ]
+      fd_sample_t**     magV;      // magV[ chN ][ binN ]
+      fd_sample_t**     phsV;      // phsV[ chN ][ binN ]
+      fd_sample_t**     hzV;       // hzV[ chN ][ binN ]
       bool*             readyFlV;  // readyFlV[chN] true if this channel is ready to be processed (used to sync. fbuf rate to abuf rate)
-      fd_sample_t*        buf;       // memory used by this buffer (or NULL if magV,phsV,hzV point are proxied to another buffer)      
+      fd_sample_t*      buf;       // memory used by this buffer (or NULL if magV,phsV,hzV point are proxied to another buffer)      
     } fbuf_t;
 
     typedef struct mbuf_str
@@ -78,6 +78,8 @@ namespace cw
 
       kTypeMask    = 0x0000ffff,
 
+      kRuntimeTFl  = 0x80000000
+
     };
 
     typedef struct mtx_str
@@ -92,7 +94,8 @@ namespace cw
     
     typedef struct value_str
     {
-      unsigned flags;
+      unsigned tflag;
+      
       union {
         bool            b;
         uint_t          u;
@@ -108,6 +111,7 @@ namespace cw
         char*           s;
         
         const object_t* cfg;
+        void* p;
 
       } u;
       
@@ -116,8 +120,9 @@ namespace cw
     } value_t;
 
 
-    inline bool is_numeric( const value_t* v ) { return cwIsFlag(v->flags,kBoolTFl|kUIntTFl|kIntTFl|kFloatTFl|kDoubleTFl); }
-    inline bool is_matrix(  const value_t* v ) { return cwIsFlag(v->flags,kBoolMtxTFl|kUIntMtxTFl|kIntMtxTFl|kFloatMtxTFl|kDoubleMtxTFl); }
+    inline void set_null( value_t& v, unsigned tflag ) { v.tflag=tflag; v.u.p=nullptr; }
+    inline bool is_numeric( const value_t* v ) { return cwIsFlag(v->tflag,kBoolTFl|kUIntTFl|kIntTFl|kFloatTFl|kDoubleTFl); }
+    inline bool is_matrix(  const value_t* v ) { return cwIsFlag(v->tflag,kBoolMtxTFl|kUIntMtxTFl|kIntMtxTFl|kFloatMtxTFl|kDoubleMtxTFl); }
         
     struct instance_str;
     struct variable_str;
@@ -170,24 +175,40 @@ namespace cw
       unsigned          polyLimitN; // max. poly copies of this class per network_t or 0 if no limit
     } class_desc_t;
 
+    enum {
+      kInvalidVarFl = 0x00,
+      kLogVarFl     = 0x01
+    };
 
     // Note: The concatenation of 'vid' and 'chIdx' should form a unique identifier among all variables
     // on a given 'instance'.
     typedef struct variable_str
     {
       struct instance_str* inst;         // pointer to this variables instance
+      
       char*                label;        // this variables label
-      unsigned             label_sfx_id; // the label suffix id of this variable or kInvalidIdx if this has no suffix
-      unsigned             vid;          // this variables numeric id ( cat(vid,chIdx) forms a unique variable identifier on this 'inst'
-      var_desc_t*          varDesc;      // the variable description for this variable
-      value_t              local_value[ kLocalValueN ];  // the local value instance (actual value if this is not a 'src' variable)
-      unsigned             local_value_idx; // local_value[] is double buffered to allow the cur value of the buf[] to be held while the next value is validated (see _var_set_template())
-      value_t*             value;        // pointer to the value associated with this variable   
+      unsigned             label_sfx_id; // the label suffix id of this variable or kInvalidIdx if this has no suffix      
+      unsigned             vid;          // this variables numeric id ( cat(vid,chIdx) forms a unique variable identifier on this 'inst'      
       unsigned             chIdx;        // channel index
-      struct variable_str* src_var;      // pointer to this input variables source link (or null if it uses the local_value)
-      struct variable_str* var_link;     // instance.varL link list
-      struct variable_str* connect_link; // list of outgoing connections
+      unsigned             flags;        // kLogVarFl
+      unsigned             type;         // This is the value type as established when the var is initialized - it never changes for the life of the var.
+            
+      var_desc_t*          classVarDesc; // pointer to this variables class var desc
+      var_desc_t*          localVarDesc; // pointer to this variables local var desc - if it doesn't match classVarDesc.
+      var_desc_t*          varDesc;      // the effective variable description for this variable (set to classVarDesc or localVarDesc)
+      
+      value_t              local_value[ kLocalValueN ]; // the local value instance (actual value if this is not a 'src' variable)
+      unsigned             local_value_idx;             // local_value[] is double buffered to allow the cur value of the buf[] to be held while the next value is validated (see _var_set_template())
+      struct variable_str* src_var;                     // pointer to this input variables source link (or null if it uses the local_value)
+      value_t*             value;                       // pointer to the value associated with this variable
+      
+      struct variable_str* var_link;     // instance.varL list link
       struct variable_str* ch_link;      // list of channels that share this variable (rooted on 'any' channel - in order by channel number)
+
+      struct variable_str* dst_head;     // Pointer to list of out-going connections (null on var's that do not have out-going connections)
+      struct variable_str* dst_tail;     // 
+      struct variable_str* dst_link;     // Link used by dst_head list.
+
     } variable_t;
 
     
@@ -277,11 +298,13 @@ namespace cw
     void           mbuf_destroy( mbuf_t*& buf );
     mbuf_t*        mbuf_duplicate( const mbuf_t* src );
     
-    inline bool    value_is_abuf( const value_t* v ) { return v->flags & kABufTFl; }
-    inline bool    value_is_fbuf( const value_t* v ) { return v->flags & kFBufTFl; }
+    inline bool    value_is_abuf( const value_t* v ) { return v->tflag & kABufTFl; }
+    inline bool    value_is_fbuf( const value_t* v ) { return v->tflag & kFBufTFl; }
 
     unsigned       value_type_label_to_flag( const char* type_desc );
-
+    const char*    value_type_flag_to_label( unsigned flag );
+    
+    
     //------------------------------------------------------------------------------------------------------------------------
     //
     // Class and Variable Description
@@ -305,6 +328,8 @@ namespace cw
     //
     // Instance
     //
+
+    rc_t               instance_validate( instance_t* inst );
     
     instance_t*        instance_find( network_t& net, const char* inst_label, unsigned sfx_id );
     rc_t               instance_find( network_t& net, const char* inst_label, unsigned sfx_id, instance_t*& instPtrRef );
@@ -313,6 +338,9 @@ namespace cw
 
     void               instance_print( instance_t* inst );
 
+    // Count of all var instances on this proc.  This is a count of the length of inst->varL.
+    unsigned           instance_var_count( instance_t* inst );
+
 
     
     //------------------------------------------------------------------------------------------------------------------------
@@ -321,13 +349,26 @@ namespace cw
     //
 
     // Create a variable but do not assign it a value.  Return a pointer to the new variable.
-    // Note: `value_cfg` is optional. Set it to NULL to ignore
-    rc_t           var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
+    // Notes:
+    // 1) `value_cfg` is optional. Set it to NULL to ignore
+    // 2) If `altTypeFl` is not set to kInvalidTFl then the var is assigned this type.
+    rc_t           var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFlag, variable_t*& varRef );
 
     // Channelizing creates a new var record with an explicit channel index to replace the
     // automatically generated variable whose channel index is set to  'all'.
     rc_t           var_channelize( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
 
+    // Set the var. type at runtime.
+    //rc_t           var_set_type( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned type_flags );
+
+    // Wrapper around call to var->inst->members->value()
+    rc_t           var_call_custom_value_func( variable_t* var );
+
+    // Sets and get the var->flags field
+    unsigned       var_flags(     instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref );
+    rc_t           var_set_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
+    rc_t           var_clr_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
+
     // `value_cfg` is optional. Set it to NULL to ignore
     rc_t           var_register( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
@@ -336,8 +377,9 @@ namespace cw
 
     // Return true if this var is acting as a source for another var.
     bool           is_a_source_var( const variable_t* var );
-
-
+    
+    rc_t           var_mult_sfx_id_array( instance_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
+    
     //-----------------
     //
     // var_register
@@ -461,18 +503,19 @@ namespace cw
     rc_t           var_channel_count( const variable_t* var, unsigned& chCntRef );
     
     
-    rc_t           var_get( const variable_t* var, bool&          valRef );
-    rc_t           var_get( const variable_t* var, uint_t&        valRef );
-    rc_t           var_get( const variable_t* var, int_t&         valRef );
-    rc_t           var_get( const variable_t* var, float&         valRef );
-    rc_t           var_get( const variable_t* var, double&        valRef );
-    rc_t           var_get( const variable_t* var, const char*&   valRef );    
-    rc_t           var_get( const variable_t* var, const abuf_t*& valRef );    
-    rc_t           var_get(       variable_t* var, abuf_t*&       valRef );    
-    rc_t           var_get( const variable_t* var, const fbuf_t*& valRef );
-    rc_t           var_get(       variable_t* var, fbuf_t*&       valRef );
-    rc_t           var_get( const variable_t* var, const mbuf_t*& valRef );
-    rc_t           var_get(       variable_t* var, mbuf_t*&       valRef );
+    rc_t var_get( const variable_t* var, bool&            valRef );
+    rc_t var_get( const variable_t* var, uint_t&          valRef );
+    rc_t var_get( const variable_t* var, int_t&           valRef );
+    rc_t var_get( const variable_t* var, float&           valRef );
+    rc_t var_get( const variable_t* var, double&          valRef );
+    rc_t var_get( const variable_t* var, const char*&     valRef );    
+    rc_t var_get( const variable_t* var, const abuf_t*&   valRef );    
+    rc_t var_get(       variable_t* var, abuf_t*&         valRef );    
+    rc_t var_get( const variable_t* var, const fbuf_t*&   valRef );
+    rc_t var_get(       variable_t* var, fbuf_t*&         valRef );
+    rc_t var_get( const variable_t* var, const mbuf_t*&   valRef );
+    rc_t var_get(       variable_t* var, mbuf_t*&         valRef );
+    rc_t var_get( const variable_t* var, const object_t*& valRef );
 
     template< typename T>
     rc_t var_get( instance_t* inst, unsigned vid, unsigned chIdx, T& valRef)
@@ -494,14 +537,28 @@ namespace cw
       return value;
     }
 
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, uint_t val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, int_t val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, float val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, double val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, const char* val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, abuf_t* val );
-    rc_t           var_set( instance_t* inst, unsigned vid, unsigned chIdx, fbuf_t* val );
+    rc_t var_set( variable_t* var, const value_t* val );
+    rc_t var_set( variable_t* var, bool val );
+    rc_t var_set( variable_t* var, uint_t val );
+    rc_t var_set( variable_t* var, int_t val );
+    rc_t var_set( variable_t* var, float val );
+    rc_t var_set( variable_t* var, double val );
+    rc_t var_set( variable_t* var, const char* val );
+    rc_t var_set( variable_t* var, abuf_t* val );
+    rc_t var_set( variable_t* var, fbuf_t* val );
+    rc_t var_set( variable_t* var, mbuf_t* val );
+    rc_t var_set( variable_t* var, const object_t* val );
+    
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const value_t* val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, uint_t val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, int_t val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, float val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, double val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const char* val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, abuf_t* val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, fbuf_t* val );
+    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const object_t* val );
 
     const preset_t* class_preset_find( class_desc_t* cd, const char* preset_label );
     
diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 45eac60..798f8bc 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -23,7 +23,32 @@ and audio processing networks and the application of network state data.
 
 ### Polyphonic Network.
 
-3. Network with sub-nets.
+### Network with sub-nets.
+
+## Proc Instance Syntax:
+
+```
+<label> : { 'class':<class>, "in":{<in_stmt>*}, "preset":<class_preset_label>, "log":<log_dict> "argLabel":<arg_preset_label>, "args":<args_dict> }
+```
+
+__args__ : This is a dictionary of named variable value records. 
+__preset__ : This string references a class preset to use for initializing this proc instance.
+__argLabel__ : This string references an `args` dictionary parameter set to be applied after the __preset__ class preset.
+If this argument is not given then it is automatically assigned the value "default". (What if there is not __arg__ record named default?
+What if the are no __arg__ records at all?)
+__log__ : This is a dictionary of `<var_label>:<sfx_id>` pairs whose value should be printed to the console when they change at runtime.
+
+
+Notes: 
+1. All fields except 'class' are optional.
+2. The class preset named by __preset__ is always applied before the __arg__ values referenced by  __argLabel__.
+
+
+
+
+- When a preset is given as a list of values each entry in the list is taken as the value for
+the associated channel.  When a list value is given to a var that is of type 'cfg' the list is passed
+as a single value. 
 
 
 ## Processing Unit Class
@@ -40,6 +65,7 @@ srate  | (float) Sample rate type
 sample | (float) Audio sample type
 coeff  | (float) Value that will be directly applied to a sample value (e.g added or multiplied)
 ftime  | (double) Fractional seconds
+runtime| The type is left up to the processors custom 'create' function. These vars are not automatically created.
 
 See list in cwFlowTypes.cpp : typeLabelFlagsA[]
 
@@ -166,6 +192,11 @@ uint     | `uint32_t`
 real     | `double`
 audio    | multi-channel audio
 spectrum | multi-channel spectrum
+cfg      | 
+srate    | platform defined sample rate type
+sample   | platform defined audio sample type
+coeff    | platform defined signal processing coefficient type
+
 
 ### Variable Flags:
 
@@ -180,7 +211,10 @@ Flag             | Description
 
 Notes:
 1. Unless the `no_src` attribute is set any variable may be connected to a source variable
-in the proc instantation 'in' statement.
+in the proc instantation 'in' statement.  `no_src` variables are output variables whose
+value is calculated by the proc and therefore don't make sense to be fed from 
+some other entity.
+
 
 2. By default all variables are created prior to the proc `create()` function being called.
 Variable with the `no_dflt_create` attribute will not be created.  This is useful in cases

From 040d902c6b81f6fdec028e7fc70916d4bd8a3148 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 2 May 2024 13:59:19 -0400
Subject: [PATCH 041/101] Initial working version of poly_merge and xfade_ctl.
 cwFlowNet._connect_vars() changed to cwFlowTypes.var_connect().
 cwFlowTest._set_var_value_from_cfg() to cwFlowTypes.var_set_from_preset().
 var_channelize() now connects matching channels when they are available.
 Added type 'numeric'. Updated proc_template() to automatically allocate and
 extract inst_t. Added a system sample rate.

---
 cwFlow.cpp      |  90 +--------
 cwFlowNet.cpp   |  27 +--
 cwFlowProc.cpp  | 445 ++++++++++++++++++++++++++++------------
 cwFlowProc.h    |   2 +-
 cwFlowTypes.cpp | 525 +++++++++++++++++++++++++-----------------------
 cwFlowTypes.h   |  50 +++--
 6 files changed, 637 insertions(+), 502 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index 078ff79..16e0f73 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -53,7 +53,7 @@ namespace cw
       { "audio_meter",     &audio_meter::members },
       { "audio_marker",    &audio_marker::members },
       { "xfade_ctl",       &xfade_ctl::members },
-      { "poly_mixer",      &poly_mixer::members },
+      { "poly_merge",      &poly_merge::members },
       { "sample_hold",     &sample_hold::members },
       { "number",          &number::members },
       { "timer",           &timer::members },
@@ -244,78 +244,6 @@ namespace cw
     }
 
 
-    /*
-    rc_t _setup_input( flow_t* p, instance_t* in_inst, const char* in_var_label, const char* src_proc_label, const char* src_var_label )
-    {
-      rc_t        rc        = kOkRC;
-      unsigned    src_charN = textLength(src_label_arg);
-      variable_t* src_var   = nullptr;
-      instance_t* src_inst  = nullptr;
-      variable_t* in_var    = nullptr;
-      
-      char        sbuf[ src_charN+1 ];
-        
-      // copy the id into the buf
-      strncpy(sbuf,src_label_arg,src_charN+1);
-
-      // advance suffix to the '.'
-      char* suffix = sbuf;
-      while( *suffix && *suffix != '.')
-        ++suffix;
-
-      // if a '.' suffix was found
-      if( *suffix )
-      {
-        *suffix = 0;
-        ++suffix;
-      }
-
-      // locate source instance
-      if((rc = instance_find(p, sbuf, kBaseSfxId, src_inst )) != kOkRC )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The source instance '%s' was not found.", cwStringNullGuard(sbuf) );
-        goto errLabel;
-      }
-
-      // locate source value
-      if((rc = var_find( src_inst, suffix, kBaseSfxId, kAnyChIdx, src_var)) != kOkRC )
-      {
-        rc = cwLogError(rc,"The source var '%s' was not found on the source instance '%s'.", cwStringNullGuard(suffix), cwStringNullGuard(sbuf));
-        goto errLabel;
-      }
-
-      // locate input value
-      if((rc = var_find( in_inst, in_var_label, kBaseSfxId, kAnyChIdx, in_var )) != kOkRC )
-      {
-        rc = cwLogError(rc,"The input value '%s' was not found on the instance '%s'.", cwStringNullGuard(in_var_label), cwStringNullGuard(in_inst->label));
-        goto errLabel;        
-      }
-
-      // verify that the src_value type is included in the in_value type flags
-      if( cwIsNotFlag(in_var->varDesc->type, src_var->varDesc->type) )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The type flags don't match on input:%s %s source:%s %s .", in_inst->label, in_var_label, src_inst->label, suffix);        
-        goto errLabel;                
-      }
-
-      if( src_var->value == nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The source value is null on the connection input:'%s' %s source:'%s' '%s' .", in_inst->label, in_var_label, src_inst->label, suffix);
-        goto errLabel;
-      }
-
-      _connect_vars( src_var, in_var );
-
-      //cwLogInfo("'%s:%s' connected to source '%s:%s' %p.", in_inst->label, in_var_label, src_inst->label, suffix, in_var->value );
-      
-    errLabel:
-      return rc;
-    }
-    */
-
-
-
-    
     
     rc_t _destroy( flow_t* p)
     {
@@ -406,20 +334,24 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   }
 
   // parse the main audio file processor cfg record
-  if((rc = flowCfg.getv("framesPerCycle",      p->framesPerCycle,
-                        "network",             networkCfg)) != kOkRC )
+  if((rc = flowCfg.getv("network",             networkCfg)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the required flow configuration parameters.");
     goto errLabel;
   }
 
+  p->framesPerCycle = kDefaultFramesPerCycle;
+  p->sample_rate    = kDefaultSampleRate;
+
   // parse the optional args
-  if((rc = flowCfg.getv_opt("maxCycleCount",    p->maxCycleCount,
+  if((rc = flowCfg.getv_opt("framesPerCycle",       p->framesPerCycle,
+                            "sample_rate",          p->sample_rate,
+                            "maxCycleCount",        p->maxCycleCount,
                             "multiPriPresetProbFl", p->multiPriPresetProbFl,
                             "multiSecPresetProbFl", p->multiSecPresetProbFl,
-                            "multiPresetInterpFl", p->multiPresetInterpFl,
-                            "printClassDictFl", printClassDictFl,
-                            "printNetworkFl",   printNetworkFl)) != kOkRC )
+                            "multiPresetInterpFl",  p->multiPresetInterpFl,
+                            "printClassDictFl",     printClassDictFl,
+                            "printNetworkFl",       printNetworkFl)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the optional flow configuration parameters.");
     goto errLabel;
diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index 01f2cd8..cc1402c 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -63,20 +63,6 @@ namespace cw
 
     rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef );
 
-    void _connect_vars( variable_t* src_var, variable_t* in_var )
-    {
-      // connect in_var into src_var's outgoing var chain
-      in_var->dst_link  = src_var->dst_tail;
-      src_var->dst_tail = in_var;
-      if( src_var->dst_head == nullptr )
-        src_var->dst_head = in_var;
-
-      assert( src_var->value != nullptr );
-          
-      in_var->value    = src_var->value;
-      in_var->src_var = src_var;
-    }
-
     rc_t _create_instance_var_map( instance_t* inst )
     {
       rc_t        rc        = kOkRC;
@@ -146,6 +132,7 @@ namespace cw
       
     }
 
+    /*
     void _complete_input_connections( instance_t* inst )
     {
       for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
@@ -173,7 +160,8 @@ namespace cw
           }
         }
     }
-
+    */
+    
     rc_t _set_log_flags(instance_t* proc, const object_t* log_labels)
     {
       rc_t rc = kOkRC;
@@ -1223,7 +1211,7 @@ namespace cw
         // get the var class desc. for the in-var
         if(( in_stmt.in_var_desc = var_desc_find(inst->class_desc,in_stmt.in_var_ele.label)) == nullptr )
         {
-          rc = cwLogError(rc,"Unable to locate the var class desc for the in-var from '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label));
+          rc = cwLogError(kEleNotFoundRC,"Unable to locate the var class desc for the in-var from '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label));
           goto errLabel;
         }
 
@@ -1446,7 +1434,7 @@ namespace cw
           }
 
           //
-          _connect_vars( src_var, in_var );
+          var_connect( src_var, in_var );
         }                
       }
 
@@ -1661,7 +1649,7 @@ namespace cw
       }
 
       // the custom creation function may have added channels to in-list vars fix up those connections here.
-      _complete_input_connections(inst);
+      //_complete_input_connections(inst);
 
       // set the log flags again so that vars created by the instance can be included in the log output
       if((rc = _set_log_flags(inst,pstate.log_labels)) != kOkRC )
@@ -2033,7 +2021,8 @@ cw::rc_t cw::flow::exec_cycle( network_t& net )
   for(unsigned i=0; i<net.proc_arrayN; ++i)
   {
     if((rc = net.proc_array[i]->class_desc->members->exec(net.proc_array[i])) != kOkRC )
-    {          
+    {
+      rc = cwLogError(rc,"Execution failed on the proc:%s:%i.",cwStringNullGuard(net.proc_array[i]->label),net.proc_array[i]->label_sfx_id);
       break;
     }
   }
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index e9f640a..7dbb49c 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -31,6 +31,39 @@ namespace cw
 
   namespace flow
   {
+    
+    template< typename inst_t >
+    rc_t std_destroy( instance_t* proc )
+    {
+      inst_t* p = (inst_t*)proc->userPtr;
+      rc_t rc = _destroy(proc,p);
+      mem::release(proc->userPtr);
+      return rc;
+    }
+    
+    template< typename inst_t >
+    rc_t std_create( instance_t* proc )
+    {
+      rc_t rc = kOkRC;
+      proc->userPtr = mem::allocZ<inst_t>();
+      if((rc = _create(proc,(inst_t*)proc->userPtr)) != kOkRC )
+        std_destroy<inst_t>(proc);
+      return rc;        
+    }
+
+    template< typename inst_t >
+    rc_t std_value( instance_t* proc, variable_t* var )
+    { return _value(proc,(inst_t*)proc->userPtr, var); }
+        
+    template< typename inst_t >
+    rc_t std_exec( instance_t* proc )
+    { return _exec(proc,(inst_t*)proc->userPtr); }
+
+    template< typename inst_t >
+    rc_t std_report( instance_t* proc )
+    { return _report(proc,(inst_t*)proc->userPtr); }
+
+    
     //------------------------------------------------------------------------------------------------------------------
     //
     // Template
@@ -43,50 +76,46 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* proc )
+      rc_t _create( instance_t* proc, inst_t* p )
       {
         rc_t    rc   = kOkRC;        
-        inst_t* p = mem::allocZ<inst_t>();
-        proc->userPtr = p;
 
         // Custom create code goes here
 
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t _destroy( instance_t* proc, inst_t* p )
       {
         rc_t rc = kOkRC;
 
-        inst_t* p = (inst_t*)proc->userPtr;
-
         // Custom clean-up code goes here
 
-        mem::release(p);
-        
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
+      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t exec( instance_t* proc )
+      rc_t _exec( instance_t* proc, inst_t* p )
       {
         rc_t rc      = kOkRC;
-        //inst_t*  p = (inst_t*)proc->userPtr;
         
         return rc;
       }
 
+      rc_t _report( instance_t* proc, inst_t* p )
+      { return kOkRC; }
+
       class_members_t members = {
-        .create = create,
-        .destroy = destroy,
-        .value   = value,
-        .exec = exec,
-        .report = nullptr
+        .create  = std_create<inst_t>,
+        .destroy = std_destroy<inst_t>,
+        .value   = std_value<inst_t>,
+        .exec    = std_exec<inst_t>,
+        .report  = std_report<inst_t>
       };
       
     }    
@@ -972,7 +1001,7 @@ namespace cw
 
           // print a minutes counter
           inst->durSmpN += src_abuf->frameN;          
-          if( inst->durSmpN % ((unsigned)src_abuf->srate*60) == 0 )
+          if( src_abuf->srate!=0 && inst->durSmpN % ((unsigned)src_abuf->srate*60) == 0 )
             printf("audio file out: %5.1f min\n", inst->durSmpN/(src_abuf->srate*60));
           
         }
@@ -1720,15 +1749,29 @@ namespace cw
         ctx->userPtr = inst;
 
         // Register variables and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx, kChCntPid, "chCnt", kBaseSfxId, chCnt)) != kOkRC )
+        if((rc = var_register_and_get( ctx, kAnyChIdx,
+                                       kChCntPid, "chCnt", kBaseSfxId, chCnt,
+                                       kSratePId, "srate", kBaseSfxId, srate)) != kOkRC )
         {
           goto errLabel;
         }
 
+        // Sample rate logic:
+        // The sample rate may be set directly, or sourced.
+        // If the srate is 0 then this indicates that the system sample rate should be used.
+        // if the sample rate is sourced and 0 it is a configuration error.
+
+        // if no sample rate was given then use the system sample rate.
+        if( srate == 0 )
+          srate = ctx->ctx->sample_rate;
+        
         // register each oscillator variable
         for(unsigned i=0; i<chCnt; ++i)
+        {
+          unsigned ch_srate = 0;
+          
           if((rc = var_register_and_get( ctx, i,
-                                         kSratePId,  "srate", kBaseSfxId, srate,
+                                         kSratePId,  "srate", kBaseSfxId, ch_srate,
                                          kFreqHzPId, "hz",    kBaseSfxId, hz,
                                          kPhasePId,  "phase", kBaseSfxId, phase,
                                          kDcPId,     "dc",    kBaseSfxId, dc,
@@ -1737,8 +1780,15 @@ namespace cw
             goto errLabel;
           }
 
+          // if no srate was set on this channel then use the default sample rate
+          if( ch_srate == 0 )
+            if((rc = var_set(ctx,kSratePId,i,srate)) != kOkRC )
+              goto errLabel;
+        }
+        
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, chCnt, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( ctx, "out", kBaseSfxId,
+                                   kOutPId, kAnyChIdx, srate, chCnt, ctx->ctx->framesPerCycle );
 
         inst->phaseA = mem::allocZ<double>( chCnt );
         
@@ -3286,22 +3336,25 @@ namespace cw
         kSrateRefPId,
         kDurMsPId,
         kTriggerPId,
+        kPresetPId,
         kGainPId,
       };
       
       typedef struct
       {
-        unsigned    xfadeDurMs;        // crossfade duration in milliseconds
-        instance_t* net_proc;          // source 'poly' network
-        network_t   net;               // internal proxy network 
+        unsigned    xfadeDurMs;       // crossfade duration in milliseconds
+        instance_t* net_proc;         // source 'poly' network
+        network_t   net;              // internal proxy network 
         unsigned    poly_ch_cnt;      // set to 2 (one for 'cur' poly-ch., one for 'next' poly-ch.)
-        unsigned    net_proc_cnt;      // count of proc's in a single poly-channel (net_proc->proc_arrayN/poly_cnt)
+        unsigned    net_proc_cnt;     // count of proc's in a single poly-channel (net_proc->proc_arrayN/poly_cnt)
         unsigned    cur_poly_ch_idx;  // 
         unsigned    next_poly_ch_idx; //
         float*      target_gainA;     // target_gainA[net_proc->poly_cnt]
         float*      cur_gainA;        // cur_gainA[net_proc->poly_cnt]
         double      srate;
-        
+        bool        preset_delta_fl;
+        bool        trigFl;
+        bool        trigVal;
       } inst_t;
 
       void _trigger_xfade( inst_t* p )
@@ -3333,16 +3386,17 @@ namespace cw
         p->target_gainA[ p->cur_poly_ch_idx ] = 1;
 
         // if the next channel is not already at 0 send it in that direction
-        p->target_gainA[ p->next_poly_ch_idx ] = 0; 
+        p->target_gainA[ p->next_poly_ch_idx ] = 0;
+
+        //printf("xfad:%i %i : %i\n",p->cur_poly_ch_idx, p->next_poly_ch_idx,p->poly_ch_cnt);
 
       }
 
-
-
       rc_t create( instance_t* ctx )
       {
         rc_t        rc            = kOkRC;
         const char* netLabel      = nullptr;
+        const char* presetLabel   = nullptr;
         unsigned    netLabelSfxId = kBaseSfxId;
         bool        trigFl        = false;
         variable_t* gainVar       = nullptr;
@@ -3353,15 +3407,15 @@ namespace cw
 
         ctx->userPtr = p;
         
-        p->poly_ch_cnt = 2;
         
         if((rc = var_register_and_get(ctx,kAnyChIdx,
                                       kNetLabelPId,       "net",       kBaseSfxId, netLabel,
                                       kNetLabelSfxPId,    "netSfxId",  kBaseSfxId, netLabelSfxId,
                                       kSrateRefPId,       "srateSrc",  kBaseSfxId, srateSrc,
                                       kDurMsPId,          "durMs",     kBaseSfxId, p->xfadeDurMs,
-                                      kTriggerPId,         "trigger",  kBaseSfxId, trigFl,
-                                      kGainPId,            "gain",     kBaseSfxId, dum_dbl)) != kOkRC )
+                                      kTriggerPId,        "trigger",   kBaseSfxId, p->trigVal,
+                                      kPresetPId,         "preset",    kBaseSfxId, presetLabel,
+                                      kGainPId,           "gain",      kBaseSfxId, dum_dbl)) != kOkRC )
         {
           goto errLabel; 
         }
@@ -3378,7 +3432,9 @@ namespace cw
           cwLogError(rc,"The xfade_ctl source network must have at least 3 poly channels. %i < 3",p->net_proc->internal_net->poly_cnt);
           goto errLabel;
         }
-          
+
+        p->poly_ch_cnt = p->net_proc->internal_net->poly_cnt;
+
 
         // create the gain output variables - one output for each poly-channel
         for(unsigned i=1; i<p->net_proc->internal_net->poly_cnt; ++i)
@@ -3396,11 +3452,11 @@ namespace cw
 
         // create the proxy network
         p->net.proc_arrayAllocN = p->net_proc_cnt * p->poly_ch_cnt;
-        p->net.proc_arrayN = p->net.proc_arrayAllocN;
-        p->net.proc_array  = mem::allocZ<instance_t*>(p->net.proc_arrayAllocN);
-        p->target_gainA    = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
-        p->cur_gainA       = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
-        p->srate           = srateSrc->srate;
+        p->net.proc_arrayN      = p->net.proc_arrayAllocN;
+        p->net.proc_array       = mem::allocZ<instance_t*>(p->net.proc_arrayAllocN);
+        p->target_gainA         = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
+        p->cur_gainA            = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
+        p->srate                = srateSrc->srate;
         
         // make the proxy network public - xfad_ctl now looks like the source network
         // because it has the same proc instances
@@ -3431,7 +3487,27 @@ namespace cw
       }
 
       rc_t value( instance_t* ctx, variable_t* var )
-      { return kOkRC; }
+      {
+        rc_t rc = kOkRC;
+        inst_t* p = (inst_t*)ctx->userPtr;
+        
+        if(var->vid == kTriggerPId )
+        {
+          bool v;
+          if((rc = var_get(var,v)) == kOkRC )
+          {
+            if( !p->trigFl )
+              p->trigFl = p->trigVal != v;
+                
+            p->trigVal = v;
+          }
+          //printf("tr:%i %i %i\n",v,p->trigVal,p->trigFl);
+
+          
+        }
+
+        return kOkRC;
+      }
 
       // return sign of expression as a float
       float _signum( float v ) { return (0.0f < v) - (v < 0.0f); }
@@ -3440,14 +3516,12 @@ namespace cw
       {
         rc_t    rc     = kOkRC;
         inst_t* p      = (inst_t*)ctx->userPtr;
-        bool    trigFl = false;
 
         // check if a cross-fade has been triggered
-        if((rc = var_get(ctx,kTriggerPId,kAnyChIdx,trigFl)) == kOkRC )
+        if(p->trigFl )
         {
+          p->trigFl = false;
           _trigger_xfade(p);
-          
-          var_set(ctx,kTriggerPId,kAnyChIdx,false);
         }
         
         // time in sample frames to complete a xfade
@@ -3482,95 +3556,181 @@ namespace cw
     
     //------------------------------------------------------------------------------------------------------------------
     //
-    // poly_mixer
+    // poly_merge
     //
-    namespace poly_mixer
+
+    namespace poly_merge
     {
-      enum {
+      enum
+      {
         kOutGainPId,
         kOutPId,
-        
+        kInBasePId,
       };
-      
+        
       typedef struct
       {
-        unsigned inBaseVId;
-        unsigned gainBaseVId;
+        unsigned inAudioVarCnt;
+        unsigned gainVarCnt;
+        unsigned baseGainPId;
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t _create( instance_t* proc, inst_t* p )
       {
-        rc_t          rc     = kOkRC;
-        /*
-        const abuf_t* abuf0  = nullptr; //
-        const abuf_t* abuf1  = nullptr;
-        unsigned      outChN = 0;
-        double dum;
+        rc_t    rc   = kOkRC;        
+
+        unsigned inAudioChCnt = 0;
+        srate_t  srate        = 0;
+        unsigned audioFrameN  = 0;
+        unsigned sfxIdAllocN  = instance_var_count(proc);
+        unsigned sfxIdA[ sfxIdAllocN ];
+          
+
+        // register the output gain variable
+        if((rc = var_register(proc,kAnyChIdx,kOutGainPId,"out_gain",kBaseSfxId)) != kOkRC )
+          goto errLabel;
+          
         
-        // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,
-                                      kIn0PId,"in0",kBaseSfxId,abuf0,
-                                      kIn1PId,"in1",kBaseSfxId,abuf1 )) != kOkRC )
+        // get the the sfx_id's of the input audio variables 
+        if((rc = var_mult_sfx_id_array(proc, "in", sfxIdA, sfxIdAllocN, p->inAudioVarCnt )) != kOkRC )
+          goto errLabel;
+
+        // for each input audio variable
+        for(unsigned i=0; i<p->inAudioVarCnt; ++i)
         {
+          abuf_t* abuf;
+
+          // register the input audio variable
+          if((rc = var_register_and_get(proc,kAnyChIdx,kInBasePId+i,"in",sfxIdA[i],abuf)) != kOkRC )
+            goto errLabel;
+            
+
+          // the sample rate of off input audio signals must be the same
+          if( srate != 0 && abuf->srate != srate )
+          {
+            rc = cwLogError(kInvalidArgRC,"All signals on a poly merge must have the same sample rate.");
+            goto errLabel;
+          }
+
+          srate = abuf->srate;
+
+          // the count of frames in all audio signals must be the same
+          if( audioFrameN != 0 && abuf->frameN != audioFrameN )
+          {
+            rc = cwLogError(kInvalidArgRC,"All signals on a poly merge must have the same frame count.");
+            goto errLabel;
+          }
+          
+          audioFrameN = abuf->frameN;
+          
+          inAudioChCnt += abuf->chN;
+        }
+
+        // Get the sfx-id's of the input gain variables
+        if((rc = var_mult_sfx_id_array(proc, "gain", sfxIdA, sfxIdAllocN, p->gainVarCnt )) != kOkRC )
+          goto errLabel;
+        
+
+        // There must be one gain variable for each audio input or exactly one gain variable 
+        if( p->gainVarCnt != p->inAudioVarCnt && p->gainVarCnt != 1 )
+        {
+          rc = cwLogError(kInvalidArgRC,"The count of gain variables must be the same as the count of audio variables are there must be one gain variable.");
           goto errLabel;
         }
 
-        assert( abuf0->frameN == abuf1->frameN );
+        // set the baseInGainPId
+        p->baseGainPId = kInBasePId + p->inAudioVarCnt;
 
-        outChN = std::max(abuf0->chN, abuf1->chN);
+        // register each of the input gain variables
+        for(unsigned i=0; i<p->gainVarCnt; ++i)
+        {
+          coeff_t dum;
+          if((rc = var_register(proc,kAnyChIdx,p->baseGainPId + i,"gain",sfxIdA[i])) != kOkRC )
+            goto errLabel;
+          
+        }
 
-        // register the gain
-        var_register_and_get( ctx, kAnyChIdx, kGain0PId, "gain0", kBaseSfxId, dum );
-        var_register_and_get( ctx, kAnyChIdx, kGain1PId, "gain1", kBaseSfxId, dum );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, inAudioChCnt, audioFrameN );
 
-        // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf0->srate, outChN, abuf0->frameN );
-        */
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
-      { return kOkRC; }
+      rc_t _destroy( instance_t* proc, inst_t* p )
+      {
+        return kOkRC;
+      }
 
-      rc_t value( instance_t* ctx, variable_t* var )
-      { return kOkRC; }
+      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
+      {
+        return kOkRC;
+      }
 
+      unsigned _merge_in_one_audio_var( instance_t* proc, const abuf_t* ibuf, abuf_t* obuf, unsigned outChIdx, coeff_t gain )
+      {
+        // for each channel          
+        for(unsigned i=0; i<ibuf->chN  && outChIdx<obuf->chN; ++i)
+        {            
+          sample_t* isig = ibuf->buf + i        * ibuf->frameN;
+          sample_t* osig = obuf->buf + outChIdx * obuf->frameN;
+
+          // apply the gain
+          for(unsigned j=0; j<ibuf->frameN; ++j)
+            osig[j] = gain * isig[j];
+
+          outChIdx += 1;
+        }  
+
+        return outChIdx;
+      }
       
-      rc_t exec( instance_t* ctx )
+      rc_t _exec( instance_t* proc, inst_t* p )
       {
         rc_t          rc    = kOkRC;
-        /*
         abuf_t*       obuf  = nullptr;
-        //const abuf_t* ibuf0 = nullptr;
-        //const abuf_t* ibuf1 = nullptr;
+        unsigned      oChIdx = 0;
+        coeff_t       igain   = 1;
+        coeff_t       ogain   = 1;
 
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        // get the output audio buffer
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
           goto errLabel;
 
-        //if((rc = var_get(ctx,kIn0PId, kAnyChIdx, ibuf0 )) != kOkRC )
-        //  goto errLabel;
-        
-        //if((rc = var_get(ctx,kIn1PId, kAnyChIdx, ibuf1 )) != kOkRC )
-        //  goto errLabel;
+        // get the output audio gain
+        if((rc = var_get(proc,kOutGainPId, kAnyChIdx, ogain)) != kOkRC )
+          goto errLabel;
+
+        // for each audio input variable
+        for(unsigned i=0; i<p->inAudioVarCnt; ++i)
+        {
+          const abuf_t* ibuf = nullptr;
+
+          // get the input audio buffer
+          if((rc = var_get(proc,kInBasePId+i, kAnyChIdx, ibuf )) != kOkRC )
+            goto errLabel;
+
+          // get the input gain
+          if( i < p->gainVarCnt )
+            var_get(proc,p->baseGainPId+i,kAnyChIdx,igain);
+
+          // merge the input audio signal into the output audio buffer
+          oChIdx = _merge_in_one_audio_var( proc, ibuf, obuf, oChIdx, igain * ogain );
+        }        
 
-        vop::zero(obuf->buf, obuf->frameN*obuf->chN );
-        
-        _mix( ctx, kIn0PId, kGain0PId, obuf );
-        _mix( ctx, kIn1PId, kGain1PId, obuf );
-        */
-        
       errLabel:
         return rc;
       }
 
+      rc_t _report( instance_t* proc, inst_t* p )
+      { return kOkRC; }
+
       class_members_t members = {
-        .create = create,
-        .destroy = destroy,
-        .value   = value,
-        .exec = exec,
-        .report = nullptr
+        .create  = std_create<inst_t>,
+        .destroy = std_destroy<inst_t>,
+        .value   = std_value<inst_t>,
+        .exec    = std_exec<inst_t>,
+        .report  = std_report<inst_t>
       };
       
     }    
@@ -3878,6 +4038,9 @@ namespace cw
           goto errLabel;
         }
 
+        if( srate == 0 )
+          var_set(proc,kSratePId,kAnyChIdx,proc->ctx->sample_rate);
+
         if((rc = var_register_and_set(proc,kAnyChIdx,
                                       kOutPId,       "out",     kBaseSfxId,false)) != kOkRC )
         {
@@ -4745,12 +4908,14 @@ namespace cw
       };      
     }    
 
+
     //------------------------------------------------------------------------------------------------------------------
     //
     // preset
     //
     namespace preset
     {
+
       enum { kInPId };
       
       enum { kPresetLabelCharN=255 };
@@ -4758,101 +4923,113 @@ namespace cw
       typedef struct
       {
         char preset_label[ kPresetLabelCharN+1];
+        bool delta_fl;
       } inst_t;
 
 
-      rc_t _set_preset( instance_t* proc, inst_t* p, const char* preset_label )
+      rc_t _set_preset( instance_t* proc, inst_t* p )
       {
         rc_t rc = kOkRC;
+        unsigned presetLabelCharN = 0;
+        const char* preset_label = nullptr;
 
-        if( preset_label == nullptr )
+        // get the preset label
+        if((rc = var_get(proc, kInPId, kAnyChIdx, preset_label)) != kOkRC )
         {
-          if((rc = var_get(proc, kInPId, kAnyChIdx, preset_label)) != kOkRC )
-          {
-            rc = cwLogError(rc,"The variable 'in read failed.");
-            goto errLabel;
-          }
+          rc = cwLogError(rc,"The variable 'in read failed.");
+          goto errLabel;
         }
 
-        if( preset_label == nullptr )
+        // at this point a valid preset-label must exist
+        if( preset_label == nullptr || (presetLabelCharN=textLength(preset_label))==0 )
         {
           rc = cwLogError(kInvalidArgRC,"Preset application failed due to blank preset label.");
           goto errLabel;
         }
 
+        // if the preset-label has not changed since the last preset application - then there is nothing to do
+        if( textIsEqual(preset_label,p->preset_label) )
+          goto errLabel;
+          
+
+        // verify the preset-label is not too long
+        if( presetLabelCharN > kPresetLabelCharN )
+        {
+          rc = cwLogError(kBufTooSmallRC,"The preset label '%s' is to long.",cwStringNullGuard(preset_label));
+          goto errLabel;
+        }
+        
+        cwRuntimeCheck(proc->net != nullptr );
+        
+        // apply the preset
         if((rc = network_apply_preset(*proc->net, preset_label)) != kOkRC )
         {
           rc = cwLogError(rc,"Appy preset '%s' failed.",cwStringNullGuard(preset_label));
           goto errLabel;
         }
-        
-        if( textLength(preset_label) >= kPresetLabelCharN )
-          strncpy(p->preset_label,preset_label,kPresetLabelCharN);
-        else
-        {
-          rc = cwLogError(kBufTooSmallRC,"The preset label '%s' is to long.",cwStringNullGuard(preset_label));
-          goto errLabel;
-        }
+
+        // store the applied preset-label 
+        textCopy(p->preset_label,kPresetLabelCharN,preset_label,presetLabelCharN);
 
       errLabel:
         return rc;
         
       }
-      
-      rc_t create( instance_t* proc )
+
+      rc_t _create( instance_t* proc, inst_t* p )
       {
         rc_t    rc   = kOkRC;        
-        inst_t* p = mem::allocZ<inst_t>();
-        proc->userPtr = p;
+
+        // Custom create code goes here
         const char* label = nullptr;
 
         p->preset_label[0] = 0;
+        p->delta_fl = true;
         
         if((rc = var_register_and_get(proc,kAnyChIdx,kInPId,"in",kBaseSfxId,label)) != kOkRC )
           goto errLabel;
 
+        // we can't apply a preset here because the network is not yet constructed
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t _destroy( instance_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
       {
         rc_t rc = kOkRC;
-
-        inst_t* p = (inst_t*)proc->userPtr;
-
-        // Custom clean-up code goes here
-
-        mem::release(p);
+        if( var->vid == kInPId )
+          p->delta_fl = true;
         
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
-      {
-        rc_t rc = kOkRC;
-        return rc;
-      }
-
-      rc_t exec( instance_t* proc )
+      rc_t _exec( instance_t* proc, inst_t* p )
       {
         rc_t rc      = kOkRC;
-        //inst_t*  p = (inst_t*)proc->userPtr;
+        
+        if( p->delta_fl )
+          rc = _set_preset(proc,p);
         
         return rc;
       }
 
+      rc_t _report( instance_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      
       class_members_t members = {
-        .create = create,
-        .destroy = destroy,
-        .value   = value,
-        .exec = exec,
-        .report = nullptr
+        .create  = std_create<inst_t>,
+        .destroy = std_destroy<inst_t>,
+        .value   = std_value<inst_t>,
+        .exec    = std_exec<inst_t>,
+        .report  = std_report<inst_t>
       };
       
     }    
 
-
     
   } // flow
 } // cw
diff --git a/cwFlowProc.h b/cwFlowProc.h
index 30e3588..64921e3 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -26,7 +26,7 @@ namespace cw
     namespace audio_meter     { extern class_members_t members;  }
     namespace audio_marker    { extern class_members_t members;  }
     namespace xfade_ctl       { extern class_members_t members;  }
-    namespace poly_mixer      { extern class_members_t members;  }
+    namespace poly_merge      { extern class_members_t members;  }
     namespace sample_hold     { extern class_members_t members;  }
     namespace number          { extern class_members_t members;  }
     namespace timer           { extern class_members_t members;  }
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 6474233..df43567 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -46,7 +46,7 @@ namespace cw
       { kFloatTFl, "coeff"},
       { kDoubleTFl, "ftime" },
 
-      { kUIntTFl | kIntTFl | kFloatTFl | kDoubleTFl, "numeric" },
+      { kBoolTFl | kUIntTFl | kIntTFl | kFloatTFl | kDoubleTFl, "numeric" },
 
       { kRuntimeTFl, "runtime" },
 
@@ -473,7 +473,6 @@ namespace cw
           val->u.s   = mem::duplStr(v);
           val->tflag = kStringTFl;
           break;
-
         default:
           rc = cwLogError(kTypeMismatchRC,"A string could not be converted to a %s (0x%x).",_typeFlagToLabel(val->tflag),val->tflag);          
       }
@@ -662,30 +661,8 @@ namespace cw
 
       return _val_get(var->value,valRef);
     
-}
-    rc_t _var_find_to_set( instance_t* inst, unsigned vid, unsigned chIdx, unsigned typeFl, variable_t*& varRef )
-    {
-      rc_t rc = kOkRC;
-      varRef = nullptr;
-
-      // 
-      if((rc = var_find(inst,vid,chIdx,varRef)) == kOkRC )
-      {
-        // validate the type of the variable against the description
-        /*
-        if( !cwIsFlag(varRef->varDesc->type,typeFl ) )
-          rc = cwLogError(kTypeMismatchRC,"Type mismatch. Instance:%s:%i variable:%s:%i with type %s (0x%x) does not match requested type: %s (0x%x).",
-                          varRef->inst->label,varRef->inst->label_sfx_id,
-                          varRef->label,
-                          varRef->label_sfx_id,_typeFlagToLabel(varRef->varDesc->type),varRef->varDesc->type,
-                          _typeFlagToLabel(typeFl),typeFl);
-        */
-    
-      }
-
-      return rc;
     }
-   
+    
 
     // Variable lookup: Exact match on vid and chIdx
     rc_t _var_find_on_vid_and_ch( instance_t* inst, unsigned vid, unsigned chIdx, variable_t*& varRef )
@@ -737,6 +714,9 @@ namespace cw
       return kOkRC;
     }
 
+    void _var_print_addr( const char* title, const variable_t* v )
+    { printf("%s:%s:%i.%s:%i ",title,v->inst->label,v->inst->label_sfx_id,v->label,v->label_sfx_id); }
+
     void _var_print( const variable_t* var )
     {
       const char* conn_label  = is_connected_to_source_proc(var) ? "extern" : "      ";
@@ -751,6 +731,12 @@ namespace cw
       if( var->src_var != nullptr )
         printf(" src:%s:%i.%s:%i",var->src_var->inst->label,var->src_var->inst->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
 
+      if( var->dst_head != nullptr )
+      {
+        for(variable_t* v = var->dst_head; v!=nullptr; v=v->dst_link)
+          printf(" dst:%s:%i.%s:%i",v->inst->label,v->inst->label_sfx_id,v->label,v->label_sfx_id);
+      }
+
       printf("\n");    
     }
     
@@ -766,7 +752,7 @@ namespace cw
         // so that it points to the correct value.
         con_var->value = var->value;
         
-        cwLogMod("%s:%i %s:%i -> %s:%i %s:%i\n",
+        cwLogMod("%s:%i %s:%i -> %s:%i %s:%i",
                  var->inst->label,var->inst->label_sfx_id,
                  var->label,var->label_sfx_id,
                  con_var->inst->label,con_var->inst->label_sfx_id,
@@ -782,23 +768,28 @@ namespace cw
 
 
     
-    // 'typeFlag' is the type (tflag) of 'val'.
+    // 'argTypeFlag' is the type (tflag) of 'val'.
     template< typename T >    
     rc_t _var_set_template( variable_t* var, unsigned argTypeFlag, T val )
     {
-      rc_t rc;
+      rc_t rc = kOkRC;
+      
+      // it is not legal to set the value of a variable that is connected to a 'source' variable.
+      if( var->src_var != nullptr )
+        return cwLogError(kInvalidStateRC, "The variable '%s:%i %s:%i' cannot be set because it is connected to a source variable.", var->inst->label,var->inst->label_sfx_id, var->label, var->label_sfx_id);      
+
+      
       // var->type is the allowable type for this var's value.
+      // It may be set to kInvalidTFl if the type has not yet been determined.
       unsigned value_type_flag    = var->type;
 
+      // Pick the slot in local_value[] that we will use to try out this new value.
       unsigned next_local_value_idx = (var->local_value_idx + 1) % kLocalValueN;
       
       // store the pointer to the current value of this variable
       value_t* original_value     = var->value;
       unsigned original_value_idx = var->local_value_idx;
       
-      // verify that this is a legal assignment
-      if((rc = _validate_var_assignment( var, argTypeFlag )) != kOkRC )
-        goto errLabel;
       
       // release the previous value in the next slot
       _value_release(&var->local_value[next_local_value_idx]);
@@ -808,9 +799,13 @@ namespace cw
       {
         // if the var desc is a single type then use that ....
         if( math::isPowerOfTwo(var->varDesc->type) )
+        {
           value_type_flag = var->varDesc->type;
+        }
         else // ... Otherwise select a type from the one of the possible flags given by the var desc
+        {
           value_type_flag = var->varDesc->type & argTypeFlag;
+        }
 
         // if the incoming type is not in the set of allowable types then it is an error
         if( value_type_flag == 0  )
@@ -824,7 +819,7 @@ namespace cw
       // set the type of the LHS to force the incoming value to be coerced to this type
       var->local_value[ next_local_value_idx ].tflag = value_type_flag;
 
-      // set the new local value
+      // set the new local value in var->local_value[next_local_value_idx]
       if((rc = _val_set(var->local_value + next_local_value_idx, val )) != kOkRC )
       {
         rc = cwLogError(rc,"Value set failed on '%s:%i %s:%i",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id);
@@ -843,7 +838,7 @@ namespace cw
         // call because calls' to 'proc.value()' will see the instance in a incomplete state)
         // Note 2: If this call returns an error then the value assignment is cancelled
         // and the value does not change.
-        var_call_custom_value_func( var );
+        rc = var_call_custom_value_func( var );
       }
 
       //printf("%p set: %s:%s  0x%x\n",var->value, var->inst->label,var->label,var->value->tflag);
@@ -875,8 +870,9 @@ namespace cw
 
       // if this variable is fed from the output of an external proc - then it's local value cannot be set
       if(is_connected_to_source_proc(var)   )
-        return kOkRC;
-      
+      {
+        return cwLogError(kInvalidStateRC,"Cannot set the value on a connected variables.");
+      }
 
       // if this assignment targets a specific channel ...
       if( var->chIdx != kAnyChIdx )
@@ -936,137 +932,6 @@ namespace cw
       return rc;
     }
 
-    rc_t _set_var_value_from_cfg( variable_t* var, const object_t* value )
-    {
-      rc_t rc = kOkRC;
-
-      // Determine the flow variable type of cfg. argument 'value'.
-      unsigned value_flag = 0;
-      
-      switch( value->type->id )
-      {
-        case kCharTId:  
-        case kUInt8TId:
-        case kUInt16TId:
-        case kUInt32TId:
-          value_flag = kUIntTFl;
-          break;
-          
-        case kInt8TId:
-        case kInt16TId:
-        case kInt32TId:
-          value_flag = kIntTFl;
-          break;
-          
-        case kInt64TId:
-        case kUInt64TId:
-          rc = cwLogError(kInvalidArgRC,"The flow system does not currently implement 64bit integers.");
-          goto errLabel;
-          break;
-          
-        case kFloatTId:
-          value_flag = kFloatTFl;
-          break;
-          
-        case kDoubleTId:
-          value_flag = kDoubleTFl;
-          break;
-          
-        case kBoolTId:
-          value_flag = kBoolTFl;
-          break;
-          
-        case kStringTId:
-        case kCStringTId:
-          value_flag = kStringTFl;
-          break;
-          
-        default:
-          value_flag = kCfgTFl;
-        
-      }
-
-      /*
-      if( !cwIsFlag(var->varDesc->type & kTypeMask, value_flag) )
-      {
-        rc = cwLogError(kTypeMismatchRC,"The var desc class type 0x%x does not permit the var to be instantiated with the type %s (0x%x).",var->varDesc->type,_typeFlagToLabel(value_flag),value_flag);
-        goto errLabel;
-      }
-      */
-      
-      switch( value_flag )
-      {
-        case kBoolTFl:
-          {
-            bool v;
-            // assign the value of 'value' to to 'v' (do type conversion if necessary)
-            if((rc = value->value(v)) == kOkRC )
-              // set the value of 'var' where 'v' is the new value and 'value_flag' is the type of 'v'.
-              rc = _var_set_driver( var, value_flag, v );
-          }
-           break;
-          
-        case kUIntTFl:
-          {
-            unsigned v;
-            if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, value_flag, v );
-          }
-          break;
-          
-        case kIntTFl:
-          {
-            int v;
-            if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, value_flag, v );
-          }
-          break;
-          
-        case kFloatTFl:
-          {
-            float v;
-            if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, value_flag, v );
-          }
-          break;
-
-        case kDoubleTFl:
-          {
-            double v;
-            if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, value_flag, v );
-          }
-          break;
-          
-        case kStringTFl:
-          {
-            const char* v;
-            if((rc = value->value(v)) == kOkRC )
-              rc = _var_set_driver( var, value_flag, v );
-          }
-          break;
-
-        case kCfgTFl:
-          {
-            //const object_t* v;
-            //if((rc = value->value(v)) == kOkRC )
-            rc = _var_set_driver( var, value_flag, value );
-          }
-          break;
-          
-       default:
-          rc = cwLogError(kOpFailRC,"The variable type 0x%x cannot yet be set via a cfg.", var->varDesc->type );
-          goto errLabel;
-      }
-
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
-      
-      return rc;
-      
-    }
-    
 
     rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef )
     {
@@ -1130,22 +995,6 @@ namespace cw
       
     }
 
-    /*
-    void _var_set_value_to_typed_null( variable_t* var, unsigned type_flag )
-    {
-      for(unsigned i=0; i<kLocalValueN; ++i)
-      {
-        assert( var->local_value[i].tflag == kInvalidTFl );
-        
-        // set the var-value to a typed null value - this will force later settings to be coerced to this type
-        set_null( var->local_value[i], type_flag );
-      }
-
-      var->value = var->local_value;
-      
-    }
-    */
-    
     rc_t _var_set_type( variable_t* var, unsigned type_flag )
     {
       rc_t rc = kOkRC;
@@ -1155,7 +1004,8 @@ namespace cw
         rc = cwLogError(kOpFailRC,"It is invalid to change the type of a statically (non-runtime) type variable.");
         goto errLabel;
       }
-      
+
+      // Duplicate the varDesc with the 'type' field set to type_flag      
       if( var->localVarDesc == nullptr )
       {
         var->localVarDesc    = mem::allocZ<var_desc_t>();
@@ -1165,8 +1015,6 @@ namespace cw
   
       var->localVarDesc->type = type_flag;
       var->varDesc            = var->localVarDesc;
-
-      //_var_set_value_to_typed_null(var,type_flag);
       
     errLabel:
       return rc;
@@ -1215,10 +1063,10 @@ namespace cw
       // if no value was given then set the value to the value given in the class
       if( value_cfg == nullptr )
         value_cfg = var->varDesc->val_cfg;
-
+      
       // if value_cfg is valid set the variable value
       if( value_cfg != nullptr && cwIsNotFlag(vd->type,kRuntimeTFl))
-        if((rc = _set_var_value_from_cfg( var, value_cfg )) != kOkRC )
+        if((rc = var_set_from_preset( var, value_cfg )) != kOkRC )
           goto errLabel;
 
       var->var_link  = inst->varL;
@@ -1244,28 +1092,9 @@ namespace cw
       return rc;
     }
 
-    
-    rc_t _preset_set_var_value( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value )
-    {
-      rc_t rc = kOkRC;
-      variable_t* var = nullptr;
-
-      // get the variable
-      if((rc = var_find( inst, var_label, sfx_id, chIdx, var )) != kOkRC )
-        goto errLabel;
-        
-      rc = _set_var_value_from_cfg( var, value );
-      
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(rc,"The value of instance:%s:%i variable:%s:%i could not be set via a preset.", inst->label, inst->label_sfx_id, var_label, sfx_id );
-
-      return rc;
-    }
   }
 }
 
-
 cw::flow::abuf_t* cw::flow::abuf_create( srate_t srate, unsigned chN, unsigned frameN )
 {
   abuf_t* a  = mem::allocZ<abuf_t>();
@@ -1455,6 +1284,7 @@ cw::flow::class_desc_t* cw::flow::class_desc_find( flow_t* p, const char* label
   return nullptr;
 }
 
+
 cw::flow::var_desc_t* cw::flow::var_desc_find( class_desc_t* cd, const char* label )
 {
   var_desc_t* vd = cd->varDescL;
@@ -1472,6 +1302,15 @@ cw::rc_t cw::flow::var_desc_find( class_desc_t* cd, const char* label, var_desc_
   return kOkRC;
 }
 
+const cw::flow::preset_t* cw::flow::class_preset_find( class_desc_t* cd, const char* preset_label )
+{
+  const preset_t* pr;
+  for(pr=cd->presetL; pr!=nullptr; pr=pr->link)
+    if( textCompare(pr->label,preset_label) == 0 )
+      return pr;
+  
+  return nullptr;
+}
 
 void cw::flow::class_dict_print( flow_t* p )
 {
@@ -1530,16 +1369,19 @@ cw::rc_t cw::flow::instance_validate( instance_t* inst )
       continue;      
     }
 
+    // the assigned value must have exactly one type
     if(!math::isPowerOfTwo( var->value->tflag ) )
     {
       rc = cwLogError(kInvalidStateRC,"The var '%s:%i' has the invalid type flag:0x%x",var->label,var->label_sfx_id,var->value->tflag);
       continue;
     }
 
-    if( !(var->varDesc->type & var->value->tflag) )
+    // if var is using a local value (not connected to a source variable) then the type of the value must be valid with the variable class
+    if( !is_connected_to_source_proc(var) && !(var->varDesc->type & var->value->tflag) )
     {
-      rc = cwLogError(kInvalidStateRC, "The value type flag '%s' (0x%x) of the var '%s:%i' is not found in the variable class type flags: '%s' (0x%x)",
+      rc = cwLogError(kInvalidStateRC, "The value type flag '%s' (0x%x) of '%s:%i-%s:%i' is not found in the variable class type flags: '%s' (0x%x)",
                       _typeFlagToLabel(var->value->tflag),var->value->tflag,
+                      var->inst->label,var->inst->label_sfx_id,
                       var->label,var->label_sfx_id,
                       _typeFlagToLabel(var->varDesc->type),var->varDesc->type);
       continue;
@@ -1651,12 +1493,14 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   var = _var_find_on_label_and_ch( inst, var_label, sfx_id, chIdx );
   
   // 'src' variables cannot be channelized
+  /*
   if( cwIsFlag(base_var->varDesc->flags,kSrcVarFl) )
   {
     rc = cwLogError(rc,"'src' variables cannot be channelized.");
     goto errLabel;
   }
-
+  */
+  
   // if the requested var was not found then create a new variable with the requested channel index
   if( var == nullptr && chIdx != kAnyChIdx )
   {
@@ -1667,12 +1511,46 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
     // if no value was set then set the value from the 'any' channel
     if( value_cfg == nullptr )
     {
-      // Set the value of the new variable to the value of the 'any' channel
-      _value_duplicate( var->local_value[ var->local_value_idx], base_var->local_value[ base_var->local_value_idx ] );
+      // if the base-var is connected to a source ...
+      if( is_connected_to_source_proc(base_var) )
+      {
+        // ... then connect the new var to a source also
+        
+        // Attempt to find a matching channel on the source
+        variable_t* src_ch_var      = base_var->src_var;
+        variable_t* last_src_ch_var = base_var->src_var;
+        unsigned src_ch_cnt = 0;
+        
+        for(; src_ch_var!=nullptr; src_ch_var=src_ch_var->ch_link)
+        {
+          last_src_ch_var = src_ch_var;
+          if( src_ch_var->chIdx == var->chIdx )
+            break;
 
-      // If the 'any' channel value was set to point to it's local value then do same with this value
-      if( base_var->local_value + base_var->local_value_idx == base_var->value )
-        var->value = var->local_value + var->local_value_idx;
+          src_ch_cnt += 1;
+        }
+
+        // if there is more than one channel available and the src and dst var's do not have matching ch indexes
+        // then there is a possibility that this is an unexpected connection between different channels.
+        if( src_ch_var == nullptr && src_ch_cnt>1 && last_src_ch_var->chIdx != var->chIdx )
+          cwLogWarning("A connection is being made where channel src and dst. channels don't match and more than one src channel is available.");
+
+        // if no matching channel is found connect to the last valid source channel
+        // (Connecting to the last valid source is better than connecting to base_var->src_var
+        //  because if a var has more than a base var it is unlikely to update the base_var.)
+        var_connect( last_src_ch_var, var );
+            
+      }
+      else
+      {
+      
+        // Set the value of the new variable to the value of the 'any' channel
+        _value_duplicate( var->local_value[ var->local_value_idx], base_var->local_value[ base_var->local_value_idx ] );
+
+        // If the 'any' channel value was set to point to it's local value then do same with this value
+        if( base_var->local_value + base_var->local_value_idx == base_var->value )
+          var->value = var->local_value + var->local_value_idx;
+      }
     }
     
   }
@@ -1683,7 +1561,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
     if( value_cfg != nullptr )
     {
       //cwLogInfo("%s ch:%i",var_label,chIdx);
-      rc = _set_var_value_from_cfg( var, value_cfg );
+      rc = var_set_from_preset( var, value_cfg );
     }
     else
     {
@@ -1708,9 +1586,18 @@ cw::rc_t cw::flow::var_call_custom_value_func( variable_t* var )
     goto errLabel;
   
   if( var->flags & kLogVarFl )
-  {
+  {    
     printf("%10s:%5i", var->inst->label,var->inst->label_sfx_id);
-    _var_print(var);
+    
+    if( var->chIdx == kAnyChIdx )
+      _var_print(var);
+    else
+    {
+      printf("\n");
+      for(variable_t* ch_var = var; ch_var!=nullptr; ch_var=ch_var->ch_link)
+        _var_print(ch_var);
+      
+    }
   }
   
 errLabel:
@@ -1761,24 +1648,6 @@ cw::rc_t cw::flow::var_clr_flags( instance_t* inst, unsigned chIdx, const char*
 errLabel:
   return rc;
 }
-/*
-cw::rc_t cw::flow::var_set_type( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned type_flag )  
-{
-  rc_t rc = kOkRC;
-  variable_t* var = nullptr;
-  
-  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
-    goto errLabel;
-
-  rc = _var_set_type(var,type_flag);
-  
-errLabel:
-  if( rc != kOkRC )
-    rc = cwLogError(rc,"Type set failed on the variable:'%s:%i",cwStringNullGuard(var_label),sfx_id);
-  
-  return rc;
-}
-*/            
 
 bool cw::flow::var_exists( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
 { return _var_find_on_label_and_ch(inst,label,sfx_id,chIdx) != nullptr; }
@@ -1846,7 +1715,7 @@ cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, var
     }
   }
 
-  // if we get here var must be non-null
+  // if we get here var must be non-null - (was the var registered?)
   assert( var != nullptr && rc == kOkRC );
   varRef = var;
   
@@ -1927,7 +1796,7 @@ cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsign
   {
     // if a value was given - then update the value
     if( value_cfg != nullptr )
-      if((rc = _set_var_value_from_cfg( var, value_cfg )) != kOkRC )
+      if((rc = var_set_from_preset( var, value_cfg )) != kOkRC )
         goto errLabel;    
   }
   else // an exact match was not found - channelize the variable
@@ -1968,6 +1837,37 @@ bool cw::flow::is_connected_to_source_proc( const variable_t* var )
 bool cw::flow::is_a_source_var( const variable_t* var )
 { return var->dst_head != nullptr; }
 
+
+void cw::flow::var_connect( variable_t* src_var, variable_t* in_var )
+{
+  assert( in_var->dst_link == nullptr );
+
+  // connect in_var into src_var's outgoing var chain   
+  if( src_var->dst_head == nullptr )
+    src_var->dst_head = in_var;
+  else
+    src_var->dst_tail->dst_link = in_var;
+
+  src_var->dst_tail = in_var;
+  
+  in_var->value    = src_var->value;
+  in_var->src_var = src_var;
+
+  //printf("Connect: ");
+  //_var_print_addr("src",src_var);
+  //_var_print_addr("dst",in_var);
+  //_var_print_addr("HEAD",src_var->dst_head);
+
+  //if( src_var->dst_head->dst_link != nullptr )
+  //  _var_print_addr("LINK",src_var->dst_head->dst_link);
+  
+  //_var_print_addr("TAIL",src_var->dst_tail);
+  //printf("\n");
+
+  
+}
+
+
 cw::rc_t  cw::flow::var_mult_sfx_id_array( instance_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref )
 {
   rc_t rc = kOkRC;
@@ -2104,6 +2004,132 @@ cw::rc_t  cw::flow::var_get( variable_t* var, mbuf_t*& valRef )
 cw::rc_t  cw::flow::var_get( const variable_t* var, const object_t*& valRef )
 { return _val_get_driver(var,valRef); }
 
+cw::rc_t cw::flow::var_set_from_preset( variable_t* var, const object_t* value )
+{
+  rc_t rc = kOkRC;
+
+  //
+  // Determine the flow variable type of cfg. argument 'value'.
+  // 
+  unsigned value_flag = 0;
+      
+  switch( value->type->id )
+  {
+    case kCharTId:  
+    case kUInt8TId:
+    case kUInt16TId:
+    case kUInt32TId:
+      value_flag = kUIntTFl;
+      break;
+          
+    case kInt8TId:
+    case kInt16TId:
+    case kInt32TId:
+      value_flag = kIntTFl;
+      break;
+          
+    case kInt64TId:
+    case kUInt64TId:
+      rc = cwLogError(kInvalidArgRC,"The flow system does not currently implement 64bit integers.");
+      goto errLabel;
+      break;
+          
+    case kFloatTId:
+      value_flag = kFloatTFl;
+      break;
+          
+    case kDoubleTId:
+      value_flag = kDoubleTFl;
+      break;
+          
+    case kBoolTId:
+      value_flag = kBoolTFl;
+      break;
+          
+    case kStringTId:
+    case kCStringTId:
+      value_flag = kStringTFl;
+      break;
+          
+    default:
+      value_flag = kCfgTFl;
+        
+  }
+
+  //
+  // Convert the cfg value to a c++ typed value and then call _var_set_driver() with the c++ value.
+  //
+  switch( value_flag )
+  {
+    case kBoolTFl:
+      {
+        bool v;
+        // assign the value of 'value' to to 'v' (do type conversion if necessary)
+        if((rc = value->value(v)) == kOkRC )
+          // set the value of 'var' where 'v' is the new value and 'value_flag' is the type of 'v'.
+          rc = _var_set_driver( var, value_flag, v );
+      }
+      break;
+          
+    case kUIntTFl:
+      {
+        unsigned v;
+        if((rc = value->value(v)) == kOkRC )
+          rc = _var_set_driver( var, value_flag, v );
+      }
+      break;
+          
+    case kIntTFl:
+      {
+        int v;
+        if((rc = value->value(v)) == kOkRC )
+          rc = _var_set_driver( var, value_flag, v );
+      }
+      break;
+          
+    case kFloatTFl:
+      {
+        float v;
+        if((rc = value->value(v)) == kOkRC )
+          rc = _var_set_driver( var, value_flag, v );
+      }
+      break;
+
+    case kDoubleTFl:
+      {
+        double v;
+        if((rc = value->value(v)) == kOkRC )
+          rc = _var_set_driver( var, value_flag, v );
+      }
+      break;
+          
+    case kStringTFl:
+      {
+        const char* v;
+        if((rc = value->value(v)) == kOkRC )
+          rc = _var_set_driver( var, value_flag, v );
+      }
+      break;
+
+    case kCfgTFl:
+      {
+        rc = _var_set_driver( var, value_flag, value );
+      }
+      break;
+          
+    default:
+      rc = cwLogError(kOpFailRC,"The variable type 0x%x cannot yet be set via a cfg.", var->varDesc->type );
+      goto errLabel;
+  }
+
+errLabel:
+  if( rc != kOkRC )
+    rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
+      
+  return rc;
+      
+}
+
 cw::rc_t cw::flow::var_set( variable_t* var, const value_t* val )
 {
   rc_t rc = kOkRC;
@@ -2144,7 +2170,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, cons
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, val->tflag, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = var_set(var,val);
   
   return rc;
@@ -2155,7 +2181,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kBoolTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kBoolTFl, val );
   
   return rc;    
@@ -2166,7 +2192,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, uint
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kUIntTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kUIntTFl, val );
   
   return rc;    
@@ -2177,7 +2203,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, int_
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kIntTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kIntTFl, val );
   
   return rc;    
@@ -2188,7 +2214,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, floa
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kFloatTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kFloatTFl, val );
   
   return rc;    
@@ -2199,7 +2225,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, doub
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kDoubleTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kDoubleTFl, val );
   
   return rc;    
@@ -2210,7 +2236,7 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, cons
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kStringTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kStringTFl, val );
   
   return rc;    
@@ -2221,20 +2247,11 @@ cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, cons
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_to_set(inst, vid, chIdx, kCfgTFl, var )) == kOkRC )
+  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kCfgTFl, val );
   
   return rc;    
 }
 
 
-const cw::flow::preset_t* cw::flow::class_preset_find( class_desc_t* cd, const char* preset_label )
-{
-  const preset_t* pr;
-  for(pr=cd->presetL; pr!=nullptr; pr=pr->link)
-    if( textCompare(pr->label,preset_label) == 0 )
-      return pr;
-  
-  return nullptr;
-}
 
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 3116516..b0c4cf9 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -18,7 +18,9 @@ namespace cw
       kBaseSfxId = 0,
       kFbufVectN = 3,  // count of signal vectors in fbuf (mag,phs,hz)
       kAnyChIdx = kInvalidIdx,
-      kLocalValueN = 2
+      kLocalValueN = 2,
+      kDefaultFramesPerCycle=64,
+      kDefaultSampleRate=48000
     };
         
     typedef struct abuf_str
@@ -78,8 +80,9 @@ namespace cw
 
       kTypeMask    = 0x0000ffff,
 
-      kRuntimeTFl  = 0x80000000
+      kRuntimeTFl  = 0x80000000,
 
+      kNumericFlags = kBoolMtxTFl | kUIntMtxTFl | kIntMtxTFl | kFloatMtxTFl | kDoubleMtxTFl
     };
 
     typedef struct mtx_str
@@ -111,7 +114,7 @@ namespace cw
         char*           s;
         
         const object_t* cfg;
-        void* p;
+        void*           p;
 
       } u;
       
@@ -119,10 +122,6 @@ namespace cw
       
     } value_t;
 
-
-    inline void set_null( value_t& v, unsigned tflag ) { v.tflag=tflag; v.u.p=nullptr; }
-    inline bool is_numeric( const value_t* v ) { return cwIsFlag(v->tflag,kBoolTFl|kUIntTFl|kIntTFl|kFloatTFl|kDoubleTFl); }
-    inline bool is_matrix(  const value_t* v ) { return cwIsFlag(v->tflag,kBoolMtxTFl|kUIntMtxTFl|kIntMtxTFl|kFloatMtxTFl|kDoubleMtxTFl); }
         
     struct instance_str;
     struct variable_str;
@@ -187,7 +186,8 @@ namespace cw
       struct instance_str* inst;         // pointer to this variables instance
       
       char*                label;        // this variables label
-      unsigned             label_sfx_id; // the label suffix id of this variable or kInvalidIdx if this has no suffix      
+      unsigned             label_sfx_id; // the label suffix id of this variable or kBaseSfxId if this has no suffix
+      
       unsigned             vid;          // this variables numeric id ( cat(vid,chIdx) forms a unique variable identifier on this 'inst'      
       unsigned             chIdx;        // channel index
       unsigned             flags;        // kLogVarFl
@@ -262,6 +262,7 @@ namespace cw
 
       
       unsigned             framesPerCycle;  // sample frames per cycle (64)
+      srate_t              sample_rate;     // default sample rate (48000.0)
       bool                 multiPriPresetProbFl; // If set then probability is used to choose presets on multi-preset application
       bool                 multiSecPresetProbFl; // 
       bool                 multiPresetInterpFl; // If set then interpolation is applied between two selectedd presets on multi-preset application
@@ -282,6 +283,14 @@ namespace cw
     //
     // Value Only
     //
+
+    inline void set_null( value_t& v, unsigned tflag ) { v.tflag=tflag; v.u.p=nullptr; }
+    inline bool is_numeric( const value_t* v ) { return cwIsFlag(v->tflag,kBoolTFl|kUIntTFl|kIntTFl|kFloatTFl|kDoubleTFl); }
+    inline bool is_matrix(  const value_t* v ) { return cwIsFlag(v->tflag,kNumericFlags); }
+
+    // if all of the src flags are set in the dst flags then the two types are convertable.
+    inline bool can_convert( unsigned src_tflag, unsigned dst_tflag ) { return (src_tflag&dst_tflag)==src_tflag; }
+
     
     abuf_t*         abuf_create( srate_t srate, unsigned chN, unsigned frameN );
     void            abuf_destroy( abuf_t*& buf );
@@ -309,11 +318,13 @@ namespace cw
     //
     // Class and Variable Description
     //
+
+    class_desc_t*  class_desc_find(  flow_t* p, const char* class_desc_label );
     
     var_desc_t*    var_desc_find( class_desc_t* cd, const char* var_label );
     rc_t           var_desc_find( class_desc_t* cd, const char* label, var_desc_t*& vdRef );
 
-    class_desc_t*  class_desc_find(  flow_t* p, const char* class_desc_label );
+    const preset_t* class_preset_find( class_desc_t* cd, const char* preset_label );
     
     void           class_dict_print( flow_t* p );
 
@@ -341,7 +352,6 @@ namespace cw
     // Count of all var instances on this proc.  This is a count of the length of inst->varL.
     unsigned           instance_var_count( instance_t* inst );
 
-
     
     //------------------------------------------------------------------------------------------------------------------------
     //
@@ -358,9 +368,6 @@ namespace cw
     // automatically generated variable whose channel index is set to  'all'.
     rc_t           var_channelize( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
 
-    // Set the var. type at runtime.
-    //rc_t           var_set_type( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned type_flags );
-
     // Wrapper around call to var->inst->members->value()
     rc_t           var_call_custom_value_func( variable_t* var );
 
@@ -377,7 +384,11 @@ namespace cw
 
     // Return true if this var is acting as a source for another var.
     bool           is_a_source_var( const variable_t* var );
-    
+
+    // Connect in_var to src_var. 
+    void           var_connect( variable_t* src_var, variable_t* in_var );
+
+    // Get all the label-sfx-id's associated with a give var label
     rc_t           var_mult_sfx_id_array( instance_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
     
     //-----------------
@@ -502,6 +513,10 @@ namespace cw
     rc_t           var_channel_count( instance_t* inst, const char* label, unsigned sfx_idx, unsigned& chCntRef );
     rc_t           var_channel_count( const variable_t* var, unsigned& chCntRef );
     
+
+    //
+    // var_get() coerces the value of the variable to the type of the returned value.
+    //
     
     rc_t var_get( const variable_t* var, bool&            valRef );
     rc_t var_get( const variable_t* var, uint_t&          valRef );
@@ -537,6 +552,12 @@ namespace cw
       return value;
     }
 
+    //
+    //  var_set() coerces the incoming value to the type of the variable (var->type)
+    //
+
+    rc_t var_set_from_preset( variable_t* var, const object_t* val );
+
     rc_t var_set( variable_t* var, const value_t* val );
     rc_t var_set( variable_t* var, bool val );
     rc_t var_set( variable_t* var, uint_t val );
@@ -560,7 +581,6 @@ namespace cw
     rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, fbuf_t* val );
     rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const object_t* val );
 
-    const preset_t* class_preset_find( class_desc_t* cd, const char* preset_label );
     
   }
 }

From 8566d91d053b964c0aa2341f77a25079edbf8efa Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 2 May 2024 13:59:33 -0400
Subject: [PATCH 042/101] cwText.h : Updated comments.

---
 cwText.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwText.h b/cwText.h
index 9c4b7de..89a8bf1 100644
--- a/cwText.h
+++ b/cwText.h
@@ -8,7 +8,7 @@ namespace cw
   unsigned textLength( const char* s );
 
   // If dst is non-null then dst is always 0-terminated.
-  // If src will be truncated if srcN > dstN-1.
+  // src will be truncated if srcN > dstN-1.
   // If dst is null then null is returned
   // if src is null then dst[0] = 0.
   // if srcN is 0 then textLength(src) is used for srcN

From 6d8e1543547ad5744c11f5b601f4c8f02a6a4aab Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 2 May 2024 13:59:55 -0400
Subject: [PATCH 043/101] cwCommonImpl.h : Added cwRuntimeCheck()

---
 cwCommonImpl.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cwCommonImpl.h b/cwCommonImpl.h
index 7b59c59..703f2f0 100644
--- a/cwCommonImpl.h
+++ b/cwCommonImpl.h
@@ -138,8 +138,8 @@ namespace cw
 {
 
   
-#define cwAssert(C) while(1){ if(!(C)){ cwLogFatal(kAssertFailRC,"Assert failed on condition:%s",#C ); } break; }
-
+#define cwAssert(C)       while(1){ if(!(C)) { cwLogFatal(kAssertFailRC,"Assert failed on condition:%s",#C ); } break; }
+#define cwRuntimeCheck(C) while(1){ if(!(C)) { rc=cwLogError(kAssertFailRC,"Runtime error check failed on condition:%s",#C); goto errLabel; } break; }
 
   
   

From f9aad38eea6aa9aabba874657d5f8a1ec16b0ffa Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 2 May 2024 14:00:07 -0400
Subject: [PATCH 044/101] flow_doc.md : Updates

---
 flow/flow_doc.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 798f8bc..9acf6a7 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -179,6 +179,24 @@ number, they are reconnected to a specific channel on the source
 variable.
 
 
+### Var Semantics
+
+#### Var Types:
+
+- Variables final types are determined during their owner proc instantiation.
+Once the type is set it never changes for the life of the proc.
+
+- When reading a variable value the value will be coerced to the type of the output variable.
+For example:  `int v; var_get(var,v)` will coerce the value of `var` to an `int`.
+
+- When writing a variable the value will be coerced to the type of the variable.
+For example: If the type of `var` in `var_set(var,float_val)` is `double` then the value of `float_val` will be coerced to a double.
+
+- The type a variables value is set in `variable_t.type` and always consists of a single bit field.
+(i.e. `assert(isPowerOfTwo(variable_t.type))`)
+
+- The type of the value assigned to a variable (`variable_t.value->tflag`) must always exactly match `variable_t.type`.
+
 ### Preset Syntax:
 
 

From 746ecc9466dd8ff0d2d9c9ce5ca54280f778e0e1 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 2 May 2024 14:00:17 -0400
Subject: [PATCH 045/101] README.md : Updates.

---
 README.md | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 99611e6..83a2e61 100644
--- a/README.md
+++ b/README.md
@@ -529,7 +529,7 @@ before registering the variable.
 6. The internal variable id map is created to implement  fast
 access to registered variables.
 
-
+7. The 
 
 # Notes on 'poly' and 'mult':
 
@@ -624,7 +624,7 @@ created by default and later connected to the source inst/var.
 	  of source variables indicated in the `src-expr`.
 
 
-- If no "_" is given:
+- If "_" is not given:
     + No `sec-int` can exist without a "_".
 	
     + If a `pri-int` is given then a single
@@ -850,10 +850,10 @@ resolvable without more information.
 ### TODO:
 
 - Documentation w/ examples.
-  + Write the rules for each member function.
+  + Write the rules for each implementing member function.
     
 - value() should return a special return-code value to indicate that the
-value should not be updated.
+value should not be updated and distinguish it from an error code - which should stop the system.
 
 - Compile presets: at load time the presets should be resolved
   to the proc and vars to which they will be assigned.
@@ -865,6 +865,20 @@ value should not be updated.
   
 - Enforce var attributes.
 
+-  String assignment is allocating  memory:
+   See: `rc_t _val_set( value_t* val, const char* v ) cwFlowTypes.cpp line:464.`
+
+- Should the var's with multiple channels remove the 'kAnyChIdx'?
+This may be a good idea because 'kAnyChIdx' will in general not be used
+if a var has been channelized - and yet it is possible for another 
+var to connect to it as a source ... which doesn't provoke an error
+but would almost certainly not do what the user expects.
+
+- DONE: verifiy that all proc variables values have a valid type - (i.e. (type & typeMask) != 0)
+  when the proc instance create is complete. This checks that both the type is assigned and
+  a valid value has been assigned - since the type is assigned the first time a value is set.
+  
+  
 - DONE: 'poly' should be implemented as a proc-inst with an internal network - but the 
 elements of the network should be visible outside of it.
 
@@ -876,19 +890,22 @@ ports of the internal elements.
 - 'poly' and 'sub' should be arbitrarily nestable. DONE?
 
 
-- Reduce runtime over head for var get/set operations.
+- Reduce runtime overhead for var get/set operations.
 
 
-- Allow multiple types on an input.
+- DONE: Allow multiple types on an input.
    For example 'adder' should have a single input 
    which can by any numeric type.
    
 - Allow min/max values on numeric variables.
 
-- Make a standard way to turn on output printing from any port on any instance
+- DONE: Make a standard way to turn on output printing from any port on any instance
 This might be a better approach to logging than having a 'printer' object.
 Add proc instance field: `log:{ var_label_0:0, var_label_1:0 } `
 
+- log: should print the values for all channels - right now it is only
+printing the values for kAnyChIdx
+
 
 Next:
 

From 8f405e4784cb805120732625e8f98bcbba01ef93 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 3 May 2024 09:16:37 -0400
Subject: [PATCH 046/101] cwFlowTypes.h : Fixed bug in kNumericTFl enumeration.
 Added kAllTFl

---
 cwFlowTypes.cpp | 3 ++-
 cwFlowTypes.h   | 8 +++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index df43567..63f9fbb 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -46,7 +46,8 @@ namespace cw
       { kFloatTFl, "coeff"},
       { kDoubleTFl, "ftime" },
 
-      { kBoolTFl | kUIntTFl | kIntTFl | kFloatTFl | kDoubleTFl, "numeric" },
+      { kNumericTFl, "numeric" },
+      { kAllTFl,     "all" },
 
       { kRuntimeTFl, "runtime" },
 
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index b0c4cf9..d207e0d 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -82,7 +82,9 @@ namespace cw
 
       kRuntimeTFl  = 0x80000000,
 
-      kNumericFlags = kBoolMtxTFl | kUIntMtxTFl | kIntMtxTFl | kFloatMtxTFl | kDoubleMtxTFl
+      kNumericTFl = kBoolTFl | kUIntTFl | kIntTFl | kFloatTFl | kDoubleTFl,
+      kMtxTFl     = kBoolMtxTFl | kUIntMtxTFl | kIntMtxTFl | kFloatMtxTFl | kDoubleMtxTFl,
+      kAllTFl     = kTypeMask
     };
 
     typedef struct mtx_str
@@ -285,8 +287,8 @@ namespace cw
     //
 
     inline void set_null( value_t& v, unsigned tflag ) { v.tflag=tflag; v.u.p=nullptr; }
-    inline bool is_numeric( const value_t* v ) { return cwIsFlag(v->tflag,kBoolTFl|kUIntTFl|kIntTFl|kFloatTFl|kDoubleTFl); }
-    inline bool is_matrix(  const value_t* v ) { return cwIsFlag(v->tflag,kNumericFlags); }
+    inline bool is_numeric( const value_t* v ) { return cwIsFlag(v->tflag,kNumericTFl); }
+    inline bool is_matrix(  const value_t* v ) { return cwIsFlag(v->tflag,kMtxTFl); }
 
     // if all of the src flags are set in the dst flags then the two types are convertable.
     inline bool can_convert( unsigned src_tflag, unsigned dst_tflag ) { return (src_tflag&dst_tflag)==src_tflag; }

From f2dea887346acf2c7f3b7fb3f9f1bc68921422c1 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 3 May 2024 09:21:08 -0400
Subject: [PATCH 047/101] cwFlowNet.h/cpp : network_apply_preset() now takes a

---
 cwFlowNet.cpp | 4 ++--
 cwFlowNet.h   | 5 ++++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index cc1402c..f0b769a 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -2061,7 +2061,7 @@ errLabel:
 }
 
 
-cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel )
+cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel, unsigned proc_label_sfx_id )
 {
   rc_t    rc = kOkRC;
   const object_t* net_preset_value;
@@ -2085,7 +2085,7 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel
       instance_t* inst;
 
       // locate the instance
-      if((inst = instance_find(net,inst_label,kBaseSfxId)) == nullptr )
+      if((inst = instance_find(net,inst_label,proc_label_sfx_id)) == nullptr )
       {
         rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel);
         goto errLabel;
diff --git a/cwFlowNet.h b/cwFlowNet.h
index fa35553..2901e9a 100644
--- a/cwFlowNet.h
+++ b/cwFlowNet.h
@@ -70,7 +70,10 @@ namespace cw
       return rc;
     }
 
-    rc_t network_apply_preset( network_t& net, const char* presetLabel );
+    // 'proc_label_sfx_id' is the proc label_sfx_id to be used to identify all proc's which will
+    // be updated by the preset application. This is used to identify the set of procs to be updated
+    // for 'poly' networks.
+    rc_t network_apply_preset( network_t& net, const char* presetLabel, unsigned proc_label_sfx_id=kBaseSfxId );
     rc_t network_apply_dual_preset( network_t& net, const char* presetLabel_0, const char* presetLabel_1, double coeff );      
     rc_t network_apply_preset( network_t& net, const multi_preset_selector_t& mps );
     

From 072d0eecd60248be171831c0f42d510449e35164 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 3 May 2024 09:22:16 -0400
Subject: [PATCH 048/101] cwFlowProc.cpp : Refactored xfade_ctl to implement
 preset updates.

---
 cwFlowProc.cpp | 321 ++++++++++++++++++++++++++++---------------------
 1 file changed, 184 insertions(+), 137 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 7dbb49c..f00d2bc 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -3339,54 +3339,44 @@ namespace cw
         kPresetPId,
         kGainPId,
       };
+
+      typedef struct poly_ch_str
+      {
+        network_t net;
+        coeff_t   target_gain;
+        coeff_t   cur_gain;
+      } poly_ch_t;
       
       typedef struct
       {
         unsigned    xfadeDurMs;       // crossfade duration in milliseconds
         instance_t* net_proc;         // source 'poly' network
-        network_t   net;              // internal proxy network 
-        unsigned    poly_ch_cnt;      // set to 2 (one for 'cur' poly-ch., one for 'next' poly-ch.)
+        poly_ch_t*  netA;             // netA[ poly_ch_cnt ] internal proxy network 
+        unsigned    poly_ch_cnt;      // count of poly channels in net_proc
         unsigned    net_proc_cnt;     // count of proc's in a single poly-channel (net_proc->proc_arrayN/poly_cnt)
-        unsigned    cur_poly_ch_idx;  // 
-        unsigned    next_poly_ch_idx; //
-        float*      target_gainA;     // target_gainA[net_proc->poly_cnt]
-        float*      cur_gainA;        // cur_gainA[net_proc->poly_cnt]
-        double      srate;
-        bool        preset_delta_fl;
-        bool        trigFl;
-        bool        trigVal;
+        unsigned    cur_poly_ch_idx;  // This is the active channel.
+        unsigned    next_poly_ch_idx; // This is the next channel that will be active.
+        srate_t     srate;            // Sample rate used for time base
+        bool        preset_delta_fl;  // Preset change trigger flag.
+        bool        trigFl;           // Cross-fade trigger flag.
       } inst_t;
 
       void _trigger_xfade( inst_t* p )
       {
         // begin fading out the cur channel
-        p->target_gainA[ p->cur_poly_ch_idx ] = 0;
+        p->netA[p->cur_poly_ch_idx].target_gain = 0;
         
         // the next poly-ch become the cur poly-ch
         p->cur_poly_ch_idx  = p->next_poly_ch_idx;
 
         // the next poly-ch advances
         p->next_poly_ch_idx = p->next_poly_ch_idx+1 >= p->poly_ch_cnt ? 0 : p->next_poly_ch_idx+1;
-
-        // j selects a block of 'net_proc_cnt' slots in the proxy network which will become the 'next' channel
-        unsigned j = p->next_poly_ch_idx * p->net_proc_cnt;
-
-        // set the [j:j+poly_proc_cnt] pointers in the proxy net to the actual proc instances in the source net
-        for(unsigned i=0; i<p->net_proc->internal_net->proc_arrayN; ++i)
-          if( p->net_proc->internal_net->proc_array[i]->label_sfx_id == p->next_poly_ch_idx )
-          {
-            assert( p->next_poly_ch_idx * p->net_proc_cnt <= j
-                    && j < p->next_poly_ch_idx * p->net_proc_cnt + p->net_proc_cnt
-                    && j < p->net.proc_arrayN );
-            
-            p->net.proc_array[j++] = p->net_proc->internal_net->proc_array[i];
-          }
-
+        
         // begin fading in the new cur channel
-        p->target_gainA[ p->cur_poly_ch_idx ] = 1;
+        p->netA[p->cur_poly_ch_idx].target_gain = 1;
 
         // if the next channel is not already at 0 send it in that direction
-        p->target_gainA[ p->next_poly_ch_idx ] = 0;
+        p->netA[p->next_poly_ch_idx].target_gain = 0;
 
         //printf("xfad:%i %i : %i\n",p->cur_poly_ch_idx, p->next_poly_ch_idx,p->poly_ch_cnt);
 
@@ -3398,24 +3388,23 @@ namespace cw
         const char* netLabel      = nullptr;
         const char* presetLabel   = nullptr;
         unsigned    netLabelSfxId = kBaseSfxId;
-        bool        trigFl        = false;
-        variable_t* gainVar       = nullptr;
         abuf_t*     srateSrc      = nullptr;
-        double      dum_dbl;
+        coeff_t     dum_dbl;
 
         inst_t* p = mem::allocZ<inst_t>();
 
         ctx->userPtr = p;
-        
-        
+
+        if((rc = var_register(ctx,kAnyChIdx,kTriggerPId,"trigger", kBaseSfxId )) != kOkRC )
+          goto errLabel;
+                
         if((rc = var_register_and_get(ctx,kAnyChIdx,
-                                      kNetLabelPId,       "net",       kBaseSfxId, netLabel,
-                                      kNetLabelSfxPId,    "netSfxId",  kBaseSfxId, netLabelSfxId,
-                                      kSrateRefPId,       "srateSrc",  kBaseSfxId, srateSrc,
-                                      kDurMsPId,          "durMs",     kBaseSfxId, p->xfadeDurMs,
-                                      kTriggerPId,        "trigger",   kBaseSfxId, p->trigVal,
-                                      kPresetPId,         "preset",    kBaseSfxId, presetLabel,
-                                      kGainPId,           "gain",      kBaseSfxId, dum_dbl)) != kOkRC )
+                                      kNetLabelPId,    "net",       kBaseSfxId, netLabel,
+                                      kNetLabelSfxPId, "netSfxId",  kBaseSfxId, netLabelSfxId,
+                                      kSrateRefPId,    "srateSrc",  kBaseSfxId, srateSrc,
+                                      kDurMsPId,       "durMs",     kBaseSfxId, p->xfadeDurMs,
+                                      kPresetPId,      "preset",    kBaseSfxId, presetLabel,
+                                      kGainPId,        "gain",      kBaseSfxId, dum_dbl)) != kOkRC )
         {
           goto errLabel; 
         }
@@ -3435,9 +3424,8 @@ namespace cw
 
         p->poly_ch_cnt = p->net_proc->internal_net->poly_cnt;
 
-
         // create the gain output variables - one output for each poly-channel
-        for(unsigned i=1; i<p->net_proc->internal_net->poly_cnt; ++i)
+        for(unsigned i=1; i<p->poly_ch_cnt; ++i)
         {
           variable_t* dum;
           if((rc = var_create(ctx, "gain", i, kGainPId+i, kAnyChIdx, nullptr, kInvalidTFl, dum )) != kOkRC )
@@ -3450,17 +3438,29 @@ namespace cw
         // count of proc's in one poly-ch of the poly network
         p->net_proc_cnt = p->net_proc->internal_net->proc_arrayN / p->net_proc->internal_net->poly_cnt;
 
-        // create the proxy network
-        p->net.proc_arrayAllocN = p->net_proc_cnt * p->poly_ch_cnt;
-        p->net.proc_arrayN      = p->net.proc_arrayAllocN;
-        p->net.proc_array       = mem::allocZ<instance_t*>(p->net.proc_arrayAllocN);
-        p->target_gainA         = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
-        p->cur_gainA            = mem::allocZ<float>(p->net_proc->internal_net->poly_cnt);
-        p->srate                = srateSrc->srate;
+        p->netA = mem::allocZ<poly_ch_t>(p->poly_ch_cnt);
         
-        // make the proxy network public - xfad_ctl now looks like the source network
-        // because it has the same proc instances
-        ctx->internal_net = &p->net;
+        // create the proxy network networks
+        for(unsigned i=0; i<p->poly_ch_cnt; ++i)
+        {
+          p->netA[i].net.proc_arrayAllocN = p->net_proc_cnt;
+          p->netA[i].net.proc_arrayN      = p->netA[i].net.proc_arrayAllocN;
+          p->netA[i].net.proc_array       = mem::allocZ<instance_t*>(p->netA[i].net.proc_arrayAllocN);
+          p->netA[i].net.presetsCfg       = p->net_proc->internal_net->presetsCfg;
+
+          for(unsigned j=0,k=0; j<p->net_proc->internal_net->proc_arrayN; ++j)
+            if( p->net_proc->internal_net->proc_array[j]->label_sfx_id == i )
+            {
+              assert( k < p->net_proc_cnt );
+              p->netA[i].net.proc_array[k++] = p->net_proc->internal_net->proc_array[j];
+            }          
+        }
+
+        if( srateSrc == nullptr )
+          p->srate = ctx->ctx->sample_rate;
+        else
+          p->srate = srateSrc->srate;
+
 
         // setup the channels such that the first active channel after _trigger_xfade()
         // will be channel 0
@@ -3468,8 +3468,6 @@ namespace cw
         p->next_poly_ch_idx = 2;
         _trigger_xfade(p);  // cur=2 nxt=0 initialize inst ptrs in range: p->net[0:net_proc_cnt]
         _trigger_xfade(p);  // cur=0 nxt=1 initialize inst ptrs in range: p->net[net_proc_cnt:2*net_proc_cnt]
-
-
         
       errLabel:
         return rc;
@@ -3478,9 +3476,10 @@ namespace cw
       rc_t destroy( instance_t* ctx )
       {
         inst_t* p = (inst_t*)ctx->userPtr;
-        mem::release(p->net.proc_array);
-        mem::release(p->target_gainA);
-        mem::release(p->cur_gainA);
+        for(unsigned i=0; i<p->poly_ch_cnt; ++i)
+          mem::release(p->netA[i].net.proc_array);
+        
+        mem::release(p->netA);
         mem::release(ctx->userPtr);
         
         return kOkRC;
@@ -3488,24 +3487,20 @@ namespace cw
 
       rc_t value( instance_t* ctx, variable_t* var )
       {
-        rc_t rc = kOkRC;
-        inst_t* p = (inst_t*)ctx->userPtr;
-        
-        if(var->vid == kTriggerPId )
+        rc_t    rc = kOkRC;
+        inst_t* p  = (inst_t*)ctx->userPtr;
+
+        switch( var->vid )
         {
-          bool v;
-          if((rc = var_get(var,v)) == kOkRC )
-          {
-            if( !p->trigFl )
-              p->trigFl = p->trigVal != v;
-                
-            p->trigVal = v;
-          }
-          //printf("tr:%i %i %i\n",v,p->trigVal,p->trigFl);
+          case kTriggerPId:
+            p->trigFl = true;
+            break;
 
-          
+          case kPresetPId:
+            p->preset_delta_fl = true;
+            break;
         }
-
+        
         return kOkRC;
       }
 
@@ -3517,29 +3512,52 @@ namespace cw
         rc_t    rc     = kOkRC;
         inst_t* p      = (inst_t*)ctx->userPtr;
 
-        // check if a cross-fade has been triggered
-        if(p->trigFl )
-        {
-          p->trigFl = false;
-          _trigger_xfade(p);
-        }
-        
         // time in sample frames to complete a xfade
         double xfade_dur_smp        = p->xfadeDurMs * p->srate / 1000.0;
 
         // fraction of a xfade which will be completed in on exec() cycle
         float delta_gain_per_cycle =  (float)(ctx->ctx->framesPerCycle / xfade_dur_smp);
 
+
+        if( p->preset_delta_fl )
+        {
+          const char* preset_label = nullptr;
+          
+          p->preset_delta_fl = false;
+
+          if((rc = var_get(ctx,kPresetPId,kAnyChIdx,preset_label)) != kOkRC )
+          {
+            rc = cwLogError(rc,"Preset label access failed.");
+            goto errLabel;
+          }
+          
+          if((rc = network_apply_preset(p->netA[p->next_poly_ch_idx].net, preset_label,p->next_poly_ch_idx)) != kOkRC )
+          {
+            rc = cwLogError(rc,"Appy preset '%s' failed.",cwStringNullGuard(preset_label));
+            goto errLabel;
+          }
+        }
+        
+        // check if a cross-fade has been triggered
+        if(p->trigFl )
+        {
+          p->trigFl = false;
+          _trigger_xfade(p);
+        }
+
         // update the cross-fade gain outputs
         for(unsigned i=0; i<p->net_proc->internal_net->poly_cnt; ++i)
         {
-          p->cur_gainA[i] += _signum(p->target_gainA[i] - p->cur_gainA[i]) * delta_gain_per_cycle;
+          p->netA[i].cur_gain += _signum(p->netA[i].target_gain - p->netA[i].cur_gain) * delta_gain_per_cycle;
           
-          p->cur_gainA[i] = std::min(1.0f, std::max(0.0f, p->cur_gainA[i]));
+          p->netA[i].cur_gain = std::min(1.0f, std::max(0.0f, p->netA[i].cur_gain));
           
-          var_set(ctx,kGainPId+i,kAnyChIdx,p->cur_gainA[i]);
+          var_set(ctx,kGainPId+i,kAnyChIdx,p->netA[i].cur_gain);
         }
         
+        
+
+        
       errLabel:
         return rc;
       }
@@ -4402,7 +4420,8 @@ namespace cw
       {
         kInPId,
         kListPId,
-        kOutPId
+        kOutPId,
+        kValueBasePId
       };
       
       typedef struct
@@ -4509,7 +4528,7 @@ namespace cw
       }
 
       template< typename T >
-      rc_t _set_out_tmpl( instance_t* proc, inst_t* p, unsigned idx, T& v )
+      rc_t _set_out_tmpl( instance_t* proc, inst_t* p, unsigned idx, unsigned vid, T& v )
       {
         rc_t rc;
         const object_t* ele;        
@@ -4529,7 +4548,7 @@ namespace cw
         }
 
         // set the output
-        if((rc = var_set(proc,kOutPId,kAnyChIdx,v)) != kOkRC )
+        if((rc = var_set(proc,vid,kAnyChIdx,v)) != kOkRC )
         {
           rc = cwLogError(rc,"List output failed on index %i",idx);
           goto errLabel;          
@@ -4539,6 +4558,64 @@ namespace cw
         return rc;
       }
 
+      rc_t _set_output( instance_t* proc, inst_t* p, unsigned idx, unsigned vid )
+      {
+        rc_t rc;
+
+        switch( p->typeFl )
+        {
+          case kUIntTFl:
+            {
+              unsigned v;
+              rc = _set_out_tmpl(proc,p,idx,vid,v);
+            }
+            break;
+            
+          case kIntTFl:
+            {
+              int v;
+              rc = _set_out_tmpl(proc,p,idx,vid,v);
+            }
+            break;
+            
+          case kFloatTFl:
+            {
+              float v;
+              rc = _set_out_tmpl(proc,p,idx,vid,v);
+            }
+            break;
+            
+          case kDoubleTFl:
+            {
+              double v;
+              rc = _set_out_tmpl(proc,p,idx,vid,v); 
+            }
+            break;
+            
+          case kStringTFl:
+            {
+              const char* v;
+              rc = _set_out_tmpl(proc,p,idx,vid,v);
+            }
+            break;
+            
+          case kCfgTFl:
+            {
+              const object_t* v;
+              rc = _set_out_tmpl(proc,p,idx,vid,v);
+            }
+            break;
+            
+          default:
+            rc = cwLogError(kInvalidArgRC,"The list type flag %s (0x%x) is not valid.",value_type_flag_to_label(p->typeFl),p->typeFl);
+            break;
+            
+        }
+
+      errLabel:
+        return rc;
+      }
+
       rc_t _set_output( instance_t* proc, inst_t* p )
       {
         rc_t rc;
@@ -4554,64 +4631,16 @@ namespace cw
         if( idx == p->index )
           goto errLabel;
 
-        switch( p->typeFl )
-        {
-          case kUIntTFl:
-            {
-              unsigned v;
-              rc = _set_out_tmpl(proc,p,idx,v);
-            }
-            break;
-            
-          case kIntTFl:
-            {
-              int v;
-              rc = _set_out_tmpl(proc,p,idx,v);
-            }
-            break;
-            
-          case kFloatTFl:
-            {
-              float v;
-              rc = _set_out_tmpl(proc,p,idx,v);
-            }
-            break;
-            
-          case kDoubleTFl:
-            {
-              double v;
-              rc = _set_out_tmpl(proc,p,idx,v); 
-            }
-            break;
-            
-          case kStringTFl:
-            {
-              const char* v;
-              rc = _set_out_tmpl(proc,p,idx,v);
-            }
-            break;
-            
-          case kCfgTFl:
-            {
-              const object_t* v;
-              rc = _set_out_tmpl(proc,p,idx,v);
-            }
-            break;
-            
-          default:
-            rc = cwLogError(kInvalidArgRC,"The list type flag %s (0x%x) is not valid.",value_type_flag_to_label(p->typeFl),p->typeFl);
-            break;
-            
-        }
-
-        if(rc != kOkRC )
+        if((rc = _set_output(proc,p,idx, kOutPId )) != kOkRC )
           goto errLabel;
 
         p->index = idx;
-        
+
       errLabel:
         return rc;
       }
+        
+      
 
       rc_t create( instance_t* proc )
       {
@@ -4656,6 +4685,24 @@ namespace cw
         // set the initial value of the output 
         if((rc = _set_output(proc,p)) != kOkRC )
           goto errLabel;
+                
+        // create the output variable
+        for(unsigned i=0; i<p->listN; ++i)
+        {
+          if((rc = var_create( proc, "value", i, kValueBasePId+i, kAnyChIdx, nullptr, p->typeFl, dum )) != kOkRC )
+          {
+            rc = cwLogError(rc,"'value%i' var create failed.",i);
+            goto errLabel;
+          }
+
+          if((rc = _set_output(proc, p, i, kValueBasePId+i )) != kOkRC )
+          {
+            rc = cwLogError(rc,"'value%i' output failed.",i);
+            goto errLabel;            
+          }
+
+        }
+       
         
       errLabel:
         return rc;

From 4a90b6b1b699daac6996b5756cb39e562bcc387e Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 3 May 2024 09:22:27 -0400
Subject: [PATCH 049/101] README.md : Updates

---
 README.md | 58 +++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 52 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 83a2e61..3fb4ccd 100644
--- a/README.md
+++ b/README.md
@@ -862,8 +862,7 @@ value should not be updated and distinguish it from an error code - which should
 
 - Variable attributes should be meaningful. e.g. src,src_opt,mult,init, ....
   Should we check for 'src' or 'mult' attribute on var's?
-  
-- Enforce var attributes.
+  (In other words: Enforce var attributes.)
 
 -  String assignment is allocating  memory:
    See: `rc_t _val_set( value_t* val, const char* v ) cwFlowTypes.cpp line:464.`
@@ -889,9 +888,11 @@ ports of the internal elements.
 
 - 'poly' and 'sub' should be arbitrarily nestable. DONE?
 
-
 - Reduce runtime overhead for var get/set operations.
+  
+- Implement matrix types.
 
+- Should the `object_t` be used in place of `value_t`?
 
 - DONE: Allow multiple types on an input.
    For example 'adder' should have a single input 
@@ -909,8 +910,53 @@ printing the values for kAnyChIdx
 
 Next:
 
-- Implement 'preset' proc. This will involve implementing the 'cfg' datatype.
+There is no way for a proc in a poly context to use it's poly channel number to 
+select a mult variable.
 
-- Finish the 'poly' frawework. We are making 'mult' var's, but do any of the procs explicitly deal with them?
+The counter modulo mode is not working as expected.
 
-- Turn on variable 'broadcast'.  Why was it turned off? ... maybe multiple updates?
+
+
+- DONE: Implement 'preset' proc. This will involve implementing the 'cfg' datatype.
+
+- DONE: Finish the 'poly' frawework. We are making 'mult' var's, but do any of the procs explicitly deal with them?
+
+- DONE: Turn on variable 'broadcast'.  Why was it turned off? ... maybe multiple updates?
+
+```
+	
+mod_osc: {
+
+	vars:
+	{
+      hz:            { type:hz_lfo.dc,     doc:"Audio frequency" },
+	  hz_mod_hz:     { type:hz_lfo.hz,     doc:"Frequency modulator hz" },
+	  hz_mod_depth:  { type:hz_lfo.gain,   doc:Frequency modulator depth" },
+	  amp_mod_hz:    { type:amp_lfo.hz,    doc:Amplitude modulator hz" },
+	  amp_mod_depth: { type:amp_lfo.gain,  doc:Amplutide modulator depth."},
+	  out:           { type:gain.out       doc:"Oscillator output."},
+	}
+	
+	presets: {
+	  
+	}
+
+	network: {
+	  procs: {
+		  hz_lfo:   { class: sine_tone,   in:{ dc:hz, gain:hz_mod_depth, hz:hz_mod_hz }, args: { default:{ chCnt:1, hz:3, dc:440, gain:110 }}}
+	      hz_sh:    { class: sample_hold, in:{ in:hz_lfo.out }}
+
+		  amp_lfo:   { class: sine_tone,   in:{ gain:amp_mod_depth, hz:amp_mod_hz }, args: { default:{ chCnt:1, hz:3, gain:110 }}}
+	      amp_sh:    { class: sample_hold, in:{ in:amp_lfo.out }}
+
+	      osc:   { class: sine_tone,   in:{ hz: hz_sh.out }}	
+		  gain:  { class: audio_gain,  in:{ in:osc.out, gain:amp_sh.out}}
+	  }
+	  
+	  presets: {
+	  }
+	
+	}
+
+}
+```

From e86451b7a27fda5a7163312557fd0addd44e64f1 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sun, 5 May 2024 17:31:42 -0400
Subject: [PATCH 050/101] cwFlow,cwFlowNet,cwFlowTypes,cwFlowProc : Initial
 working subnet.

---
 cwFlow.cpp      | 392 ++++++++++++++++++++++++++++++++++++++++++++----
 cwFlow.h        |  11 +-
 cwFlowCross.cpp |   2 +-
 cwFlowNet.cpp   | 158 +++++++++++++++++--
 cwFlowNet.h     |   7 +-
 cwFlowProc.cpp  |  88 ++++++++++-
 cwFlowProc.h    |   1 +
 cwFlowTypes.cpp |  52 ++++---
 cwFlowTypes.h   |  35 +++--
 cwIoFlow.cpp    |   1 -
 10 files changed, 661 insertions(+), 86 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index 16e0f73..c846b76 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -29,6 +29,7 @@ namespace cw
     } library_t;
     
     library_t g_library[] = {
+      { "subnet",          &subnet::members },
       { "poly",            &poly::members },
       { "midi_in",         &midi_in::members },
       { "midi_out",        &midi_out::members },
@@ -175,7 +176,7 @@ namespace cw
           // get the class member functions
           if((cd->members = _find_library_record(cd->label)) == nullptr )
           {
-            rc = cwLogError(kSyntaxErrorRC,"The '%s' class member function record could not be found..", cd->label );
+            rc = cwLogError(kSyntaxErrorRC,"The '%s' class member function record could not be found.", cd->label );
             goto errLabel;                    
           }
 
@@ -243,21 +244,319 @@ namespace cw
       return rc;
     }
 
+    rc_t _find_subnet_proc_class_desc( flow_t* p, const object_t* subnetProcD, const char* procInstLabel, const class_desc_t*& class_desc_ref )
+    {
+      rc_t                rc          = kOkRC;
+      const object_t*     procInstD   = nullptr;
+      const object_t*     classStr    = nullptr;
+      const class_desc_t* class_desc  = nullptr;
+      const char*         class_label = nullptr;
 
+      class_desc_ref = nullptr;
+        
+      // find the proc inst dict in the subnet
+      if((procInstD = subnetProcD->find_child(procInstLabel)) == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance '%s' from the proxy var list could not be foud in the subnet.",cwStringNullGuard(procInstLabel));
+        goto errLabel;
+      }
+
+      // find the proc class label of the proc inst
+      if((classStr = procInstD->find_child("class")) == nullptr || (rc = classStr->value(class_label))!=kOkRC)
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The 'class' field could not be found in the '%s' proc instance record.", cwStringNullGuard(procInstLabel));
+        goto errLabel;
+      }
+
+      // find the associated class desc record
+      if((class_desc_ref = class_desc_find(p,class_label)) == nullptr)
+      {
+        rc = cwLogError(kEleNotFoundRC,"The class desc record '%s' for the proc instance '%s' could not be found.",class_label,cwStringNullGuard(procInstLabel));
+        goto errLabel;
+      }
+
+    errLabel:
+      
+      return rc;
+    }
+
+
+    rc_t _parse_subnet_var_proxy_string( const char* proxyStr, char*& procLabel_ref, char*& varLabel_ref )
+    {
+      rc_t rc       = kOkRC;
+      procLabel_ref = nullptr;
+      varLabel_ref  = nullptr;
+
+      const char* period;
+
+      // find the separating period
+      if((period = firstMatchChar(proxyStr,'.')) == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The separating '.' could not be found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
+        goto errLabel;
+      }
+
+      // validate the length of the proc inst label
+      if( period-proxyStr == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"No proxy proc instance was found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
+        goto errLabel;        
+      }
+
+      // validate the length of the var label
+      if( textLength(period+1) == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"No proxy var was found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
+        goto errLabel;        
+      }
+
+      
+      procLabel_ref = mem::duplStr(proxyStr,period-proxyStr);
+      varLabel_ref  = mem::duplStr(period+1);
+
+    errLabel:
+      return rc;
+    }
+
+    void _var_desc_release( var_desc_t*& vd )
+    {
+      mem::release(vd->proxyProcLabel);
+      mem::release(vd->proxyVarLabel);
+      mem::release(vd);
+    }
+
+    rc_t _create_subnet_var_desc( flow_t* p, class_desc_t* wrapProcClassDesc, const object_t* subnetProcD, const object_t* varDescPair, var_desc_t*& vd_ref )
+    {
+      rc_t                rc               = kOkRC;
+      const object_t*     flagsCfg         = nullptr;
+      const char*         proxyStr         = nullptr;
+      const char*         docStr           = nullptr;
+      const char*         varLabel         = nullptr;
+      char*               proxyProcLabel   = nullptr;
+      char*               proxyVarLabel    = nullptr;
+      unsigned            proxyVarFlags    = 0;
+      const class_desc_t* proxy_class_desc = nullptr;
+      const var_desc_t*   proxy_var_desc   = nullptr;
+      bool                subnetOutVarFl   = false;
+      var_desc_t*         var_desc         = mem::allocZ<var_desc_t>();
+      
+      vd_ref = nullptr;
+
+      // verify that the var label is valid
+      if(!varDescPair->is_pair() || (varLabel=varDescPair->pair_label())==nullptr || varDescPair->pair_value()==nullptr || !varDescPair->pair_value()->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proxy var entry is not valid.");
+        goto errLabel;
+      }
+
+      // parse the var desc dictionary
+      if((rc = varDescPair->pair_value()->getv("proxy",proxyStr,
+                                               "doc",  docStr)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parsing failed on the proxy var dictionary.");
+        goto errLabel;
+      }
+
+      // parse the var desc dictionary optional fields
+      if((rc = varDescPair->pair_value()->getv_opt("flags", flagsCfg)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Optional attribute parsing failed on the proxy var dictionary.");
+        goto errLabel;
+      }
+      
+      // parse the proxy string into it's two parts: <proc>.<var>
+      if((rc = _parse_subnet_var_proxy_string( proxyStr, proxyProcLabel, proxyVarLabel )) != kOkRC )
+      {
+        goto errLabel;
+      }
+      
+      // locate the class desc associated with proxy proc
+      if((rc = _find_subnet_proc_class_desc( p, subnetProcD, proxyProcLabel, proxy_class_desc )) != kOkRC )
+      {
+        goto errLabel;
+      }
+
+      // locate the var desc associated with the proxy proc var
+      if((proxy_var_desc = var_desc_find( proxy_class_desc, proxyVarLabel)) == nullptr )
+      {
+        rc = cwLogError(kEleNotFoundRC,"The variable desc '%s.%s' could not be found.",cwStringNullGuard(proxyProcLabel),cwStringNullGuard(proxyVarLabel));
+        goto errLabel;                        
+      }
+
+      // most of the fields for the proxy are taken directly from the the actual var ...
+      *var_desc = *proxy_var_desc;
+      
+      var_desc->label   = varLabel;  // ... but the label and doc are overwritten from subnet desc.
+      var_desc->docText = docStr;
+      var_desc->proxyProcLabel = proxyProcLabel;
+      var_desc->proxyVarLabel  = proxyVarLabel;
+      var_desc->link    = nullptr;
+
+      if((rc = _is_var_flag_set( flagsCfg, "out", wrapProcClassDesc->label, var_desc->label, subnetOutVarFl )) != kOkRC )
+        goto errLabel;
+
+      var_desc->flags = cwEnaFlag(var_desc->flags, kSubnetOutVarFl, subnetOutVarFl);
+      
+      vd_ref = var_desc;
+
+    errLabel:
+
+      if( rc != kOkRC )
+      {        
+        rc = cwLogError(rc,"The creation of proxy var '%s' failed.",cwStringNullGuard(varLabel));
+        _var_desc_release(var_desc);
+      }
+      
+      return rc;
+    }
     
-    rc_t _destroy( flow_t* p)
+    rc_t _parse_subnet_vars( flow_t* p, class_desc_t* class_desc, const object_t* subnetProcD, const object_t* varD )
     {
       rc_t rc = kOkRC;
 
-      if( p == nullptr )
-        return rc;
-
-      network_destroy(p->net);
+      unsigned varN = 0;
       
-      // release the class records
-      for(unsigned i=0; i<p->classDescN; ++i)
+      if( !varD->is_dict() )
       {
-        class_desc_t* cd  = p->classDescA + i;
+        rc = cwLogError(kSyntaxErrorRC,"The proxy variable dictionary is invalid.");
+        goto errLabel;
+      }
+
+      varN = varD->child_count();
+
+      // Fill the class_Desc.varDescL list from the subnet 'vars' dictioanry
+      for(unsigned i=0; i<varN; ++i)
+      {
+        const object_t* child_pair = varD->child_ele(i);
+        var_desc_t*     var_desc   = nullptr;
+
+        if((rc = _create_subnet_var_desc( p, class_desc, subnetProcD, child_pair, var_desc )) != kOkRC )
+          goto errLabel;
+
+
+        var_desc->link = class_desc->varDescL;
+        class_desc->varDescL = var_desc;
+
+        //printf("Wrapper var-desc created: %i of %i : %s:%s proxy:%s:%s flags:%i.\n", i, varN, class_desc->label, var_desc->label, var_desc->proxyProcLabel,var_desc->proxyVarLabel,var_desc->flags);
+        
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _create_subnet_class_desc( flow_t* p, const object_t* class_obj, class_desc_t* class_desc )
+    {
+      rc_t            rc                  = kOkRC;
+      const object_t* varD                = nullptr;
+      const object_t* subnetD             = nullptr;
+      const object_t* subnetProcD         = nullptr;
+      const object_t* subnetPresetD       = nullptr;          
+      const char*     subnetProcDescLabel = nullptr;
+
+      // Validate the subnet proc desc label and value
+      if( class_obj==nullptr || !class_obj->is_pair() || class_obj->pair_value()==nullptr || !class_obj->pair_value()->is_dict() || (subnetProcDescLabel = class_obj->pair_label()) == nullptr )
+      {
+        rc = cwLogError(kInvalidArgRC,"An invalid subnet description '%s' was encountered.",cwStringNullGuard(subnetProcDescLabel));
+        goto errLabel;
+      }
+
+      // verify that another subnet with the same name does not already exist
+      if( class_desc_find(p,subnetProcDescLabel) != nullptr )
+      {
+        rc = cwLogError(kInvalidStateRC,"A subnet named '%s' already exists.",subnetProcDescLabel);
+        goto errLabel;
+      }
+
+      class_desc->cfg    = class_obj->pair_value();
+      class_desc->label  = class_obj->pair_label();
+
+      // get the 'subnet' members record
+      if((class_desc->members = _find_library_record("subnet")) == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The 'subnet' class member function record could not be found." );
+        goto errLabel;                    
+      }
+                
+      // get the variable description 
+      if((rc = class_desc->cfg->getv_opt("vars",  varD,
+                                         "network", subnetD)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parse failed while parsing subnet desc:'%s'", cwStringNullGuard(class_desc->label) );
+        goto errLabel;                      
+      }
+
+      // get the subnet proc and preset dictionaries
+      if((rc = subnetD->getv("procs",   subnetProcD,
+                             "presets", subnetPresetD)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parse failed on the 'network' element.");
+        goto errLabel;
+      }
+
+      // fill class_desc.varDescL from the subnet vars dictionary
+      if((rc = _parse_subnet_vars( p, class_desc, subnetProcD, varD )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Subnet 'vars' processing failed.");
+        goto errLabel;          
+      }
+
+      
+    errLabel:
+      if(rc != kOkRC )
+        rc = cwLogError(rc,"'proc' class description creation failed for the subnet '%s'. ",cwStringNullGuard(subnetProcDescLabel));
+        
+      return rc;
+    }
+        
+  
+    rc_t  _parse_subnet_cfg(flow_t* p, const object_t* subnetCfg)
+    {
+      rc_t rc = kOkRC;
+      
+      if( !subnetCfg->is_dict() )
+        return cwLogError(kSyntaxErrorRC,"The subnet class description dictionary does not have dictionary syntax.");
+              
+      unsigned subnetDescN = subnetCfg->child_count();
+      p->subnetDescA = mem::allocZ<class_desc_t>( subnetDescN );      
+
+      // for each subnet description
+      for(unsigned i=0; i<subnetDescN; ++i)
+      {
+        const object_t* subnet_obj = subnetCfg->child_ele(i);
+
+        if((rc = _create_subnet_class_desc(p, subnet_obj, p->subnetDescA + i )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Subnet class description create failed on the subnet at index:%i.",i);
+          goto errLabel;
+        }
+
+        // we have to update the size of the subnet class array
+        // as we go because we may want to find subnets classes within
+        // subnets which are definted later and so the length p->subnetA[]
+        // must be correct 
+        p->subnetDescN += 1;
+      }
+
+      assert( subnetDescN == p->subnetDescN );
+    errLabel:
+
+      if( rc != kOkRC )
+      {
+        rc = cwLogError(rc,"Subnet processing failed.");
+        
+      }
+      
+      return rc;
+
+    }
+
+    void _release_class_desc_array( class_desc_t*& classDescA, unsigned classDescN )
+    {
+      // release the class records
+      for(unsigned i=0; i<classDescN; ++i)
+      {
+        class_desc_t* cd  = classDescA + i;
 
         // release the var desc list
         var_desc_t*   vd0 = cd->varDescL;
@@ -265,7 +564,7 @@ namespace cw
         while( vd0 != nullptr )
         {
           vd1 = vd0->link;
-          mem::release(vd0);
+          _var_desc_release(vd0);
           vd0 = vd1;
         }
 
@@ -280,8 +579,20 @@ namespace cw
         }
       }
 
-      mem::release(p->classDescA);
+      mem::release(classDescA);      
+    }
+    
+    rc_t _destroy( flow_t* p)
+    {
+      rc_t rc = kOkRC;
 
+      if( p == nullptr )
+        return rc;
+
+      network_destroy(p->net);
+      
+      _release_class_desc_array(p->classDescA,p->classDescN);
+      _release_class_desc_array(p->subnetDescA,p->subnetDescN);
       
       mem::release(p);
       
@@ -308,8 +619,9 @@ void cw::flow::print_external_device( const external_device_t* dev )
 
 
 cw::rc_t cw::flow::create( handle_t&          hRef,
-                           const object_t&    classCfg,
-                           const object_t&    flowCfg,
+                           const object_t*    classCfg,
+                           const object_t*    flowCfg,
+                           const object_t*    subnetCfg,
                            external_device_t* deviceA,
                            unsigned           deviceN )
 {
@@ -317,24 +629,32 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   const object_t* networkCfg       = nullptr; 
   bool            printClassDictFl = false;
   bool            printNetworkFl   = false;
+  variable_t*     proxyVarL        = nullptr;
   
   if(( rc = destroy(hRef)) != kOkRC )
     return rc;
 
   flow_t* p   = mem::allocZ<flow_t>();
-  p->flowCfg    = &flowCfg;   // TODO: duplicate cfg?
+  p->flowCfg    = flowCfg;   // TODO: duplicate cfg?
   p->deviceA    = deviceA;
   p->deviceN    = deviceN;
 
   // parse the class description array
-  if((rc = _parse_class_cfg(p,&classCfg)) != kOkRC )
+  if((rc = _parse_class_cfg(p,classCfg)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the class description list.");
     goto errLabel;    
   }
 
+  if( subnetCfg != nullptr )
+    if((rc = _parse_subnet_cfg(p,subnetCfg)) != kOkRC )
+    {
+      rc = cwLogError(kSyntaxErrorRC,"Error parsing the subnet list.");
+      goto errLabel;          
+    }
+
   // parse the main audio file processor cfg record
-  if((rc = flowCfg.getv("network",             networkCfg)) != kOkRC )
+  if((rc = flowCfg->getv("network", networkCfg)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the required flow configuration parameters.");
     goto errLabel;
@@ -344,7 +664,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   p->sample_rate    = kDefaultSampleRate;
 
   // parse the optional args
-  if((rc = flowCfg.getv_opt("framesPerCycle",       p->framesPerCycle,
+  if((rc = flowCfg->getv_opt("framesPerCycle",      p->framesPerCycle,
                             "sample_rate",          p->sample_rate,
                             "maxCycleCount",        p->maxCycleCount,
                             "multiPriPresetProbFl", p->multiPriPresetProbFl,
@@ -375,7 +695,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
       class_dict_print( p );
 
   // instantiate the network
-  if((rc = network_create(p,networkCfg,p->net)) != kOkRC )
+  if((rc = network_create(p,networkCfg,p->net,proxyVarL)) != kOkRC )
   {
     rc = cwLogError(rc,"Network creation failed.");
     goto errLabel;
@@ -535,10 +855,12 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
   rc_t rc = kOkRC;
   handle_t flowH;
 
-  object_t* class_cfg = nullptr;
-  const object_t* test_cases_cfg = nullptr;
-  const object_t* test_cfg = nullptr;
-  const char* flow_proc_fname;
+  const char*     proc_cfg_fname   = nullptr;
+  const char*     subnet_cfg_fname = nullptr;
+  const object_t* test_cases_cfg   = nullptr;
+  object_t*       class_cfg        = nullptr;
+  object_t*       subnet_cfg       = nullptr;
+  const object_t* test_cfg         = nullptr;
 
   if( argc < 2 || textLength(argv[1]) == 0 )
   {
@@ -546,13 +868,20 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     goto errLabel;
   }
   
-  if((rc = cfg->getv("flow_proc_fname",flow_proc_fname,
-                     "test_cases",test_cases_cfg)) != kOkRC )
+  if((rc                                                 = cfg->getv("proc_cfg_fname",proc_cfg_fname,
+                     "test_cases",     test_cases_cfg)) != kOkRC )
   {
     rc = cwLogError(rc,"The name of the flow_proc_dict file could not be parsed.");
     goto errLabel;
   }
 
+  // get the subnet cfg filename
+  if((rc = cfg->getv_opt("subnet_cfg_fname",subnet_cfg_fname)) != kOkRC )
+  {
+    rc = cwLogError(rc,"The name of the subnet file could not be parsed.");
+    goto errLabel;
+  }
+
   // find the user requested test case
   if((test_cfg = test_cases_cfg->find_child(argv[1])) == nullptr )
   {
@@ -560,15 +889,22 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     goto errLabel;
   }  
 
-  // parse the flow-proc-cfg
-  if((rc = objectFromFile(flow_proc_fname,class_cfg)) != kOkRC )
+  // parse the proc dict. file
+  if((rc = objectFromFile(proc_cfg_fname,class_cfg)) != kOkRC )
   {
-    rc = cwLogError(rc,"The flow proc dict could not be read from '%s'.",cwStringNullGuard(flow_proc_fname));
+    rc = cwLogError(rc,"The proc dictionary could not be read from '%s'.",cwStringNullGuard(proc_cfg_fname));
     goto errLabel;
   }
 
+  // parse the subnet dict file
+  if((rc = objectFromFile(subnet_cfg_fname,subnet_cfg)) != kOkRC )
+  {
+    rc = cwLogError(rc,"The subnet dictionary could not be read from '%s'.",cwStringNullGuard(subnet_cfg_fname));
+    goto errLabel;
+  }
+  
   // create the flow object
-  if((rc = create( flowH, *class_cfg, *test_cfg)) != kOkRC )
+  if((rc = create( flowH, class_cfg, test_cfg, subnet_cfg)) != kOkRC )
   {
     rc = cwLogError(rc,"Flow object create failed.");
     goto errLabel;
diff --git a/cwFlow.h b/cwFlow.h
index 722775a..17fc29b 100644
--- a/cwFlow.h
+++ b/cwFlow.h
@@ -14,11 +14,12 @@ namespace cw
     void print_external_device( const external_device_t* dev );
     
 
-    rc_t create( handle_t&             hRef,
-                 const object_t&       classCfg,
-                 const object_t&       networkCfg,
-                 external_device_t*    deviceA = nullptr,
-                 unsigned              deviceN = 0);
+    rc_t create( handle_t&          hRef,
+                 const object_t*    classCfg,
+                 const object_t*    networkCfg,
+                 const object_t*    subnetCfg = nullptr,   
+                 external_device_t* deviceA   = nullptr,
+                 unsigned           deviceN   = 0);
 
     rc_t destroy( handle_t& hRef );
 
diff --git a/cwFlowCross.cpp b/cwFlowCross.cpp
index c47afc7..330ebed 100644
--- a/cwFlowCross.cpp
+++ b/cwFlowCross.cpp
@@ -146,7 +146,7 @@ namespace cw
       net->stateId = net_idx == 0 ? kActiveStateId : kInactiveStateId;
       net->net_idx = net_idx;
       
-      if((rc = flow::create( net->flowH, classCfg, networkCfg, net->deviceA, deviceN )) == kOkRC )
+      if((rc = flow::create( net->flowH, &classCfg, &networkCfg, nullptr, net->deviceA, deviceN )) == kOkRC )
         net->deviceN = deviceN;
       else
       {
diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index f0b769a..3fe0ef8 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -1263,8 +1263,16 @@ namespace cw
       
       return rc;      
     }
+
+    const variable_t* _find_proxy_var( const char* procInstLabel, const char* varLabel, const variable_t* proxyVarL )
+    {
+      for(const variable_t* proxyVar=proxyVarL; proxyVar!=nullptr; proxyVar=proxyVar->var_link)
+        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procInstLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
+          return proxyVar;
+      return nullptr;
+    }
     
-    rc_t _parse_in_list( network_t& net, instance_t* inst, proc_inst_parse_state_t& pstate )
+    rc_t _parse_in_list( network_t& net, instance_t* inst, variable_t* proxyVarL, proc_inst_parse_state_t& pstate )
     {
       rc_t            rc     = kOkRC;
       
@@ -1315,6 +1323,16 @@ namespace cw
         // create the var
         if( in_stmt.create_in_fl )
         {
+          const variable_t* proxy_var;
+          
+          // a variable cannot be in the 'in' list if it is used a a subnet variable
+          if((proxy_var = _find_proxy_var(inst->label, in_stmt.in_var_ele.label, proxyVarL)) != nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The variable:'%s' cannot be used as the in-var of an 'in' statement if it is a subnet variable: '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label),cwStringNullGuard(proxy_var->label));
+            goto errLabel;
+          }
+
+          
           for(unsigned i=0; i<in_stmt.iter_cnt; ++i)
           {
             variable_t* dum = nullptr;        
@@ -1339,12 +1357,105 @@ namespace cw
       return rc;      
     }
 
-    bool _is_var_inst_already_created( const char* var_label, const proc_inst_parse_state_t& pstate )
+    // This function is used to create the variables on procs
+    // inside subnets which are represented by interface variables
+    // on the subnet wrapper.
+    // 'inst' is a proc on the subnet's internal proc list
+    // 'wrap_varL' is a list of all the variables on the wrapper proc.
+    // These wrapper variables mirror variables on some of the internal subnet proc's.
+    // The function finds the variables in wrap_varL that mirror
+    // variables in 'inst' and instantiates them.  It then connects the wrapper
+    // variable to the proc-inst variable for input variables or
+    // proc-inst variable to the wrapper variable for output variables.
+    rc_t  _create_proxied_vars( instance_t* inst, variable_t* wrap_varL )
+    {
+      rc_t rc = kOkRC;
+      
+      for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link )
+      {
+        // if this wrap_var is on this proc (inst->label)
+        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,inst->label) )
+        {
+          
+          variable_t* var;
+
+          if((rc = var_create( inst, wrap_var->varDesc->proxyVarLabel, wrap_var->label_sfx_id, kInvalidId, wrap_var->chIdx, nullptr, kInvalidTFl, var )) != kOkRC )
+          {
+            rc = cwLogError(rc,"Subnet variable creation failed for %s:%s on wrapper variable:%s:%s.",cwStringNullGuard(wrap_var->varDesc->proxyProcLabel),cwStringNullGuard(wrap_var->varDesc->proxyVarLabel),cwStringNullGuard(wrap_var->inst->label),cwStringNullGuard(wrap_var->label));
+            goto errLabel;
+          }
+
+          //printf("Proxy matched: %s %s %s : flags:%i.\n",inst->label, wrap_var->varDesc->proxyVarLabel, wrap_var->label,wrap_var->varDesc->flags );
+
+          var->flags |= kProxiedVarFl;
+          
+          if( cwIsFlag(wrap_var->varDesc->flags,kSubnetOutVarFl) )
+            var->flags |= kProxiedOutVarFl;
+        }
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    variable_t* _find_wrap_var( variable_t* wrap_varL, variable_t* var )
+    {
+      for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link)
+        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,var->inst->label) && textIsEqual(wrap_var->varDesc->proxyVarLabel,var->label) && (wrap_var->label_sfx_id==var->label_sfx_id) )
+          return wrap_var;
+        
+      return nullptr;
+    }
+    
+    rc_t _connect_wrapped_vars( instance_t* inst, variable_t* wrap_varL )
+    {
+      rc_t rc = kOkRC;
+      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+      {
+        if( cwIsFlag(var->flags,kProxiedVarFl) )
+        {
+          variable_t* wrap_var;
+          if((wrap_var = _find_wrap_var(wrap_varL,var)) == nullptr )
+          {
+            rc = cwLogError(kEleNotFoundRC,"The wrapped variable '%s:%i' not found on '%s:%i'.",var->label,var->label_sfx_id,inst->label,inst->label_sfx_id);
+            goto errLabel;
+          }
+          
+          if( cwIsFlag(var->flags,kProxiedOutVarFl) )
+          {
+            //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
+            //       var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,
+            //       wrap_var->inst->label,wrap_var->inst->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id );
+            
+            var_connect(var,wrap_var);
+          }
+          else
+          {
+            //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
+            //       wrap_var->inst->label,wrap_var->inst->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id,
+            //       var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id );
+            
+            var_connect(wrap_var,var);
+          }          
+        }
+      }
+
+      errLabel:
+        return rc;
+    }
+    
+
+    
+    bool _is_var_inst_already_created( instance_t* inst, const char* var_label, const proc_inst_parse_state_t& pstate )
     {
       for(unsigned i=0; i<pstate.in_arrayN; ++i)
         if( textIsEqual(pstate.in_array[i].in_var_ele.label,var_label) && pstate.in_array[i].create_in_fl )
           return true;
 
+      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+        if( textIsEqual(var->label,var_label) )
+          return true;
+      
       return false;
     }
 
@@ -1545,7 +1656,12 @@ namespace cw
       return n;
     }
 
-    rc_t _create_instance( flow_t* p, const object_t* proc_inst_cfg, unsigned sfx_id, network_t& net, instance_t*& inst_ref )
+    rc_t _create_instance( flow_t*         p,
+                           const object_t* proc_inst_cfg,
+                           unsigned        sfx_id,
+                           network_t&      net,
+                           variable_t*     proxyVarL,
+                           instance_t*&    inst_ref )
     {
       rc_t                    rc         = kOkRC;
       proc_inst_parse_state_t pstate     = {};
@@ -1558,7 +1674,7 @@ namespace cw
       if((rc = _parse_proc_inst_cfg( net, proc_inst_cfg, sfx_id, pstate )) != kOkRC )
         goto errLabel;
       
-      // locate the class desc
+      // locate the proc class desc
       if(( class_desc = class_desc_find(p,pstate.inst_clas_label)) == nullptr )
       {
         rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pstate.inst_clas_label));
@@ -1586,15 +1702,22 @@ namespace cw
       inst->net           = &net;
 
       // parse the in-list ,fill in pstate.in_array, and create var instances for var's referenced by in-list
-      if((rc = _parse_in_list( net, inst, pstate )) != kOkRC )
+      if((rc = _parse_in_list( net, inst, proxyVarL, pstate )) != kOkRC )
       {
         rc = cwLogError(rc,"in-list parse failed on proc instance '%s:%i'.",cwStringNullGuard(inst->label),sfx_id);
         goto errLabel;
       }
 
+      // create the vars that are connected to the wrapper proxy vars
+      if((rc = _create_proxied_vars( inst, proxyVarL )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Proxy vars create failed on proc instance '%s:%i'.",cwStringNullGuard(inst->label),sfx_id);
+        goto errLabel;
+      }
+
       // Instantiate all the variables in the class description - that were not already created in _parse_in_list()
       for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
-        if( !_is_var_inst_already_created( vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
+        if( !_is_var_inst_already_created( inst, vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
         {
           variable_t* var = nullptr;        
           if((rc = var_create( inst, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, kInvalidTFl, var )) != kOkRC )
@@ -1632,6 +1755,14 @@ namespace cw
         goto errLabel;
       }
 
+      // Connect the wrapped vars in this subnet proc
+      if((rc = _connect_wrapped_vars( inst, proxyVarL )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Wrapped connection processing failed.");
+        goto errLabel;
+      }
+
+      
       // Complete the instantiation of the proc instance by calling the custom instance creation function.
 
       // Call the custom instance create() function.
@@ -1924,10 +2055,11 @@ namespace cw
   }
 }
 
-cw::rc_t cw::flow::network_create( flow_t* p,
-                                   const object_t* networkCfg,
-                                   network_t& net,
-                                   unsigned polyCnt,
+cw::rc_t cw::flow::network_create( flow_t*            p,
+                                   const object_t*    networkCfg,
+                                   network_t&         net,
+                                   variable_t*        proxyVarL,
+                                   unsigned           polyCnt,
                                    network_order_id_t orderId )
 {
   rc_t     rc     = kOkRC;
@@ -1956,8 +2088,8 @@ cw::rc_t cw::flow::network_create( flow_t* p,
   }
 
   net.proc_arrayAllocN = polyCnt * net.procsCfg->child_count();
-  net.proc_array  = mem::allocZ<instance_t*>(net.proc_arrayAllocN);
-  net.proc_arrayN = 0;
+  net.proc_array       = mem::allocZ<instance_t*>(net.proc_arrayAllocN);
+  net.proc_arrayN      = 0;
 
   for(unsigned i=0; i<outerN; ++i)
   {
@@ -1973,7 +2105,7 @@ cw::rc_t cw::flow::network_create( flow_t* p,
         assert(net.proc_arrayN < net.proc_arrayAllocN );
         
         // create the proc instance
-        if( (rc= _create_instance( p, proc_cfg, sfx_id, net, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
+        if( (rc= _create_instance( p, proc_cfg, sfx_id, net, proxyVarL, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
         {
           //rc = cwLogError(rc,"The instantiation at proc index %i is invalid.",net.proc_arrayN);
           goto errLabel;
diff --git a/cwFlowNet.h b/cwFlowNet.h
index 2901e9a..b9e5016 100644
--- a/cwFlowNet.h
+++ b/cwFlowNet.h
@@ -12,9 +12,10 @@ namespace cw
     
     rc_t network_create( flow_t* p,
                          const object_t*    networkCfg,
-                         network_t&         net,                            // Network object to be filled with new proc instances
-                         unsigned           polyCnt = 1,                    // Count of networks to create
-                         network_order_id_t orderId = kNetFirstPolyOrderId  // Set the network exec order.
+                         network_t&         net,                              // Network object to be filled with new proc instances
+                         variable_t*        proxyVarL,                        // 
+                         unsigned           polyCnt   = 1,                    // Count of networks to create
+                         network_order_id_t orderId   = kNetFirstPolyOrderId  // Set the network exec order.
       );
     
     rc_t network_destroy( network_t& net );
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index f00d2bc..2e9cb82 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -120,6 +120,80 @@ namespace cw
       
     }    
 
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // subnet
+    //
+    namespace subnet
+    {
+      typedef struct
+      {
+        network_t net;
+      } inst_t;
+
+
+      rc_t _create( instance_t* proc, inst_t* p )
+      {
+        rc_t            rc         = kOkRC;        
+        const object_t* networkCfg = nullptr;
+        
+        if((rc = proc->class_desc->cfg->getv("network",networkCfg)) != kOkRC )
+        {
+          rc = cwLogError(rc,"The subnet 'network' cfg. was not found.");
+          goto errLabel;
+        }
+
+        if((rc = network_create(proc->ctx,networkCfg,p->net,proc->varL)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Creation failed on the subnet internal network.");
+          goto errLabel;
+        }
+
+        // Set the internal net pointer in the base proc instance
+        // so that network based utilities can scan it
+        proc->internal_net = &p->net;
+
+      errLabel:
+        return rc;
+      }
+
+      rc_t _destroy( instance_t* proc, inst_t* p )
+      {
+        rc_t rc = kOkRC;
+
+        network_destroy(p->net);
+
+        return rc;
+      }
+
+      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
+      {
+        rc_t rc = kOkRC;
+        return rc;
+      }
+
+      rc_t _exec( instance_t* proc, inst_t* p )
+      {
+        rc_t rc      = kOkRC;
+
+        if((rc = exec_cycle(p->net)) != kOkRC )
+          rc = cwLogError(rc,"poly internal network exec failed.");
+        
+        return rc;
+      }
+
+      rc_t _report( instance_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      class_members_t members = {
+        .create  = std_create<inst_t>,
+        .destroy = std_destroy<inst_t>,
+        .value   = std_value<inst_t>,
+        .exec    = std_exec<inst_t>,
+        .report  = std_report<inst_t>
+      };
+      
+    }    
     
     //------------------------------------------------------------------------------------------------------------------
     //
@@ -147,6 +221,7 @@ namespace cw
         inst_t*         inst        = mem::allocZ<inst_t>();
         const object_t* networkCfg  = nullptr;
         const char*     order_label = nullptr;
+        variable_t*     proxyVarL   = nullptr;
         
         proc->userPtr = inst;
         
@@ -181,7 +256,7 @@ namespace cw
           }
         }
         
-        if((rc = network_create(proc->ctx,networkCfg,inst->net,inst->count )) != kOkRC )
+        if((rc = network_create(proc->ctx,networkCfg,inst->net,proxyVarL,inst->count)) != kOkRC )
         {
           rc = cwLogError(rc,"Creation failed on the internal network.");
           goto errLabel;
@@ -1003,7 +1078,9 @@ namespace cw
           inst->durSmpN += src_abuf->frameN;          
           if( src_abuf->srate!=0 && inst->durSmpN % ((unsigned)src_abuf->srate*60) == 0 )
             printf("audio file out: %5.1f min\n", inst->durSmpN/(src_abuf->srate*60));
-          
+
+          //if( 48000 <= inst->durSmpN  && inst->durSmpN < 49000 )
+          //  printf("break\n");
         }
         
         return rc;
@@ -1785,6 +1862,8 @@ namespace cw
             if((rc = var_set(ctx,kSratePId,i,srate)) != kOkRC )
               goto errLabel;
         }
+
+        printf("%s: sr:%f hz:%f phs:%f dc:%f gain:%f\n",ctx->label,srate,hz,phase,dc,gain);
         
         // create one output audio buffer
         rc = var_register_and_set( ctx, "out", kBaseSfxId,
@@ -1840,7 +1919,10 @@ namespace cw
             for(unsigned j=0; j<abuf->frameN; ++j)
               v[j] = (sample_t)((gain * sin( inst->phaseA[i] + phase + (2.0 * M_PI * j * hz/srate)))+dc);
 
-            inst->phaseA[i] += 2.0 * M_PI * abuf->frameN * hz/srate;            
+            inst->phaseA[i] += 2.0 * M_PI * abuf->frameN * hz/srate;
+
+            //if( i==0 )
+            //  printf("hz:%f gain:%f phs:%f : %f\n",hz,gain,inst->phaseA[i],v[0]);
           }
         }
         
diff --git a/cwFlowProc.h b/cwFlowProc.h
index 64921e3..daaff15 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -2,6 +2,7 @@ namespace cw
 {
   namespace flow
   {
+    namespace subnet          { extern class_members_t members;  }
     namespace poly            { extern class_members_t members;  }
     namespace midi_in         { extern class_members_t members;  }
     namespace midi_out        { extern class_members_t members;  }
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 63f9fbb..a03b1f7 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -1093,6 +1093,21 @@ namespace cw
       return rc;
     }
 
+    void _class_desc_print( const class_desc_t* cd )
+    {
+      const var_desc_t*   vd = cd->varDescL;
+      printf("%s\n",cwStringNullGuard(cd->label));
+        
+      for(; vd!=nullptr; vd=vd->link)
+      {
+        const char* srcFlStr    = vd->flags & kSrcVarFl    ? "src"      : "   ";
+        const char* srcOptFlStr = vd->flags & kSrcOptVarFl ? "srcOpt"   : "      ";
+        const char* plyMltFlStr = vd->flags & kMultVarFl   ? "mult"     : "    ";
+          
+        printf("  %10s 0x%08x %s %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, plyMltFlStr, cwStringNullGuard(vd->docText) );
+      }  
+    }
+    
   }
 }
 
@@ -1280,15 +1295,19 @@ const char* cw::flow::value_type_flag_to_label( unsigned flag )
 cw::flow::class_desc_t* cw::flow::class_desc_find( flow_t* p, const char* label )
 {
   for(unsigned i=0; i<p->classDescN; ++i)
-    if( textCompare(p->classDescA[i].label,label) == 0 )
+    if( textIsEqual(p->classDescA[i].label,label))
       return p->classDescA + i;
+
+  for(unsigned i=0; i<p->subnetDescN; ++i)
+    if( textIsEqual(p->subnetDescA[i].label,label))
+      return p->subnetDescA + i;
+  
   return nullptr;
 }
 
-
-cw::flow::var_desc_t* cw::flow::var_desc_find( class_desc_t* cd, const char* label )
+const cw::flow::var_desc_t* cw::flow::var_desc_find( const class_desc_t* cd, const char* label )
 {
-  var_desc_t* vd = cd->varDescL;
+  const var_desc_t* vd = cd->varDescL;
       
   for(; vd != nullptr; vd=vd->link )
     if( textCompare(vd->label,label) == 0 )
@@ -1296,6 +1315,11 @@ cw::flow::var_desc_t* cw::flow::var_desc_find( class_desc_t* cd, const char* lab
   return nullptr;
 }
 
+cw::flow::var_desc_t* cw::flow::var_desc_find( class_desc_t* cd, const char* label )
+{
+  return (var_desc_t*)var_desc_find( (const class_desc_t*)cd, label);
+}
+
 cw::rc_t cw::flow::var_desc_find( class_desc_t* cd, const char* label, var_desc_t*& vdRef )
 {
   if((vdRef = var_desc_find(cd,label)) == nullptr )
@@ -1303,7 +1327,7 @@ cw::rc_t cw::flow::var_desc_find( class_desc_t* cd, const char* label, var_desc_
   return kOkRC;
 }
 
-const cw::flow::preset_t* cw::flow::class_preset_find( class_desc_t* cd, const char* preset_label )
+const cw::flow::preset_t* cw::flow::class_preset_find( const class_desc_t* cd, const char* preset_label )
 {
   const preset_t* pr;
   for(pr=cd->presetL; pr!=nullptr; pr=pr->link)
@@ -1316,20 +1340,10 @@ const cw::flow::preset_t* cw::flow::class_preset_find( class_desc_t* cd, const c
 void cw::flow::class_dict_print( flow_t* p )
 {
   for(unsigned i=0; i<p->classDescN; ++i)
-  {
-    class_desc_t* cd = p->classDescA + i;
-    var_desc_t*   vd = cd->varDescL;
-    printf("%s\n",cwStringNullGuard(cd->label));
-        
-    for(; vd!=nullptr; vd=vd->link)
-    {
-      const char* srcFlStr    = vd->flags & kSrcVarFl    ? "src"      : "   ";
-      const char* srcOptFlStr = vd->flags & kSrcOptVarFl ? "srcOpt"   : "      ";
-      const char* plyMltFlStr = vd->flags & kMultVarFl   ? "mult"     : "    ";
-          
-      printf("  %10s 0x%08x %s %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, plyMltFlStr, cwStringNullGuard(vd->docText) );
-    }
-  }
+    _class_desc_print(p->classDescA+i);
+  
+  for(unsigned i=0; i<p->subnetDescN; ++i)
+    _class_desc_print(p->subnetDescA+i);
 }
 
 
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index d207e0d..4fd0af6 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -25,7 +25,6 @@ namespace cw
         
     typedef struct abuf_str
     {
-      struct value_str*  base;
       srate_t            srate;   // signal sample rate
       unsigned           chN;     // count of channels
       unsigned           frameN;  // count of sample frames per channel
@@ -35,7 +34,6 @@ namespace cw
 
     typedef struct fbuf_str
     {      
-      struct value_str* base;
       srate_t           srate;     // signal sample rate
       unsigned          flags;     // See kXXXFbufFl
       unsigned          chN;       // count of channels
@@ -51,7 +49,6 @@ namespace cw
 
     typedef struct mbuf_str
     {
-      struct value_str*     base;
       const midi::ch_msg_t* msgA;
       unsigned              msgN;
     } mbuf_t;
@@ -136,7 +133,8 @@ namespace cw
       kNoVarFl     = 0x00,
       kSrcVarFl    = 0x01,
       kSrcOptVarFl = 0x02,
-      kMultVarFl   = 0x04
+      kMultVarFl   = 0x04,
+      kSubnetOutVarFl = 0x08
     };
     
     typedef struct class_members_str
@@ -156,6 +154,10 @@ namespace cw
       unsigned             type;    // Value type id (e.g. kBoolTFl, kIntTFl, ...)
       unsigned             flags;   // Attributes for this var. (e.g. kSrcVarFl )
       const char*          docText; // User help string for this var.
+      
+      char*                proxyProcLabel;
+      char*                proxyVarLabel;
+      
       struct var_desc_str* link;    // class_desc->varDescL list link
     } var_desc_t;
 
@@ -168,17 +170,19 @@ namespace cw
     
     typedef struct class_desc_str
     {
-      const object_t*   cfg;       // 
+      const object_t*   cfg;       // class cfg 
       const char*       label;     // class label;      
-      var_desc_t*       varDescL;  // varDescA[varDescN] value description list
+      var_desc_t*       varDescL;  // varDescL variable description linked on var_desc_t.link
       preset_t*         presetL;   // presetA[ presetN ]
       class_members_t*  members;   // member functions for this class
       unsigned          polyLimitN; // max. poly copies of this class per network_t or 0 if no limit
     } class_desc_t;
 
     enum {
-      kInvalidVarFl = 0x00,
-      kLogVarFl     = 0x01
+      kInvalidVarFl    = 0x00,
+      kLogVarFl        = 0x01,
+      kProxiedVarFl    = 0x02,
+      kProxiedOutVarFl = 0x04
     };
 
     // Note: The concatenation of 'vid' and 'chIdx' should form a unique identifier among all variables
@@ -274,6 +278,10 @@ namespace cw
       class_desc_t*        classDescA;     // 
       unsigned             classDescN;     //
 
+      class_desc_t*        subnetDescA;     // 
+      unsigned             subnetDescN;     //
+      
+
       external_device_t*   deviceA;        // deviceA[ deviceN ] external device description array
       unsigned             deviceN;        //
       
@@ -321,14 +329,15 @@ namespace cw
     // Class and Variable Description
     //
 
-    class_desc_t*  class_desc_find(  flow_t* p, const char* class_desc_label );
+    class_desc_t*     class_desc_find(  flow_t* p, const char* class_desc_label );
     
-    var_desc_t*    var_desc_find( class_desc_t* cd, const char* var_label );
-    rc_t           var_desc_find( class_desc_t* cd, const char* label, var_desc_t*& vdRef );
+    var_desc_t*       var_desc_find(       class_desc_t* cd, const char* var_label );
+    const var_desc_t* var_desc_find( const class_desc_t* cd, const char* var_label );
+    rc_t              var_desc_find(       class_desc_t* cd, const char* var_label, var_desc_t*& vdRef );
 
-    const preset_t* class_preset_find( class_desc_t* cd, const char* preset_label );
+    const preset_t*   class_preset_find( const class_desc_t* cd, const char* preset_label );
     
-    void           class_dict_print( flow_t* p );
+    void              class_dict_print( flow_t* p );
 
     
     //------------------------------------------------------------------------------------------------------------------------
diff --git a/cwIoFlow.cpp b/cwIoFlow.cpp
index 2ac38b1..57402ec 100644
--- a/cwIoFlow.cpp
+++ b/cwIoFlow.cpp
@@ -114,7 +114,6 @@ namespace cw
     {
       dev->ioDevIdx    = ioDevIdx;
       dev->ioDevId     = audioDeviceUserId( p->ioH, ioDevIdx );
-      dev->abuf.base   = nullptr;
       dev->abuf.srate  = audioDeviceSampleRate(   p->ioH, ioDevIdx );
       dev->abuf.chN    = audioDeviceChannelCount( p->ioH, ioDevIdx, inOrOutFl );
       dev->abuf.frameN = dspFrameCnt;

From 94dac23cdf78f298cc4d330a1a7e43fe8c077bb4 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sun, 5 May 2024 17:32:02 -0400
Subject: [PATCH 051/101] README.md : Updates

---
 README.md | 63 ++++++++++++++++++++++---------------------------------
 1 file changed, 25 insertions(+), 38 deletions(-)

diff --git a/README.md b/README.md
index 3fb4ccd..520c3bb 100644
--- a/README.md
+++ b/README.md
@@ -907,13 +907,34 @@ Add proc instance field: `log:{ var_label_0:0, var_label_1:0 } `
 - log: should print the values for all channels - right now it is only
 printing the values for kAnyChIdx
 
-
 Next:
 
-There is no way for a proc in a poly context to use it's poly channel number to 
-select a mult variable.
+- subnet vars should be the same as non-subnet vars but include the 'proxy' field.
+  In particular they should get default values.
+  
+- subnets should have presets written in terms of the subnet vars rather than the network vars
+
+- improve the subnet creating code by using consistent naming - use proxy or wrap but not both
+
+- improve code comments on subnet creation
+
+- write a paragraph in the flow_doc.md about overall approach taken to subnet implementation
+
+
+
+BUGS:
+- The counter modulo mode is not working as expected.
+
+- There is no way for a proc in a poly context to use it's poly channel number to 
+select a mult variable.  For example in an osc in a poly has no way to select
+the frequency of the osc by conneting to a non-poly proc - like a list.
+Consider: 
+1. Use a difference 'in' statememt (e.g. 'poly-in' but the 
+   same syntax used for connecting 'mult' variables.)
+2. Include the proc name in the 'in' var to indicate a poly index is being iterated
+   e.g. `lfo: { class:sine_tone, in:{ osc_.dc:list.value_ } }` 
+
 
-The counter modulo mode is not working as expected.
 
 
 
@@ -925,38 +946,4 @@ The counter modulo mode is not working as expected.
 
 ```
 	
-mod_osc: {
-
-	vars:
-	{
-      hz:            { type:hz_lfo.dc,     doc:"Audio frequency" },
-	  hz_mod_hz:     { type:hz_lfo.hz,     doc:"Frequency modulator hz" },
-	  hz_mod_depth:  { type:hz_lfo.gain,   doc:Frequency modulator depth" },
-	  amp_mod_hz:    { type:amp_lfo.hz,    doc:Amplitude modulator hz" },
-	  amp_mod_depth: { type:amp_lfo.gain,  doc:Amplutide modulator depth."},
-	  out:           { type:gain.out       doc:"Oscillator output."},
-	}
-	
-	presets: {
-	  
-	}
-
-	network: {
-	  procs: {
-		  hz_lfo:   { class: sine_tone,   in:{ dc:hz, gain:hz_mod_depth, hz:hz_mod_hz }, args: { default:{ chCnt:1, hz:3, dc:440, gain:110 }}}
-	      hz_sh:    { class: sample_hold, in:{ in:hz_lfo.out }}
-
-		  amp_lfo:   { class: sine_tone,   in:{ gain:amp_mod_depth, hz:amp_mod_hz }, args: { default:{ chCnt:1, hz:3, gain:110 }}}
-	      amp_sh:    { class: sample_hold, in:{ in:amp_lfo.out }}
-
-	      osc:   { class: sine_tone,   in:{ hz: hz_sh.out }}	
-		  gain:  { class: audio_gain,  in:{ in:osc.out, gain:amp_sh.out}}
-	  }
-	  
-	  presets: {
-	  }
-	
-	}
-
-}
 ```

From 2395feb4a7d700e7fa38f94c93e63cd1b8a0aef1 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:41:18 -0400
Subject: [PATCH 052/101] cwCommonImpl.h/cpp  idToLabel() now returns label
 associated with 'eolId' instead of nullptr when the requested id is not
 found. Added idToLabelNull() which return nullptr when the requested id is
 not found.

---
 cwCommonImpl.cpp | 32 ++++++++++++++++++++++----------
 cwCommonImpl.h   |  3 +++
 2 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/cwCommonImpl.cpp b/cwCommonImpl.cpp
index b7aed68..4db910d 100644
--- a/cwCommonImpl.cpp
+++ b/cwCommonImpl.cpp
@@ -13,16 +13,32 @@ namespace cw
     nanosleep(ts,NULL);
   }
 
+  const idLabelPair_t* _idToSlot( const idLabelPair_t* array, unsigned id, unsigned eolId )
+  {
+    const idLabelPair_t* p = array;
+    for(; p->id != eolId; ++p)
+      if( p->id == id )
+        break;
+    
+    return p;    
+  }
+  
+}
+
+
+
+const char* cw::idToLabelNull( const idLabelPair_t* array, unsigned id, unsigned eolId )
+{
+  const idLabelPair_t* p = _idToSlot(array,id,eolId);
+
+  return p->id == eolId ? nullptr : p->label;
 }
 
 const char* cw::idToLabel( const idLabelPair_t* array, unsigned id, unsigned eolId )
 {
-  const idLabelPair_t* p = array;
-  for(; p->id != eolId; ++p)
-    if( p->id == id )
-      return p->label;
+  const idLabelPair_t* p = _idToSlot(array,id,eolId);
 
-  return nullptr;
+  return p->label;
 }
 
 unsigned cw::labelToId( const idLabelPair_t* array, const char* label, unsigned eolId )
@@ -31,16 +47,12 @@ unsigned cw::labelToId( const idLabelPair_t* array, const char* label, unsigned
 
   if( label != nullptr )
     for(; p->id != eolId; ++p)
-      if( std::strcmp(label,p->label) == 0 )
+      if( p->label != nullptr && std::strcmp(label,p->label) == 0 )
         return p->id;
 
   return eolId;
 }
 
-
-
-
-
 void cw::sleepSec( unsigned secs )
 {
   struct timespec ts;
diff --git a/cwCommonImpl.h b/cwCommonImpl.h
index 703f2f0..9d0d4db 100644
--- a/cwCommonImpl.h
+++ b/cwCommonImpl.h
@@ -160,6 +160,9 @@ namespace cw
   } idLabelPair_t;
 
   // Return nullptr if id is not found.
+  const char* idToLabelNull( const idLabelPair_t* array, unsigned id, unsigned eolId );
+
+  // Returns label in 'eolId' slot if id is not found.
   const char* idToLabel( const idLabelPair_t* array, unsigned id, unsigned eolId );
   
   // Returns eolId if the id is not found.

From 6ba4d04b58b577b9d831024ff2bdb90079125bc8 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:41:54 -0400
Subject: [PATCH 053/101] cwLog.cpp : levelToLabel() is not implemented in
 terms of cw::idToLabel().

---
 cwLog.cpp | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/cwLog.cpp b/cwLog.cpp
index bf494c0..3eb8297 100644
--- a/cwLog.cpp
+++ b/cwLog.cpp
@@ -164,13 +164,7 @@ void cw::log::setFormatCb( handle_t h, logFormatCbFunc_t fmtFunc, void* fmtCbArg
 
 
 const char* cw::log::levelToLabel( unsigned level )
-{
-  const char* label;
-  if((label = idToLabel(logLevelLabelArray,level,kInvalid_LogLevel)) == nullptr)
-    label = "<unknown>";
-  
-  return label;
-}
+{  return idToLabel(logLevelLabelArray,level,kInvalid_LogLevel); }
 
 
 

From 9c77a5e92443d50ac3132a74c57863b37489a2e1 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:42:33 -0400
Subject: [PATCH 054/101] cwSfScoreParser.cpp : opcode_id_to_label() now uses
 idToLabelNull().

---
 cwSfScoreParser.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwSfScoreParser.cpp b/cwSfScoreParser.cpp
index cd11484..5b9f293 100644
--- a/cwSfScoreParser.cpp
+++ b/cwSfScoreParser.cpp
@@ -830,7 +830,7 @@ unsigned    cw::sfscore::opcode_label_to_id( const char* label )
 const char* cw::sfscore::opcode_id_to_label( unsigned opcode_id )
 {
   const char* label;
-  if((label = idToLabel( _opcodeMapA, opcode_id, kInvalidEvtScId)) == nullptr )
+  if((label = idToLabelNull( _opcodeMapA, opcode_id, kInvalidEvtScId)) == nullptr )
     cwLogError(kInvalidArgRC,"The event opcode type id '%i' is not valid.",opcode_id);
   
   return label;

From eca42baf9fc0353e2584e36efb8eecef800ae814 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:44:53 -0400
Subject: [PATCH 055/101] cwFlowTypes.h/cpp : implemented
 var_desc_create/destroy(), var_desc_attr_label_to_flag(),
 var_desc_flag_to_attribute(), class_desc_array(). Renamed instance_t to
 proc_t.

---
 cwFlowTypes.cpp | 479 +++++++++++++++++++++++++++++-------------------
 cwFlowTypes.h   | 137 +++++++-------
 2 files changed, 369 insertions(+), 247 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index a03b1f7..2d9e1e4 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -19,7 +19,20 @@ namespace cw
 {
   namespace flow
   {
-    idLabelPair_t typeLabelFlagsA[] = {
+
+    idLabelPair_t _varDescAttrFlagsA[] =
+    {
+      { kSrcVarDescFl,       "src" },
+      { kSrcOptVarDescFl,    "src_opt" },
+      { kNoSrcVarDescFl,     "no_src" },
+      { kInitVarDescFl,      "init" },
+      { kMultVarDescFl,      "mult" },
+      { kSubnetOutVarDescFl, "out" },
+      { kInvalidVarDescFl, "<invalid>" }
+    };
+
+    
+    idLabelPair_t _typeLabelFlagsA[] = {
       
       { kBoolTFl,  "bool" },
       { kUIntTFl,  "uint" },
@@ -51,16 +64,12 @@ namespace cw
 
       { kRuntimeTFl, "runtime" },
 
-      { kInvalidTFl, nullptr }
+      { kInvalidTFl, "<invalid>" }
     };
 
     const char* _typeFlagToLabel( unsigned flag )
     {
-      for(unsigned i=0; typeLabelFlagsA[i].id != kInvalidTFl; ++i)
-        if( typeLabelFlagsA[i].id == flag )
-          return typeLabelFlagsA[i].label;
-
-      return "<unknown-type>";
+      return idToLabel(_typeLabelFlagsA,flag,kInvalidTFl);
     }
 
       
@@ -658,7 +667,7 @@ namespace cw
         return cwLogError(kInvalidArgRC,"Cannnot get the value of a non-existent variable.");
       
       if( var->value == nullptr )
-        return cwLogError(kInvalidStateRC,"No value has been assigned to the variable: %s:%i.%s:%i ch:%i.",cwStringNullGuard(var->inst->label),var->inst->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id,var->chIdx);
+        return cwLogError(kInvalidStateRC,"No value has been assigned to the variable: %s:%i.%s:%i ch:%i.",cwStringNullGuard(var->proc->label),var->proc->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id,var->chIdx);
 
       return _val_get(var->value,valRef);
     
@@ -666,11 +675,11 @@ namespace cw
     
 
     // Variable lookup: Exact match on vid and chIdx
-    rc_t _var_find_on_vid_and_ch( instance_t* inst, unsigned vid, unsigned chIdx, variable_t*& varRef )
+    rc_t _var_find_on_vid_and_ch( proc_t* proc, unsigned vid, unsigned chIdx, variable_t*& varRef )
     {
       varRef = nullptr;
       
-      for(variable_t* var = inst->varL; var!=nullptr; var=var->var_link)
+      for(variable_t* var = proc->varL; var!=nullptr; var=var->var_link)
       {
         // the variable vid and chIdx should form a unique pair
         if( var->vid==vid && var->chIdx == chIdx )
@@ -679,13 +688,13 @@ namespace cw
           return kOkRC;
         }
       }
-      return cwLogError(kInvalidIdRC,"The variable matching id:%i ch:%i on instance '%s:%i' could not be found.", vid, chIdx, inst->label, inst->label_sfx_id);
+      return cwLogError(kInvalidIdRC,"The variable matching id:%i ch:%i on procance '%s:%i' could not be found.", vid, chIdx, proc->label, proc->label_sfx_id);
     }
 
     // Variable lookup: Exact match on label and chIdx
-    variable_t* _var_find_on_label_and_ch( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx )
+    variable_t* _var_find_on_label_and_ch( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx )
     {
-      for(variable_t* var = inst->varL; var!=nullptr; var=var->var_link)
+      for(variable_t* var = proc->varL; var!=nullptr; var=var->var_link)
       {
         // the variable vid and chIdx should form a unique pair
         if( var->label_sfx_id==sfx_id && textCompare(var->label,var_label)==0 && var->chIdx == chIdx )
@@ -695,28 +704,28 @@ namespace cw
       return nullptr;
     }
     
-    rc_t _var_find_on_label_and_ch( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, variable_t*& var_ref )
+    rc_t _var_find_on_label_and_ch( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx, variable_t*& var_ref )
     {
       rc_t rc = kOkRC;
-      if((var_ref = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx)) == nullptr )
-        rc = cwLogError(kEleNotFoundRC,"The variable '%s:%i' cannot be found on the proc:%s.",cwStringNullGuard(var_label),sfx_id,cwStringNullGuard(inst->label));
+      if((var_ref = _var_find_on_label_and_ch(proc,var_label,sfx_id,chIdx)) == nullptr )
+        rc = cwLogError(kEleNotFoundRC,"The variable '%s:%i' cannot be found on the proc:%s.",cwStringNullGuard(var_label),sfx_id,cwStringNullGuard(proc->label));
       return rc;
     }
     
     rc_t _validate_var_assignment( variable_t* var, unsigned typeFl )
     {
-      if( cwIsFlag(var->varDesc->flags, kSrcVarFl ) )
-        return cwLogError(kInvalidStateRC, "The variable '%s:%i' on instance '%s:%i' cannot be set because it is a 'src' variable.", var->label, var->label_sfx_id, var->inst->label,var->inst->label_sfx_id);
+      if( cwIsFlag(var->varDesc->flags, kSrcVarDescFl ) )
+        return cwLogError(kInvalidStateRC, "The variable '%s:%i' on procance '%s:%i' cannot be set because it is a 'src' variable.", var->label, var->label_sfx_id, var->proc->label,var->proc->label_sfx_id);
       /*
       if( !cwIsFlag(var->varDesc->type, typeFl ) )
-        return cwLogError(kTypeMismatchRC, "The variable '%s:%i' on instance '%s:%i' is not a  '%s'.", var->label, var->label_sfx_id, var->inst->label, var->inst->label_sfx_id, _typeFlagToLabel( typeFl ));
+        return cwLogError(kTypeMismatchRC, "The variable '%s:%i' on procance '%s:%i' is not a  '%s'.", var->label, var->label_sfx_id, var->proc->label, var->proc->label_sfx_id, _typeFlagToLabel( typeFl ));
       */
       
       return kOkRC;
     }
 
     void _var_print_addr( const char* title, const variable_t* v )
-    { printf("%s:%s:%i.%s:%i ",title,v->inst->label,v->inst->label_sfx_id,v->label,v->label_sfx_id); }
+    { printf("%s:%s:%i.%s:%i ",title,v->proc->label,v->proc->label_sfx_id,v->label,v->label_sfx_id); }
 
     void _var_print( const variable_t* var )
     {
@@ -730,12 +739,12 @@ namespace cw
         _value_print( var->value );
 
       if( var->src_var != nullptr )
-        printf(" src:%s:%i.%s:%i",var->src_var->inst->label,var->src_var->inst->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
+        printf(" src:%s:%i.%s:%i",var->src_var->proc->label,var->src_var->proc->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
 
       if( var->dst_head != nullptr )
       {
         for(variable_t* v = var->dst_head; v!=nullptr; v=v->dst_link)
-          printf(" dst:%s:%i.%s:%i",v->inst->label,v->inst->label_sfx_id,v->label,v->label_sfx_id);
+          printf(" dst:%s:%i.%s:%i",v->proc->label,v->proc->label_sfx_id,v->label,v->label_sfx_id);
       }
 
       printf("\n");    
@@ -754,9 +763,9 @@ namespace cw
         con_var->value = var->value;
         
         cwLogMod("%s:%i %s:%i -> %s:%i %s:%i",
-                 var->inst->label,var->inst->label_sfx_id,
+                 var->proc->label,var->proc->label_sfx_id,
                  var->label,var->label_sfx_id,
-                 con_var->inst->label,con_var->inst->label_sfx_id,
+                 con_var->proc->label,con_var->proc->label_sfx_id,
                  con_var->label,con_var->label_sfx_id );
 
         // Call the value() function on the connected variable
@@ -777,7 +786,7 @@ namespace cw
       
       // it is not legal to set the value of a variable that is connected to a 'source' variable.
       if( var->src_var != nullptr )
-        return cwLogError(kInvalidStateRC, "The variable '%s:%i %s:%i' cannot be set because it is connected to a source variable.", var->inst->label,var->inst->label_sfx_id, var->label, var->label_sfx_id);      
+        return cwLogError(kInvalidStateRC, "The variable '%s:%i %s:%i' cannot be set because it is connected to a source variable.", var->proc->label,var->proc->label_sfx_id, var->label, var->label_sfx_id);      
 
       
       // var->type is the allowable type for this var's value.
@@ -812,7 +821,7 @@ namespace cw
         if( value_type_flag == 0  )
         {
           rc = cwLogError(kTypeMismatchRC,"The type 0x%x is not valid for the variable: %s:%i %s:%i type:0x%x.",
-                          argTypeFlag,var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,var->varDesc->type);
+                          argTypeFlag,var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id,var->varDesc->type);
           goto errLabel;
         }
       }
@@ -823,7 +832,7 @@ namespace cw
       // set the new local value in var->local_value[next_local_value_idx]
       if((rc = _val_set(var->local_value + next_local_value_idx, val )) != kOkRC )
       {
-        rc = cwLogError(rc,"Value set failed on '%s:%i %s:%i",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id);
+        rc = cwLogError(rc,"Value set failed on '%s:%i %s:%i",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id);
         goto errLabel;
       }
 
@@ -831,18 +840,18 @@ namespace cw
       var->value           = var->local_value + next_local_value_idx;
       var->local_value_idx = next_local_value_idx;
       
-      // If the instance is fully initialized ...
-      if( var->inst->varMapA != nullptr )
+      // If the procance is fully initialized ...
+      if( var->proc->varMapA != nullptr )
       {
         // ... then inform the proc. that the value changed
         // Note 1: We don't want to this call to occur if we are inside or prior to 'proc.create()' 
-        // call because calls' to 'proc.value()' will see the instance in a incomplete state)
+        // call because calls' to 'proc.value()' will see the procance in a incomplete state)
         // Note 2: If this call returns an error then the value assignment is cancelled
         // and the value does not change.
         rc = var_call_custom_value_func( var );
       }
 
-      //printf("%p set: %s:%s  0x%x\n",var->value, var->inst->label,var->label,var->value->tflag);
+      //printf("%p set: %s:%s  0x%x\n",var->value, var->proc->label,var->label,var->value->tflag);
 
       if( rc == kOkRC )
       {
@@ -888,17 +897,17 @@ namespace cw
       }
 
       if(rc != kOkRC )
-        rc = cwLogError(rc,"Variable value set failed on '%s:%i %s:%i",cwStringNullGuard(var->inst->label),var->inst->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id);
+        rc = cwLogError(rc,"Variable value set failed on '%s:%i %s:%i",cwStringNullGuard(var->proc->label),var->proc->label_sfx_id,cwStringNullGuard(var->label),var->label_sfx_id);
       
       return rc;
     }
 
     
-    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, abuf_t* abuf )
+    rc_t  _var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, abuf_t* abuf )
     {
       rc_t rc;
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
+      if((rc = var_register_and_set( proc, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
         return rc;
 
       if( var != nullptr )
@@ -907,11 +916,11 @@ namespace cw
       return rc;
     }
 
-    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, mbuf_t* mbuf )
+    rc_t  _var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, mbuf_t* mbuf )
     {
       rc_t rc;
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
+      if((rc = var_register_and_set( proc, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
         return rc;
 
       if( var != nullptr )
@@ -920,11 +929,11 @@ namespace cw
       return rc;
     }
     
-    rc_t  _var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, fbuf_t* fbuf )
+    rc_t  _var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, fbuf_t* fbuf )
     {
       rc_t rc;
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
+      if((rc = var_register_and_set( proc, var_label, sfx_id, vid, chIdx, var)) != kOkRC )
         return rc;
 
       if( var != nullptr )
@@ -934,32 +943,32 @@ namespace cw
     }
 
 
-    rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef )
+    rc_t  _var_map_id_to_index(  proc_t* proc, unsigned vid, unsigned chIdx, unsigned& idxRef )
     {
-      unsigned idx = vid * inst->varMapChN + (chIdx == kAnyChIdx ? 0 : (chIdx+1));
+      unsigned idx = vid * proc->varMapChN + (chIdx == kAnyChIdx ? 0 : (chIdx+1));
 
       // verify that the map idx is valid
-      if( idx >= inst->varMapN )
-        return cwLogError(kAssertFailRC,"The variable map positioning location %i is out of the range %i on instance '%s:%i' vid:%i ch:%i.", idx, inst->varMapN, inst->label,inst->label_sfx_id,vid,chIdx);
+      if( idx >= proc->varMapN )
+        return cwLogError(kAssertFailRC,"The variable map positioning location %i is out of the range %i on procance '%s:%i' vid:%i ch:%i.", idx, proc->varMapN, proc->label,proc->label_sfx_id,vid,chIdx);
 
       idxRef = idx;
   
       return kOkRC;
     }
 
-    rc_t  _var_map_label_to_index(  instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, unsigned& idxRef )
+    rc_t  _var_map_label_to_index(  proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx, unsigned& idxRef )
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
   
       idxRef = kInvalidIdx;
-      if((rc = var_find(inst, var_label, sfx_id, chIdx, var )) == kOkRC)
-        rc = _var_map_id_to_index( inst, var->vid, chIdx, idxRef );
+      if((rc = var_find(proc, var_label, sfx_id, chIdx, var )) == kOkRC)
+        rc = _var_map_id_to_index( proc, var->vid, chIdx, idxRef );
      
       return rc;
     }
 
-    rc_t _var_add_to_ch_list( instance_t* inst, variable_t* new_var )
+    rc_t _var_add_to_ch_list( proc_t* proc, variable_t* new_var )
     {
       rc_t rc = kOkRC;
       
@@ -970,9 +979,9 @@ namespace cw
       if( new_var->chIdx == kAnyChIdx )
         return kOkRC;
       
-      if((base_var = _var_find_on_label_and_ch( inst, new_var->label, new_var->label_sfx_id, kAnyChIdx )) == nullptr )
+      if((base_var = _var_find_on_label_and_ch( proc, new_var->label, new_var->label_sfx_id, kAnyChIdx )) == nullptr )
       {
-        rc = cwLogError(kInvalidStateRC,"The base channel variable does not exist for '%s:%i.%s:%i'. This is an illegal state.", inst->label, inst->label_sfx_id, new_var->label, new_var->label_sfx_id );
+        rc = cwLogError(kInvalidStateRC,"The base channel variable does not exist for '%s:%i.%s:%i'. This is an illegal state.", proc->label, proc->label_sfx_id, new_var->label, new_var->label_sfx_id );
         goto errLabel;
       }
 
@@ -1023,7 +1032,7 @@ namespace cw
     
     // Create a variable and set it's value from 'value_cfg'.
     // If 'value_cfg' is null then use the value from var->varDesc->val_cfg.
-    rc_t _var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFl, variable_t*& varRef )
+    rc_t _var_create( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFl, variable_t*& varRef )
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
@@ -1032,16 +1041,16 @@ namespace cw
       varRef = nullptr;
 
       // if this var already exists - it can't be created again
-      if((var = _var_find_on_label_and_ch(inst,var_label, sfx_id, chIdx)) != nullptr )
+      if((var = _var_find_on_label_and_ch(proc,var_label, sfx_id, chIdx)) != nullptr )
       {
-        rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' ch:%i has already been created on the instance: '%s:%i'.",var_label,sfx_id,chIdx,inst->label,inst->label_sfx_id);
+        rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' ch:%i has already been created on the procance: '%s:%i'.",var_label,sfx_id,chIdx,proc->label,proc->label_sfx_id);
         goto errLabel;
       }
 
       // locate the var desc
-      if((vd = var_desc_find( inst->class_desc, var_label)) == nullptr )
+      if((vd = var_desc_find( proc->class_desc, var_label)) == nullptr )
       {
-        rc = cwLogError(kInvalidIdRC,"Unable to locate the variable '%s:%i' in class '%s'.", var_label, sfx_id, inst->class_desc->label );
+        rc = cwLogError(kInvalidIdRC,"Unable to locate the variable '%s:%i' in class '%s'.", var_label, sfx_id, proc->class_desc->label );
         goto errLabel;
       }
 
@@ -1050,7 +1059,7 @@ namespace cw
 
       var->varDesc      = vd;
       var->classVarDesc = vd;
-      var->inst         = inst;
+      var->proc         = proc;
       var->label        = mem::duplStr(var_label);
       var->label_sfx_id = sfx_id;
       var->vid          = id;
@@ -1070,24 +1079,24 @@ namespace cw
         if((rc = var_set_from_preset( var, value_cfg )) != kOkRC )
           goto errLabel;
 
-      var->var_link  = inst->varL;
-      inst->varL = var;
+      var->var_link  = proc->varL;
+      proc->varL = var;
 
       // link the new var into the ch_link list
-      if((rc = _var_add_to_ch_list(inst, var )) != kOkRC )
+      if((rc = _var_add_to_ch_list(proc, var )) != kOkRC )
         goto errLabel;
 
 
     errLabel:
       if( rc != kOkRC )
       {
-        _var_destroy(var);
-        cwLogError(kOpFailRC,"Variable creation failed on '%s:%i.%s:%i' ch:%i.", inst->label, inst->label_sfx_id, var_label, sfx_id, chIdx );
+        var_destroy(var);
+        cwLogError(kOpFailRC,"Variable creation failed on '%s:%i.%s:%i' ch:%i.", proc->label, proc->label_sfx_id, var_label, sfx_id, chIdx );
       }
       else
       {
         varRef = var;
-        cwLogMod("Created var: %s:%i.%s:%i ch:%i.", inst->label, inst->label_sfx_id, var_label, sfx_id, chIdx );
+        cwLogMod("Created var: %s:%i.%s:%i ch:%i.", proc->label, proc->label_sfx_id, var_label, sfx_id, chIdx );
       }
       
       return rc;
@@ -1100,9 +1109,9 @@ namespace cw
         
       for(; vd!=nullptr; vd=vd->link)
       {
-        const char* srcFlStr    = vd->flags & kSrcVarFl    ? "src"      : "   ";
-        const char* srcOptFlStr = vd->flags & kSrcOptVarFl ? "srcOpt"   : "      ";
-        const char* plyMltFlStr = vd->flags & kMultVarFl   ? "mult"     : "    ";
+        const char* srcFlStr    = vd->flags & kSrcVarDescFl    ? "src"      : "   ";
+        const char* srcOptFlStr = vd->flags & kSrcOptVarDescFl ? "srcOpt"   : "      ";
+        const char* plyMltFlStr = vd->flags & kMultVarDescFl   ? "mult"     : "    ";
           
         printf("  %10s 0x%08x %s %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, plyMltFlStr, cwStringNullGuard(vd->docText) );
       }  
@@ -1281,7 +1290,7 @@ cw::flow::mbuf_t* cw::flow::mbuf_duplicate( const mbuf_t* src )
 
 unsigned cw::flow::value_type_label_to_flag( const char* s )
 {
-  unsigned flags = labelToId(typeLabelFlagsA,s,kInvalidTFl);
+  unsigned flags = labelToId(_typeLabelFlagsA,s,kInvalidTFl);
   if( flags == kInvalidTFl )
     cwLogError(kInvalidArgRC,"Invalid type flag: '%s'",cwStringNullGuard(s));
     
@@ -1292,6 +1301,65 @@ const char* cw::flow::value_type_flag_to_label( unsigned flag )
 {  return _typeFlagToLabel(flag); }
   
 
+
+cw::flow::var_desc_t*  cw::flow::var_desc_create( const char* label, const object_t* cfg )
+{
+  var_desc_t* vd = mem::allocZ<var_desc_t>();
+  vd->label = label;
+  vd->cfg   = cfg;
+  return vd;
+}
+
+void cw::flow::var_desc_destroy( var_desc_t* var_desc )
+{
+  if( var_desc != nullptr )
+  {
+    mem::release(var_desc->proxyProcLabel);
+    mem::release(var_desc->proxyVarLabel);
+    mem::release(var_desc);
+  }
+}
+
+unsigned cw::flow::var_desc_attr_label_to_flag( const char* attr_label )
+{
+  return labelToId(_varDescAttrFlagsA,attr_label,kInvalidVarDescFl);
+}
+
+const char*  cw::flow::var_desc_flag_to_attribute( unsigned flag )
+{
+  return idToLabel(_varDescAttrFlagsA,flag,kInvalidVarDescFl);
+}
+
+const cw::idLabelPair_t* cw::flow::var_desc_flag_array( unsigned& array_cnt_ref )
+{
+  array_cnt_ref = sizeof(_varDescAttrFlagsA)/sizeof(_varDescAttrFlagsA[0]);
+  return _varDescAttrFlagsA;
+}
+
+void cw::flow::class_desc_destroy( class_desc_t* class_desc)
+{
+  // release the var desc list
+  var_desc_t*   vd0 = class_desc->varDescL;
+  var_desc_t*   vd1 = nullptr;        
+  while( vd0 != nullptr )
+  {
+    vd1 = vd0->link;
+    var_desc_destroy(vd0);
+    vd0 = vd1;
+  }
+
+  // release the preset list
+  preset_t* pr0 = class_desc->presetL;
+  preset_t* pr1 = nullptr;
+  while( pr0 != nullptr )
+  {
+    pr1 = pr0->link;
+    mem::release(pr0);
+    pr0 = pr1;
+  }
+  
+}
+
 cw::flow::class_desc_t* cw::flow::class_desc_find( flow_t* p, const char* label )
 {
   for(unsigned i=0; i<p->classDescN; ++i)
@@ -1349,28 +1417,53 @@ void cw::flow::class_dict_print( flow_t* p )
 
 void cw::flow::network_print( const network_t& net )
 {
-  // for each instance in the network
+  // for each procance in the network
   for(unsigned i=0; i<net.proc_arrayN; ++i)
   {
-    instance_t* inst = net.proc_array[i];
-    instance_print(inst);
+    proc_t* proc = net.proc_array[i];
+    proc_print(proc);
 
-    // if this instance has an  internal network
-    if( inst->internal_net != nullptr )
+    // if this procance has an  internal network
+    if( proc->internal_net != nullptr )
     {
-      printf("------- Begin Nested Network: %s -------\n",cwStringNullGuard(inst->label));
-      network_print(*(inst->internal_net));
-      printf("------- End Nested Network: %s -------\n",cwStringNullGuard(inst->label));
+      printf("------- Begin Nested Network: %s -------\n",cwStringNullGuard(proc->label));
+      network_print(*(proc->internal_net));
+      printf("------- End Nested Network: %s -------\n",cwStringNullGuard(proc->label));
     }
         
   }
 }
 
-cw::rc_t cw::flow::instance_validate( instance_t* inst )
+void cw::flow::proc_destroy( proc_t* proc )
+{
+  if( proc == nullptr )
+    return;
+      
+  if( proc->class_desc->members->destroy != nullptr && proc->userPtr != nullptr )
+    proc->class_desc->members->destroy( proc );
+
+  // destroy the proc instance variables
+  variable_t* var0 = proc->varL;
+  variable_t* var1 = nullptr;      
+  while( var0 != nullptr )
+  {
+    var1 = var0->var_link;
+    var_destroy(var0);
+    var0 = var1;
+  }
+      
+  proc->varL = nullptr;
+      
+  mem::release(proc->label);
+  mem::release(proc->varMapA);
+  mem::release(proc);
+}
+
+cw::rc_t cw::flow::proc_validate( proc_t* proc )
 {
   rc_t rc = kOkRC;
 
-  for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+  for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
   {
     if( var->label == nullptr )
     {
@@ -1396,7 +1489,7 @@ cw::rc_t cw::flow::instance_validate( instance_t* inst )
     {
       rc = cwLogError(kInvalidStateRC, "The value type flag '%s' (0x%x) of '%s:%i-%s:%i' is not found in the variable class type flags: '%s' (0x%x)",
                       _typeFlagToLabel(var->value->tflag),var->value->tflag,
-                      var->inst->label,var->inst->label_sfx_id,
+                      var->proc->label,var->proc->label_sfx_id,
                       var->label,var->label_sfx_id,
                       _typeFlagToLabel(var->varDesc->type),var->varDesc->type);
       continue;
@@ -1411,23 +1504,23 @@ cw::rc_t cw::flow::instance_validate( instance_t* inst )
 }
 
 
-cw::flow::instance_t* cw::flow::instance_find( network_t& net, const char* inst_label, unsigned sfx_id )
+cw::flow::proc_t* cw::flow::proc_find( network_t& net, const char* proc_label, unsigned sfx_id )
 {
   for(unsigned i=0; i<net.proc_arrayN; ++i)
-    if( net.proc_array[i]->label_sfx_id==sfx_id && textIsEqual(inst_label,net.proc_array[i]->label) )
+    if( net.proc_array[i]->label_sfx_id==sfx_id && textIsEqual(proc_label,net.proc_array[i]->label) )
       return net.proc_array[i];
 
   return nullptr;
 }
 
-cw::rc_t cw::flow::instance_find( network_t& net, const char* inst_label, unsigned sfx_id, instance_t*& instPtrRef )
+cw::rc_t cw::flow::proc_find( network_t& net, const char* proc_label, unsigned sfx_id, proc_t*& procPtrRef )
 {
   rc_t rc = kOkRC;
       
-  if((instPtrRef = instance_find(net,inst_label,sfx_id)) != nullptr )
+  if((procPtrRef = proc_find(net,proc_label,sfx_id)) != nullptr )
     return rc;
       
-  return cwLogError(kInvalidArgRC,"The instance '%s:%i' was not found.", inst_label, sfx_id );
+  return cwLogError(kInvalidArgRC,"The procance '%s:%i' was not found.", proc_label, sfx_id );
 }
 
 cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel )
@@ -1444,29 +1537,40 @@ cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const ch
   return nullptr;
 }
 
-void cw::flow::instance_print( instance_t* inst )
+void cw::flow::proc_print( proc_t* proc )
 {
-  printf("%s:%i\n", inst->label,inst->label_sfx_id);
-  for(variable_t* var = inst->varL; var!=nullptr; var=var->var_link)
+  printf("%s:%i\n", proc->label,proc->label_sfx_id);
+  for(variable_t* var = proc->varL; var!=nullptr; var=var->var_link)
     if( var->chIdx == kAnyChIdx )
       for(variable_t* v0 = var; v0!=nullptr; v0=v0->ch_link)
         _var_print(v0);      
   
-  if( inst->class_desc->members->report )
-    inst->class_desc->members->report( inst );
+  if( proc->class_desc->members->report )
+    proc->class_desc->members->report( proc );
 }
 
-unsigned cw::flow::instance_var_count( instance_t* inst )
+unsigned cw::flow::proc_var_count( proc_t* proc )
 {
   unsigned n = 0;
-  for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+  for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
     ++n;
 
   return n;
 }
 
 
-void cw::flow::_var_destroy( variable_t* var )
+
+
+cw::rc_t cw::flow::var_create( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFl, variable_t*& varRef )
+{
+  rc_t rc = kOkRC;
+
+  rc = _var_create( proc, var_label, sfx_id, id, chIdx, value_cfg, altTypeFl, varRef );
+
+  return rc;
+}
+
+void cw::flow::var_destroy( variable_t* var )
 {
   if( var != nullptr )
   {
@@ -1481,31 +1585,21 @@ void cw::flow::_var_destroy( variable_t* var )
   }
 }
 
-
-cw::rc_t cw::flow::var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned id, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFl, variable_t*& varRef )
-{
-  rc_t rc = kOkRC;
-
-  rc = _var_create( inst, var_label, sfx_id, id, chIdx, value_cfg, altTypeFl, varRef );
-
-  return rc;
-}
-
-cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef )
+cw::rc_t  cw::flow::var_channelize( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   variable_t* base_var = nullptr;
   varRef = nullptr;
 
-  if((base_var = _var_find_on_label_and_ch( inst, var_label, sfx_id, kAnyChIdx)) == nullptr)
+  if((base_var = _var_find_on_label_and_ch( proc, var_label, sfx_id, kAnyChIdx)) == nullptr)
   {
-    rc = cwLogError(kInvalidStateRC,"The base ('any') channel variable could not be located on '%s:%i.%s:%i'.",inst->label,inst->label_sfx_id,var_label,sfx_id);
+    rc = cwLogError(kInvalidStateRC,"The base ('any') channel variable could not be located on '%s:%i.%s:%i'.",proc->label,proc->label_sfx_id,var_label,sfx_id);
     goto errLabel;
   }
  
   // locate the variable with the stated chIdx
-  var = _var_find_on_label_and_ch( inst, var_label, sfx_id, chIdx );
+  var = _var_find_on_label_and_ch( proc, var_label, sfx_id, chIdx );
   
   // 'src' variables cannot be channelized
   /*
@@ -1520,7 +1614,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   if( var == nullptr && chIdx != kAnyChIdx )
   {
     // create the channelized var
-    if((rc = _var_create( inst, var_label, sfx_id, vid, chIdx, value_cfg, kInvalidTFl, var )) != kOkRC )
+    if((rc = _var_create( proc, var_label, sfx_id, vid, chIdx, value_cfg, kInvalidTFl, var )) != kOkRC )
       goto errLabel;
 
     // if no value was set then set the value from the 'any' channel
@@ -1534,7 +1628,9 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
         // Attempt to find a matching channel on the source
         variable_t* src_ch_var      = base_var->src_var;
         variable_t* last_src_ch_var = base_var->src_var;
-        unsigned src_ch_cnt = 0;
+        unsigned    src_ch_cnt      = 0;
+        bool        anyChFl         = false;
+        bool        zeroChFl        = false;
         
         for(; src_ch_var!=nullptr; src_ch_var=src_ch_var->ch_link)
         {
@@ -1542,14 +1638,27 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
           if( src_ch_var->chIdx == var->chIdx )
             break;
 
+          if( src_ch_var->chIdx == kAnyChIdx )
+            anyChFl = true;
+
+          if( src_ch_var->chIdx == 0 )
+            zeroChFl = true;
+          
           src_ch_cnt += 1;
         }
 
-        // if there is more than one channel available and the src and dst var's do not have matching ch indexes
+        // If there is more than one channel available, in addition to the kAnyCh, and the src and dst var's do not have matching ch indexes
         // then there is a possibility that this is an unexpected connection between different channels.
-        if( src_ch_var == nullptr && src_ch_cnt>1 && last_src_ch_var->chIdx != var->chIdx )
-          cwLogWarning("A connection is being made where channel src and dst. channels don't match and more than one src channel is available.");
-
+        // However if there only any-ch and/or ch=0 is available then this is simply a one channel to many channels which is common.
+        if( src_ch_var == nullptr && (anyChFl==false || (src_ch_cnt>1 && zeroChFl==false))  && last_src_ch_var->chIdx != var->chIdx )
+        {
+          cwLogWarning("A connection is being made where channel src and dst. channels don't match and more than one src channel is available. src:%s:%i-%s:%i ch:%i of %i dst:%s:%i-%s:%i ch:%i",
+                       last_src_ch_var->proc->label, last_src_ch_var->proc->label_sfx_id,
+                       last_src_ch_var->label,       last_src_ch_var->label_sfx_id, last_src_ch_var->chIdx, src_ch_cnt,
+                       var->proc->label,             var->proc->label_sfx_id,
+                       var->label,                   var->label_sfx_id,             var->chIdx );
+        }
+        
         // if no matching channel is found connect to the last valid source channel
         // (Connecting to the last valid source is better than connecting to base_var->src_var
         //  because if a var has more than a base var it is unlikely to update the base_var.)
@@ -1580,7 +1689,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
     }
     else
     {
-      cwLogWarning("An existing var (%s:i.%s:i ch:%i) was specified for channelizing but no value was provided.", inst->label, inst->label_sfx_id, var_label, sfx_id, chIdx );
+      cwLogWarning("An existing var (%s:i.%s:i ch:%i) was specified for channelizing but no value was provided.", proc->label, proc->label_sfx_id, var_label, sfx_id, chIdx );
     }
   }
 
@@ -1589,7 +1698,7 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on instance '%s:%i' ch:%i.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx );
+    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on procance '%s:%i' ch:%i.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx );
   
   return rc;
 }
@@ -1597,12 +1706,12 @@ cw::rc_t  cw::flow::var_channelize( instance_t* inst, const char* var_label, uns
 cw::rc_t cw::flow::var_call_custom_value_func( variable_t* var )
 {
   rc_t rc;
-  if((rc = var->inst->class_desc->members->value( var->inst, var )) != kOkRC )
+  if((rc = var->proc->class_desc->members->value( var->proc, var )) != kOkRC )
     goto errLabel;
   
   if( var->flags & kLogVarFl )
   {    
-    printf("%10s:%5i", var->inst->label,var->inst->label_sfx_id);
+    printf("%10s:%5i", var->proc->label,var->proc->label_sfx_id);
     
     if( var->chIdx == kAnyChIdx )
       _var_print(var);
@@ -1620,14 +1729,14 @@ errLabel:
   
 }
 
-cw::rc_t cw::flow::var_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref )
+cw::rc_t cw::flow::var_flags( proc_t* proc, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
   flags_ref = 0;
   
-  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+  if((rc = _var_find_on_label_and_ch(proc,var_label,sfx_id,chIdx,var)) != kOkRC )
     goto errLabel;
 
   flags_ref = var->flags;
@@ -1636,12 +1745,12 @@ errLabel:
   return rc;
 }
     
-cw::rc_t cw::flow::var_set_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flag )
+cw::rc_t cw::flow::var_set_flags( proc_t* proc, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flag )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+  if((rc = _var_find_on_label_and_ch(proc,var_label,sfx_id,chIdx,var)) != kOkRC )
     goto errLabel;
   
 
@@ -1651,12 +1760,12 @@ errLabel:
   return rc;
 }
     
-cw::rc_t cw::flow::var_clr_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flag )
+cw::rc_t cw::flow::var_clr_flags( proc_t* proc, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flag )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx,var)) != kOkRC )
+  if((rc = _var_find_on_label_and_ch(proc,var_label,sfx_id,chIdx,var)) != kOkRC )
     goto errLabel;
 
   var->flags = cwClrFlag(var->flags,flag);
@@ -1664,47 +1773,47 @@ errLabel:
   return rc;
 }
 
-bool cw::flow::var_exists( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
-{ return _var_find_on_label_and_ch(inst,label,sfx_id,chIdx) != nullptr; }
+bool cw::flow::var_exists( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx )
+{ return _var_find_on_label_and_ch(proc,label,sfx_id,chIdx) != nullptr; }
 
-bool cw::flow::var_has_value( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
+bool cw::flow::var_has_value( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx )
 {
   variable_t* varPtr = nullptr;
   rc_t rc;
   
-  if((rc = var_find( inst, label, sfx_id, chIdx, varPtr )) != kOkRC )
+  if((rc = var_find( proc, label, sfx_id, chIdx, varPtr )) != kOkRC )
     return false;
 
   return varPtr->value != nullptr;
 }
 
-bool  cw::flow::var_is_a_source( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx )
+bool  cw::flow::var_is_a_source( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx )
 {
   rc_t rc;
   variable_t* varPtr = nullptr;
-  if((rc = var_find( inst, label, sfx_id, chIdx, varPtr)) != kOkRC )
+  if((rc = var_find( proc, label, sfx_id, chIdx, varPtr)) != kOkRC )
   {
-    cwLogError(kEleNotFoundRC,"The variable '%s:%i' was not found on proc:'%s:%i'. 'source' state query is invalid.",cwStringNullGuard(label),sfx_id,cwStringNullGuard(inst->label),inst->label_sfx_id);
+    cwLogError(kEleNotFoundRC,"The variable '%s:%i' was not found on proc:'%s:%i'. 'source' state query is invalid.",cwStringNullGuard(label),sfx_id,cwStringNullGuard(proc->label),proc->label_sfx_id);
     return false;
   }
   
   return is_a_source_var(varPtr);
 }
 
-bool  cw::flow::var_is_a_source( instance_t* inst, unsigned vid, unsigned chIdx )
+bool  cw::flow::var_is_a_source( proc_t* proc, unsigned vid, unsigned chIdx )
 {
   rc_t rc;
   variable_t* varPtr = nullptr;
-  if((rc = var_find( inst, vid, chIdx, varPtr)) != kOkRC )
+  if((rc = var_find( proc, vid, chIdx, varPtr)) != kOkRC )
   {
-    cwLogError(kEleNotFoundRC,"The variable with vid '%i' was not found on proc:'%s:%i'. 'source' state query is invalid.",vid,cwStringNullGuard(inst->label),inst->label_sfx_id);
+    cwLogError(kEleNotFoundRC,"The variable with vid '%i' was not found on proc:'%s:%i'. 'source' state query is invalid.",vid,cwStringNullGuard(proc->label),proc->label_sfx_id);
     return false;
   }
   
   return is_a_source_var(varPtr);
 }
 
-cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, variable_t*& varRef )
+cw::rc_t cw::flow::var_find( proc_t* proc, unsigned vid, unsigned chIdx, variable_t*& varRef )
 {
   rc_t        rc  = kOkRC;
   unsigned    idx = kInvalidIdx;
@@ -1712,20 +1821,20 @@ cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, var
       
   varRef = nullptr;
 
-  // if the varMapA[] has not yet been formed (we are inside the instance constructor) then do a slow lookup of the variable
-  if( inst->varMapA == nullptr )
+  // if the varMapA[] has not yet been formed (we are inside the procance constructor) then do a slow lookup of the variable
+  if( proc->varMapA == nullptr )
   {
-    if((rc = _var_find_on_vid_and_ch(inst,vid,chIdx,var)) != kOkRC )
+    if((rc = _var_find_on_vid_and_ch(proc,vid,chIdx,var)) != kOkRC )
       goto errLabel;
   }
   else
   {
-    // otherwise do a fast lookup using inst->varMapA[]
-    if((rc = _var_map_id_to_index(inst, vid, chIdx, idx )) == kOkRC && (idx != kInvalidIdx ))
-      var = inst->varMapA[idx];
+    // otherwise do a fast lookup using proc->varMapA[]
+    if((rc = _var_map_id_to_index(proc, vid, chIdx, idx )) == kOkRC && (idx != kInvalidIdx ))
+      var = proc->varMapA[idx];
     else
     {
-      rc = cwLogError(kInvalidIdRC,"The index of variable vid:%i chIdx:%i on instance '%s:%i' could not be calculated and the variable value could not be retrieved.", vid, chIdx, inst->label,inst->label_sfx_id);
+      rc = cwLogError(kInvalidIdRC,"The index of variable vid:%i chIdx:%i on procance '%s:%i' could not be calculated and the variable value could not be retrieved.", vid, chIdx, proc->label,proc->label_sfx_id);
       goto errLabel;
     }
   }
@@ -1741,35 +1850,35 @@ cw::rc_t cw::flow::var_find( instance_t* inst, unsigned vid, unsigned chIdx, var
 
 
 
-cw::rc_t cw::flow::var_find( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx, variable_t*& vRef )
+cw::rc_t cw::flow::var_find( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx, variable_t*& vRef )
 {
   variable_t* var;
   vRef = nullptr;
   
-  if((var = _var_find_on_label_and_ch(inst,label,sfx_id,chIdx)) != nullptr )
+  if((var = _var_find_on_label_and_ch(proc,label,sfx_id,chIdx)) != nullptr )
   {
     vRef = var;
     return kOkRC;
   }
 
-  return cwLogError(kInvalidIdRC,"The instance '%s:%i' does not have a variable named '%s:%i'.", inst->label, inst->label_sfx_id, label, sfx_id );  
+  return cwLogError(kInvalidIdRC,"The procance '%s:%i' does not have a variable named '%s:%i'.", proc->label, proc->label_sfx_id, label, sfx_id );  
 }
 
-cw::rc_t cw::flow::var_find( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx, const variable_t*& vRef )
+cw::rc_t cw::flow::var_find( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx, const variable_t*& vRef )
 {
   variable_t* v = nullptr;
-  rc_t        rc = var_find(inst,label,sfx_id,chIdx,v);
+  rc_t        rc = var_find(proc,label,sfx_id,chIdx,v);
   vRef = v;
   return rc;
 }
 
 
-cw::rc_t  cw::flow::var_channel_count( instance_t* inst, const char* label, unsigned sfx_id, unsigned& chCntRef )
+cw::rc_t  cw::flow::var_channel_count( proc_t* proc, const char* label, unsigned sfx_id, unsigned& chCntRef )
 {
   rc_t rc = kOkRC;
   const variable_t* var= nullptr;
-  if((rc = var_find(inst,label,sfx_id,kAnyChIdx,var)) != kOkRC )
-    return cwLogError(rc,"Channel count was not available because the variable '%s:%i.%s:%i' does not exist.",cwStringNullGuard(inst->label),inst->label_sfx_id,cwStringNullGuard(label),sfx_id);
+  if((rc = var_find(proc,label,sfx_id,kAnyChIdx,var)) != kOkRC )
+    return cwLogError(rc,"Channel count was not available because the variable '%s:%i.%s:%i' does not exist.",cwStringNullGuard(proc->label),proc->label_sfx_id,cwStringNullGuard(label),sfx_id);
 
   return var_channel_count(var,chCntRef);
 }
@@ -1781,9 +1890,9 @@ cw::rc_t  cw::flow::var_channel_count( const variable_t* var, unsigned& chCntRef
   
   chCntRef = 0;
   
-  if((rc = var_find( var->inst, var->label, var->label_sfx_id, kAnyChIdx, v )) != kOkRC )
+  if((rc = var_find( var->proc, var->label, var->label_sfx_id, kAnyChIdx, v )) != kOkRC )
   {
-    rc = cwLogError(kInvalidStateRC,"The base channel variable instance could not be found for the variable '%s:%i.%s:%i'.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id);
+    rc = cwLogError(kInvalidStateRC,"The base channel variable procance could not be found for the variable '%s:%i.%s:%i'.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id);
     goto errLabel;
   }
 
@@ -1796,18 +1905,18 @@ cw::rc_t  cw::flow::var_channel_count( const variable_t* var, unsigned& chCntRef
 
 
 
-cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsigned sfx_id,  unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
+cw::rc_t cw::flow::var_register( proc_t* proc, const char* var_label, unsigned sfx_id,  unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
 
   varRef = nullptr;
 
-  // TODO: check for duplicate 'vid'-'chIdx' pairs on this instance
+  // TODO: check for duplicate 'vid'-'chIdx' pairs on this procance
   // The concatenation of 'vid' and 'chIdx' should be unique 
 
   // if an exact match to label/chIdx was found
-  if((var = _var_find_on_label_and_ch(inst,var_label,sfx_id,chIdx)) != nullptr )
+  if((var = _var_find_on_label_and_ch(proc,var_label,sfx_id,chIdx)) != nullptr )
   {
     // if a value was given - then update the value
     if( value_cfg != nullptr )
@@ -1816,21 +1925,21 @@ cw::rc_t cw::flow::var_register( instance_t* inst, const char* var_label, unsign
   }
   else // an exact match was not found - channelize the variable
   {
-    if((rc = var_channelize(inst,var_label,sfx_id,chIdx,value_cfg,vid,var)) != kOkRC )
+    if((rc = var_channelize(proc,var_label,sfx_id,chIdx,value_cfg,vid,var)) != kOkRC )
       goto errLabel;
   }
 
   var->vid = vid;
   varRef   = var;
 
-  if((var = _var_find_on_label_and_ch(inst,var_label,sfx_id,kAnyChIdx)) != nullptr )
+  if((var = _var_find_on_label_and_ch(proc,var_label,sfx_id,kAnyChIdx)) != nullptr )
     var->vid = vid;
   else
-    rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' instance '%s:%i' has no base channel.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx);
+    rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' procance '%s:%i' has no base channel.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx);
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Registration failed on variable '%s:%i' instance '%s:%i' ch: %i.", var_label, sfx_id, inst->label, inst->label_sfx_id, chIdx);
+    rc = cwLogError(rc,"Registration failed on variable '%s:%i' procance '%s:%i' ch: %i.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx);
   
   return rc;
 }
@@ -1883,14 +1992,14 @@ void cw::flow::var_connect( variable_t* src_var, variable_t* in_var )
 }
 
 
-cw::rc_t  cw::flow::var_mult_sfx_id_array( instance_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref )
+cw::rc_t  cw::flow::var_mult_sfx_id_array( proc_t* proc, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref )
 {
   rc_t rc = kOkRC;
 
   idN_ref = 0;
 
   // for each variable whose 'label' is 'var_label'
-  for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+  for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
     if( textIsEqual(var->label,var_label) )
     {
       // scan idA[] for a matching sfx_id
@@ -1921,54 +2030,54 @@ errLabel:
   return rc;
 }
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, variable_t*& varRef )
+cw::rc_t cw::flow::var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, variable_t*& varRef )
 {
-  return var_register( inst, var_label, sfx_id, vid, chIdx, nullptr, varRef );
+  return var_register( proc, var_label, sfx_id, vid, chIdx, nullptr, varRef );
 }
 
-cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN )
+cw::rc_t        cw::flow::var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN )
 {
   rc_t rc = kOkRC;
   abuf_t* abuf;
   
   if((abuf = abuf_create( srate, chN, frameN )) == nullptr )
-    return cwLogError(kOpFailRC,"abuf create failed on instance:'%s:%i' variable:'%s:%i'.", inst->label, inst->label_sfx_id, var_label,sfx_id);
+    return cwLogError(kOpFailRC,"abuf create failed on procance:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label,sfx_id);
 
-  if((rc = _var_register_and_set( inst, var_label, sfx_id, vid, chIdx, abuf )) != kOkRC )
+  if((rc = _var_register_and_set( proc, var_label, sfx_id, vid, chIdx, abuf )) != kOkRC )
     abuf_destroy(abuf);
 
   return rc;
 }
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
+cw::rc_t cw::flow::var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   rc_t rc = kOkRC;
   fbuf_t* fbuf;
   if((fbuf = fbuf_create( srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV )) == nullptr )
-    return cwLogError(kOpFailRC,"fbuf create failed on instance:'%s:%i' variable:'%s:%i'.", inst->label, inst->label_sfx_id, var_label,sfx_id);
+    return cwLogError(kOpFailRC,"fbuf create failed on procance:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label,sfx_id);
 
-  if((rc = _var_register_and_set( inst, var_label, sfx_id, vid, chIdx, fbuf )) != kOkRC )
+  if((rc = _var_register_and_set( proc, var_label, sfx_id, vid, chIdx, fbuf )) != kOkRC )
     fbuf_destroy(fbuf);
 
   return rc;
 }
 
-cw::rc_t        cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* msgA, unsigned msgN  )
+cw::rc_t        cw::flow::var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* msgA, unsigned msgN  )
 {
   rc_t rc = kOkRC;
   mbuf_t* mbuf;
   
   if((mbuf = mbuf_create(msgA,msgN)) == nullptr )
-    return cwLogError(kOpFailRC,"mbuf create failed on instance:'%s:%i' variable:'%s:%i'.", inst->label, inst->label_sfx_id, var_label, sfx_id);
+    return cwLogError(kOpFailRC,"mbuf create failed on procance:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label, sfx_id);
 
-  if((rc = _var_register_and_set( inst, var_label, sfx_id, vid, chIdx, mbuf )) != kOkRC )
+  if((rc = _var_register_and_set( proc, var_label, sfx_id, vid, chIdx, mbuf )) != kOkRC )
     mbuf_destroy(mbuf);
 
   return rc;
 }
 
 
-cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
+cw::rc_t cw::flow::var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV, const fd_sample_t** phsV, const fd_sample_t** hzV )
 {
   unsigned maxBinN_V[ chN ];
   unsigned binN_V[ chN ];
@@ -1976,7 +2085,7 @@ cw::rc_t cw::flow::var_register_and_set( instance_t* inst, const char* var_label
   vop::fill(maxBinN_V,chN,maxBinN);
   vop::fill(binN_V,chN,binN);
   vop::fill(hopSmpN_V,chN, hopSmpN );
-  return var_register_and_set(inst,var_label,sfx_id,vid,chIdx,srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV);
+  return var_register_and_set(proc,var_label,sfx_id,vid,chIdx,srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV);
 }
 
 
@@ -2139,7 +2248,7 @@ cw::rc_t cw::flow::var_set_from_preset( variable_t* var, const object_t* value )
 
 errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
+    rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
       
   return rc;
       
@@ -2180,89 +2289,89 @@ cw::rc_t cw::flow::var_set( variable_t* var, fbuf_t* val )         { return _var
 cw::rc_t cw::flow::var_set( variable_t* var, mbuf_t* val )         { return _var_set_driver(var,kMBufTFl,val); }
 cw::rc_t cw::flow::var_set( variable_t* var, const object_t* val ) { return _var_set_driver(var,kCfgTFl,val); }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, const value_t* val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, const value_t* val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = var_set(var,val);
   
   return rc;
 }    
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, bool val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kBoolTFl, val );
   
   return rc;    
 }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, uint_t val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, uint_t val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kUIntTFl, val );
   
   return rc;    
 }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, int_t val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, int_t val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kIntTFl, val );
   
   return rc;    
 }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, float val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, float val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kFloatTFl, val );
   
   return rc;    
 }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, double val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, double val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kDoubleTFl, val );
   
   return rc;    
 }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, const char* val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, const char* val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kStringTFl, val );
   
   return rc;    
 }
 
-cw::rc_t cw::flow::var_set( instance_t* inst, unsigned vid, unsigned chIdx, const object_t* val )
+cw::rc_t cw::flow::var_set( proc_t* proc, unsigned vid, unsigned chIdx, const object_t* val )
 {
   rc_t        rc  = kOkRC;
   variable_t* var = nullptr;
   
-  if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+  if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
     rc = _var_set_driver( var, kCfgTFl, val );
   
   return rc;    
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 4fd0af6..93922b4 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -122,19 +122,22 @@ namespace cw
     } value_t;
 
         
-    struct instance_str;
+    struct proc_str;
     struct variable_str;
         
-    typedef rc_t (*member_func_t)( struct instance_str* ctx );
-    typedef rc_t (*member_value_func_t)( struct instance_str* ctx, struct variable_str* var );
-    
+    typedef rc_t (*member_func_t)( struct proc_str* ctx );
+    typedef rc_t (*member_value_func_t)( struct proc_str* ctx, struct variable_str* var );
+
+    // var_desc_t attribute flags
     enum
     {
-      kNoVarFl     = 0x00,
-      kSrcVarFl    = 0x01,
-      kSrcOptVarFl = 0x02,
-      kMultVarFl   = 0x04,
-      kSubnetOutVarFl = 0x08
+      kInvalidVarDescFl   = 0x00,
+      kSrcVarDescFl       = 0x01,
+      kSrcOptVarDescFl    = 0x02,
+      kNoSrcVarDescFl     = 0x04,
+      kInitVarDescFl      = 0x08,
+      kMultVarDescFl      = 0x10,
+      kSubnetOutVarDescFl = 0x20
     };
     
     typedef struct class_members_str
@@ -189,7 +192,7 @@ namespace cw
     // on a given 'instance'.
     typedef struct variable_str
     {
-      struct instance_str* inst;         // pointer to this variables instance
+      struct proc_str* proc;         // pointer to this variables instance
       
       char*                label;        // this variables label
       unsigned             label_sfx_id; // the label suffix id of this variable or kBaseSfxId if this has no suffix
@@ -218,7 +221,7 @@ namespace cw
     } variable_t;
 
     
-    struct instance_str;
+    struct proc_str;
 
     typedef struct network_str
     {
@@ -227,13 +230,13 @@ namespace cw
 
       unsigned poly_cnt; // count of duplicated networks in the list
 
-      struct instance_str** proc_array;
+      struct proc_str** proc_array;
       unsigned              proc_arrayAllocN;
       unsigned              proc_arrayN;
       
     } network_t;
     
-    typedef struct instance_str
+    typedef struct proc_str
     {
       struct flow_str* ctx;          // global system context
       network_t*       net;          // network which owns this proc
@@ -259,7 +262,7 @@ namespace cw
 
       network_t*  internal_net;
       
-    } instance_t;
+    } proc_t;
 
 
     typedef struct flow_str
@@ -329,6 +332,14 @@ namespace cw
     // Class and Variable Description
     //
 
+    var_desc_t*       var_desc_create( const char* label, const object_t* value_cfg );
+    void              var_desc_destroy( var_desc_t* var_desc );
+    
+    unsigned             var_desc_attr_label_to_flag( const char* attr_label );
+    const char*          var_desc_flag_to_attribute( unsigned flag );
+    const idLabelPair_t* var_desc_flag_array( unsigned& array_cnt_ref );
+
+    void              class_desc_destroy( class_desc_t* class_desc);
     class_desc_t*     class_desc_find(  flow_t* p, const char* class_desc_label );
     
     var_desc_t*       var_desc_find(       class_desc_t* cd, const char* var_label );
@@ -351,17 +362,18 @@ namespace cw
     // Instance
     //
 
-    rc_t               instance_validate( instance_t* inst );
+    void               proc_destroy( proc_t* proc );
+    rc_t               proc_validate( proc_t* proc );
     
-    instance_t*        instance_find( network_t& net, const char* inst_label, unsigned sfx_id );
-    rc_t               instance_find( network_t& net, const char* inst_label, unsigned sfx_id, instance_t*& instPtrRef );
+    proc_t*            proc_find( network_t& net, const char* inst_label, unsigned sfx_id );
+    rc_t               proc_find( network_t& net, const char* inst_label, unsigned sfx_id, proc_t*& instPtrRef );
     
     external_device_t* external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel=nullptr );
 
-    void               instance_print( instance_t* inst );
+    void               proc_print( proc_t* inst );
 
     // Count of all var instances on this proc.  This is a count of the length of inst->varL.
-    unsigned           instance_var_count( instance_t* inst );
+    unsigned           proc_var_count( proc_t* inst );
 
     
     //------------------------------------------------------------------------------------------------------------------------
@@ -373,22 +385,23 @@ namespace cw
     // Notes:
     // 1) `value_cfg` is optional. Set it to NULL to ignore
     // 2) If `altTypeFl` is not set to kInvalidTFl then the var is assigned this type.
-    rc_t           var_create( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFlag, variable_t*& varRef );
+    rc_t           var_create( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFlag, variable_t*& varRef );
+    void           var_destroy( variable_t* var );
 
     // Channelizing creates a new var record with an explicit channel index to replace the
     // automatically generated variable whose channel index is set to  'all'.
-    rc_t           var_channelize( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
+    rc_t           var_channelize( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
 
     // Wrapper around call to var->inst->members->value()
     rc_t           var_call_custom_value_func( variable_t* var );
 
     // Sets and get the var->flags field
-    unsigned       var_flags(     instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref );
-    rc_t           var_set_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
-    rc_t           var_clr_flags( instance_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
+    unsigned       var_flags(     proc_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref );
+    rc_t           var_set_flags( proc_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
+    rc_t           var_clr_flags( proc_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
 
     // `value_cfg` is optional. Set it to NULL to ignore
-    rc_t           var_register( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
+    rc_t           var_register( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
     // Returns true if this var is connected to an source proc variable
     bool           is_connected_to_source_proc( const variable_t* var );
@@ -400,17 +413,17 @@ namespace cw
     void           var_connect( variable_t* src_var, variable_t* in_var );
 
     // Get all the label-sfx-id's associated with a give var label
-    rc_t           var_mult_sfx_id_array( instance_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
+    rc_t           var_mult_sfx_id_array( proc_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
     
     //-----------------
     //
     // var_register
     //
     
-    inline rc_t _var_reg(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
+    inline rc_t _var_reg(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
     
     template< typename T0, typename T1,  typename... ARGS >
-    rc_t _var_reg( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, ARGS&&... args )
+    rc_t _var_reg( proc_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, ARGS&&... args )
     {
       rc_t rc;
       variable_t* dummy = nullptr;
@@ -422,7 +435,7 @@ namespace cw
 
     // Call var_register() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
+    rc_t           var_register( proc_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
     {  return _var_reg( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
@@ -432,10 +445,10 @@ namespace cw
     // var_register_and_get
     //
 
-    inline rc_t _var_register_and_get(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
+    inline rc_t _var_register_and_get(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
 
     template< typename T>
-    rc_t var_register_and_get( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, T& valRef )
+    rc_t var_register_and_get( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, T& valRef )
     {
       rc_t rc;
       variable_t* var;
@@ -445,10 +458,10 @@ namespace cw
     }
       
     
-    inline rc_t _var_reg_and_get(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
+    inline rc_t _var_reg_and_get(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
 
     template< typename T0, typename T1, typename T2, typename... ARGS >
-    rc_t _var_reg_and_get( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2& valRef, ARGS&&... args )
+    rc_t _var_reg_and_get( proc_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2& valRef, ARGS&&... args )
     {
       rc_t rc;
 
@@ -461,7 +474,7 @@ namespace cw
 
     // Call var_register_and_get() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register_and_get( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id,  ARGS&&... args )
+    rc_t           var_register_and_get( proc_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id,  ARGS&&... args )
     {  return _var_reg_and_get( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
@@ -474,17 +487,17 @@ namespace cw
     // var_register_and_set().  If the variable has not yet been created then it is created and assigned a value.
     // If the variable has already been created then 'vid' and the value are updated.
     // (Note that abuf and fbuf values are not changed by this function only the 'vid' is updated.)
-    rc_t           var_register_and_set( instance_t* inst, const char* label,  unsigned sfx_id,   unsigned vid, unsigned chIdx, variable_t*& varRef );
+    rc_t           var_register_and_set( proc_t* inst, const char* label,  unsigned sfx_id,   unsigned vid, unsigned chIdx, variable_t*& varRef );
     
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
-    rc_t           var_register_and_set( instance_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
+    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
+    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
+    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
+    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
 
-    inline rc_t _var_register_and_set(cw::flow::instance_t*, unsigned int ) { return kOkRC; }
+    inline rc_t _var_register_and_set(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
 
     template< typename T0, typename T1, typename T2, typename... ARGS >
-    rc_t _var_register_and_set( instance_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2 val, ARGS&&... args )
+    rc_t _var_register_and_set( proc_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2 val, ARGS&&... args )
     {
       rc_t rc;
 
@@ -503,25 +516,25 @@ namespace cw
 
     // Call var_register_and_set() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register_and_set( instance_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
+    rc_t           var_register_and_set( proc_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
     {  return _var_register_and_set( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
 
     void           _var_destroy( variable_t* var );
 
-    bool           var_exists(    instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
-    bool           var_has_value( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
-    bool           var_is_a_source( instance_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
-    bool           var_is_a_source( instance_t* inst, unsigned vid, unsigned chIdx );
+    bool           var_exists(    proc_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_has_value( proc_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_is_a_source( proc_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_is_a_source( proc_t* inst, unsigned vid, unsigned chIdx );
 
-    rc_t           var_find(   instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const variable_t*& varRef );
-    rc_t           var_find(   instance_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx,       variable_t*& varRef );
-    rc_t           var_find(   instance_t* inst, unsigned vid,                           unsigned chIdx,       variable_t*& varRef );
+    rc_t           var_find(   proc_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const variable_t*& varRef );
+    rc_t           var_find(   proc_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx,       variable_t*& varRef );
+    rc_t           var_find(   proc_t* inst, unsigned vid,                           unsigned chIdx,       variable_t*& varRef );
 
     
     // Count of numbered channels - does not count the kAnyChIdx variable instance.
-    rc_t           var_channel_count( instance_t* inst, const char* label, unsigned sfx_idx, unsigned& chCntRef );
+    rc_t           var_channel_count( proc_t* inst, const char* label, unsigned sfx_idx, unsigned& chCntRef );
     rc_t           var_channel_count( const variable_t* var, unsigned& chCntRef );
     
 
@@ -544,7 +557,7 @@ namespace cw
     rc_t var_get( const variable_t* var, const object_t*& valRef );
 
     template< typename T>
-    rc_t var_get( instance_t* inst, unsigned vid, unsigned chIdx, T& valRef)
+    rc_t var_get( proc_t* inst, unsigned vid, unsigned chIdx, T& valRef)
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
@@ -556,7 +569,7 @@ namespace cw
     }
 
     template< typename T >
-    T val_get( instance_t* inst, unsigned vid, unsigned chIdx )
+    T val_get( proc_t* inst, unsigned vid, unsigned chIdx )
     {
       T value;
       var_get(inst,vid,chIdx,value);
@@ -581,16 +594,16 @@ namespace cw
     rc_t var_set( variable_t* var, mbuf_t* val );
     rc_t var_set( variable_t* var, const object_t* val );
     
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const value_t* val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, bool val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, uint_t val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, int_t val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, float val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, double val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const char* val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, abuf_t* val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, fbuf_t* val );
-    rc_t var_set( instance_t* inst, unsigned vid, unsigned chIdx, const object_t* val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, const value_t* val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, bool val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, uint_t val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, int_t val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, float val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, double val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, const char* val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, abuf_t* val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, fbuf_t* val );
+    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, const object_t* val );
 
     
   }

From 04a34902e6acfb5f1d403017ff90ef93ab3b9a7d Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:46:12 -0400
Subject: [PATCH 056/101] cwFlowNet.h/cpp : Renamed instance_t to proc_t.

---
 cwFlowNet.cpp | 546 ++++++++++++++++++++++++--------------------------
 cwFlowNet.h   |   6 +-
 2 files changed, 263 insertions(+), 289 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index 3fe0ef8..fbbfd6e 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -22,37 +22,13 @@ namespace cw
   namespace flow
   {
 
-    void _destroy_inst( instance_t* inst )
-    {
-      if( inst == nullptr )
-        return;
-      
-      if( inst->class_desc->members->destroy != nullptr && inst->userPtr != nullptr )
-        inst->class_desc->members->destroy( inst );
-
-      // destroy the instance variables
-      variable_t* var0 = inst->varL;
-      variable_t* var1 = nullptr;      
-      while( var0 != nullptr )
-      {
-        var1 = var0->var_link;
-        _var_destroy(var0);
-        var0 = var1;
-      }
-      
-      inst->varL = nullptr;
-      
-      mem::release(inst->label);
-      mem::release(inst->varMapA);
-      mem::release(inst);
-    }
 
     rc_t _network_destroy( network_t& net )
     {
       rc_t rc = kOkRC;
 
       for(unsigned i=0; i<net.proc_arrayN; ++i)
-        _destroy_inst(net.proc_array[i]);
+        proc_destroy(net.proc_array[i]);
 
       mem::release(net.proc_array);
       net.proc_arrayAllocN = 0;
@@ -61,14 +37,14 @@ namespace cw
       return rc;
     }
 
-    rc_t  _var_map_id_to_index(  instance_t* inst, unsigned vid, unsigned chIdx, unsigned& idxRef );
+    rc_t  _var_map_id_to_index(  proc_t* proc, unsigned vid, unsigned chIdx, unsigned& idxRef );
 
-    rc_t _create_instance_var_map( instance_t* inst )
+    rc_t _create_proc_var_map( proc_t* proc )
     {
       rc_t        rc        = kOkRC;
       unsigned    max_vid   = kInvalidId;
       unsigned    max_chIdx = 0;
-      variable_t* var       = inst->varL;
+      variable_t* var       = proc->varL;
       //variable_t* v0        = nullptr;
       
       // determine the max variable vid and max channel index value among all variables
@@ -89,37 +65,37 @@ namespace cw
       if( max_vid != kInvalidId )
       {
         // create the variable map array
-        inst->varMapChN = max_chIdx + 1;
-        inst->varMapIdN = max_vid + 1;
-        inst->varMapN   = inst->varMapIdN * inst->varMapChN;
-        inst->varMapA   = mem::allocZ<variable_t*>( inst->varMapN );
+        proc->varMapChN = max_chIdx + 1;
+        proc->varMapIdN = max_vid + 1;
+        proc->varMapN   = proc->varMapIdN * proc->varMapChN;
+        proc->varMapA   = mem::allocZ<variable_t*>( proc->varMapN );
 
         // assign each variable to a location in the map
-        for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+        for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
           if( var->vid != kInvalidId )
           {
             unsigned idx = kInvalidIdx;
 
-            if((rc = _var_map_id_to_index( inst, var->vid, var->chIdx, idx )) != kOkRC )
+            if((rc = _var_map_id_to_index( proc, var->vid, var->chIdx, idx )) != kOkRC )
               goto errLabel;
 
           
             // verify that there are not multiple variables per map position          
-            if( inst->varMapA[ idx ] != nullptr )
+            if( proc->varMapA[ idx ] != nullptr )
             {
-              variable_t* v0 = inst->varMapA[idx];
-              rc = cwLogError(kInvalidStateRC,"The variable '%s' id:%i ch:%i and '%s' id:%i ch:%i share the same variable map position on instance: %s. This is usually cased by duplicate variable id's.",
-                              v0->label,v0->vid,v0->chIdx, var->label,var->vid,var->chIdx,inst->label);
+              variable_t* v0 = proc->varMapA[idx];
+              rc = cwLogError(kInvalidStateRC,"The variable '%s' id:%i ch:%i and '%s' id:%i ch:%i share the same variable map position on proc instance: %s. This is usually cased by duplicate variable id's.",
+                              v0->label,v0->vid,v0->chIdx, var->label,var->vid,var->chIdx,proc->label);
 
               goto errLabel;
             }
 
             // assign this variable to a map position
-            inst->varMapA[ idx ] = var;
+            proc->varMapA[ idx ] = var;
 
             if( var->chIdx != kAnyChIdx && var->value == nullptr )
             {
-              rc = cwLogError(kInvalidStateRC,"The value of the variable '%s' ch:%i on instance:'%s' has not been set.",var->label,var->chIdx,inst->label);
+              rc = cwLogError(kInvalidStateRC,"The value of the variable '%s' ch:%i on proc instance:'%s' has not been set.",var->label,var->chIdx,proc->label);
               goto errLabel;
             }
 
@@ -133,9 +109,9 @@ namespace cw
     }
 
     /*
-    void _complete_input_connections( instance_t* inst )
+    void _complete_input_connections( proc_t* proc )
     {
-      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
         if(var->chIdx == kAnyChIdx && is_connected_to_source_proc(var) )
         {
 
@@ -144,7 +120,7 @@ namespace cw
           // since 'var' is on the 'any' channel the 'src' var must also be on the 'any' channel
           assert( base_src_var->chIdx == kAnyChIdx );
           
-          //printf("%s %s\n",inst->label,var->label);
+          //printf("%s %s\n",proc->label,var->label);
           
           // for each var channel in the input var
           for(variable_t* in_var = var->ch_link; in_var != nullptr; in_var=in_var->ch_link)
@@ -162,7 +138,7 @@ namespace cw
     }
     */
     
-    rc_t _set_log_flags(instance_t* proc, const object_t* log_labels)
+    rc_t _set_log_flags(proc_t* proc, const object_t* log_labels)
     {
       rc_t rc = kOkRC;
       
@@ -197,24 +173,24 @@ namespace cw
       return rc;
     }
 
-    rc_t _call_value_func_on_all_variables( instance_t* inst )
+    rc_t _call_value_func_on_all_variables( proc_t* proc )
     {
       rc_t rc  = kOkRC;
       rc_t rc1 = kOkRC;
       
-      for(unsigned i=0; i<inst->varMapN; ++i)
-        if( inst->varMapA[i] != nullptr && inst->varMapA[i]->vid != kInvalidId )
+      for(unsigned i=0; i<proc->varMapN; ++i)
+        if( proc->varMapA[i] != nullptr && proc->varMapA[i]->vid != kInvalidId )
         {
-          variable_t* var = inst->varMapA[i];
+          variable_t* var = proc->varMapA[i];
 
           if((rc = var_call_custom_value_func( var )) != kOkRC )
-            rc1 = cwLogError(rc,"The proc instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->inst->label, var->inst->label_sfx_id, var->label, var->chIdx );
+            rc1 = cwLogError(rc,"The proc proc instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->proc->label, var->proc->label_sfx_id, var->label, var->chIdx );
         }
       
       return rc1;
     }
 
-    rc_t _var_channelize( instance_t* inst, const char* preset_label,  const char* type_src_label, const char* var_label, const object_t* value )
+    rc_t _var_channelize( proc_t* proc, const char* preset_label,  const char* type_src_label, const char* var_label, const object_t* value )
     {
       rc_t rc = kOkRC;
       
@@ -224,12 +200,12 @@ namespace cw
       // verify that a valid value exists
       if( value == nullptr )
       {
-        rc = cwLogError(kSyntaxErrorRC,"Unexpected missig value on %s preset '%s' instance '%s' variable '%s'.", type_src_label, preset_label, inst->label, cwStringNullGuard(var_label) );
+        rc = cwLogError(kSyntaxErrorRC,"Unexpected missig value on %s preset '%s' proc instance '%s' variable '%s'.", type_src_label, preset_label, proc->label, cwStringNullGuard(var_label) );
         goto errLabel;
       }
       else
       {
-        bool is_var_cfg_type_fl = (vd = var_desc_find( inst->class_desc, var_label ))!=nullptr && cwIsFlag(vd->type,kCfgTFl);
+        bool is_var_cfg_type_fl = (vd = var_desc_find( proc->class_desc, var_label ))!=nullptr && cwIsFlag(vd->type,kCfgTFl);
         bool is_list_fl         = value->is_list();
         bool is_list_of_list_fl = is_list_fl && value->child_count() > 0 && value->child_ele(0)->is_list();
         bool parse_list_fl      = (is_list_fl && !is_var_cfg_type_fl) || (is_list_of_list_fl && is_var_cfg_type_fl);
@@ -239,12 +215,12 @@ namespace cw
         {
           // then each value in the list is assigned to the associated channel
           for(unsigned chIdx=0; chIdx<value->child_count(); ++chIdx)
-            if((rc = var_channelize( inst, var_label, kBaseSfxId, chIdx, value->child_ele(chIdx), kInvalidId, dummy )) != kOkRC )
+            if((rc = var_channelize( proc, var_label, kBaseSfxId, chIdx, value->child_ele(chIdx), kInvalidId, dummy )) != kOkRC )
               goto errLabel;
         }
         else // otherwise a single value was given
         {          
-          if((rc = var_channelize( inst, var_label, kBaseSfxId, kAnyChIdx, value, kInvalidId, dummy )) != kOkRC )
+          if((rc = var_channelize( proc, var_label, kBaseSfxId, kAnyChIdx, value, kInvalidId, dummy )) != kOkRC )
             goto errLabel;
         }
       }
@@ -253,16 +229,16 @@ namespace cw
       return rc;
     }
     
-    rc_t _preset_channelize_vars( instance_t* inst, const char* type_src_label, const char* preset_label, const object_t* preset_cfg )
+    rc_t _preset_channelize_vars( proc_t* proc, const char* type_src_label, const char* preset_label, const object_t* preset_cfg )
     {
       rc_t rc = kOkRC;
 
-      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), inst->label );
+      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), proc->label );
       
       // validate the syntax of the preset record
       if( !preset_cfg->is_dict() )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", preset_label, type_src_label, inst->class_desc->label );
+        rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", preset_label, type_src_label, proc->class_desc->label );
         goto errLabel;
       }
 
@@ -275,7 +251,7 @@ namespace cw
 
         //cwLogInfo("variable:%s",value_label);
         
-        if((rc = _var_channelize( inst, preset_label, type_src_label, var_label, value )) != kOkRC )
+        if((rc = _var_channelize( proc, preset_label, type_src_label, var_label, value )) != kOkRC )
           goto errLabel;
         
         
@@ -283,7 +259,7 @@ namespace cw
 
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(rc,"Apply %s preset failed on instance:%s class:%s preset:%s.", type_src_label, inst->label, inst->class_desc->label, preset_label );
+        rc = cwLogError(rc,"Apply %s preset failed on proc instance:%s class:%s preset:%s.", type_src_label, proc->label, proc->class_desc->label, preset_label );
 
       return rc;
     }
@@ -302,7 +278,7 @@ namespace cw
       return y;
     }
 
-    rc_t _set_var_from_dual_preset_scalar_scalar( instance_t* inst, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff, unsigned chIdx )
+    rc_t _set_var_from_dual_preset_scalar_scalar( proc_t* proc, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff, unsigned chIdx )
     {
       rc_t rc = kOkRC;
       object_t interped_value;
@@ -331,7 +307,7 @@ namespace cw
         goto errLabel;
       }
 
-      printf("%s:%s :",inst->label,var_label);
+      printf("%s:%s :",proc->label,var_label);
       
       switch( scalar_0->type->id )
       {
@@ -362,7 +338,7 @@ namespace cw
       }
 
       
-      if((rc = var_channelize( inst, var_label, kBaseSfxId, chIdx, &interped_value, kInvalidId, dummy )) != kOkRC )
+      if((rc = var_channelize( proc, var_label, kBaseSfxId, chIdx, &interped_value, kInvalidId, dummy )) != kOkRC )
       {
         rc = cwLogError(kInvalidArgRC,"Dual value preset application failed.");
         goto errLabel;
@@ -372,7 +348,7 @@ namespace cw
       return rc;
     }
 
-    rc_t _set_var_from_dual_preset_list_list( instance_t* inst, const char* var_label, const object_t* list_0, const object_t* list_1, double coeff )
+    rc_t _set_var_from_dual_preset_list_list( proc_t* proc, const char* var_label, const object_t* list_0, const object_t* list_1, double coeff )
     {
       rc_t rc = kOkRC;
       
@@ -380,38 +356,38 @@ namespace cw
         return cwLogError(kInvalidArgRC,"If two lists are to be applied as a dual preset they must be the same length.");
 
       for(unsigned chIdx=0; chIdx<list_0->child_count(); ++chIdx)
-        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,list_0->child_ele(chIdx),list_1->child_ele(chIdx),coeff,chIdx)) != kOkRC )
+        if((rc = _set_var_from_dual_preset_scalar_scalar(proc,var_label,list_0->child_ele(chIdx),list_1->child_ele(chIdx),coeff,chIdx)) != kOkRC )
           goto errLabel;
 
     errLabel:
       return rc;
     }
 
-    rc_t _set_var_from_dual_preset_scalar_list( instance_t* inst, const char* var_label, const object_t* scalar, const object_t* list, double coeff )
+    rc_t _set_var_from_dual_preset_scalar_list( proc_t* proc, const char* var_label, const object_t* scalar, const object_t* list, double coeff )
     {
       rc_t rc = kOkRC;
       for(unsigned chIdx=0; chIdx<list->child_count(); ++chIdx)
-        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,scalar,list->child_ele(chIdx),coeff,chIdx)) != kOkRC )
+        if((rc = _set_var_from_dual_preset_scalar_scalar(proc,var_label,scalar,list->child_ele(chIdx),coeff,chIdx)) != kOkRC )
           goto errLabel;
       
     errLabel:
       return rc;
     }
 
-    rc_t _set_var_from_dual_preset_list_scalar( instance_t* inst, const char* var_label, const object_t* list, const object_t* scalar, double coeff )
+    rc_t _set_var_from_dual_preset_list_scalar( proc_t* proc, const char* var_label, const object_t* list, const object_t* scalar, double coeff )
     {
       rc_t rc = kOkRC;
       for(unsigned chIdx=0; chIdx<list->child_count(); ++chIdx)
-        if((rc = _set_var_from_dual_preset_scalar_scalar(inst,var_label,list->child_ele(chIdx),scalar,coeff,chIdx)) != kOkRC )
+        if((rc = _set_var_from_dual_preset_scalar_scalar(proc,var_label,list->child_ele(chIdx),scalar,coeff,chIdx)) != kOkRC )
           goto errLabel;
       
     errLabel:
       return rc;
     }
     
-    rc_t _set_var_from_dual_preset_scalar_scalar( instance_t* inst, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff )
+    rc_t _set_var_from_dual_preset_scalar_scalar( proc_t* proc, const char* var_label, const object_t* scalar_0, const object_t* scalar_1, double coeff )
     {
-      return _set_var_from_dual_preset_scalar_scalar(inst,var_label,scalar_0,scalar_1,coeff,kAnyChIdx);
+      return _set_var_from_dual_preset_scalar_scalar(proc,var_label,scalar_0,scalar_1,coeff,kAnyChIdx);
     }
     
 
@@ -449,7 +425,7 @@ namespace cw
       
     }
     
-    rc_t _set_var_from_dual_preset( instance_t* inst, const char* var_label, const object_t* value_0, const object_t* value_1, double coeff )
+    rc_t _set_var_from_dual_preset( proc_t* proc, const char* var_label, const object_t* value_0, const object_t* value_1, double coeff )
     {
       rc_t rc = kOkRC;
 
@@ -461,7 +437,7 @@ namespace cw
       // if both values are lists then they must be the same length
       if( value_0->is_list() && value_1->is_list() )
       {
-        rc = _set_var_from_dual_preset_list_list( inst, var_label, value_0, value_1, coeff );
+        rc = _set_var_from_dual_preset_list_list( proc, var_label, value_0, value_1, coeff );
         goto errLabel;
       }
       else
@@ -469,7 +445,7 @@ namespace cw
         // if value_0 is a list and value_1 is a scalar
         if( value_0->is_list() )
         {
-          rc = _set_var_from_dual_preset_list_scalar( inst, var_label, value_0, value_1, coeff );
+          rc = _set_var_from_dual_preset_list_scalar( proc, var_label, value_0, value_1, coeff );
           goto errLabel;
         }
         else
@@ -477,12 +453,12 @@ namespace cw
           // if value_1 is a list and value_0 is a scalar
           if( value_1->is_list() )
           {
-            rc = _set_var_from_dual_preset_scalar_list( inst, var_label, value_0, value_1, coeff );
+            rc = _set_var_from_dual_preset_scalar_list( proc, var_label, value_0, value_1, coeff );
             goto errLabel;
           }
           else // both values are scalars
           {
-            rc = _set_var_from_dual_preset_scalar_scalar( inst, var_label, value_0, value_1, coeff );
+            rc = _set_var_from_dual_preset_scalar_scalar( proc, var_label, value_0, value_1, coeff );
             goto errLabel;
           }
         }
@@ -492,14 +468,14 @@ namespace cw
       return rc;
     }
     
-    rc_t _multi_preset_channelize_vars( instance_t* inst, const char* type_src_label, const char** presetLabelA, const object_t** preset_cfgA, unsigned presetN, double coeff )
+    rc_t _multi_preset_channelize_vars( proc_t* proc, const char* type_src_label, const char** presetLabelA, const object_t** preset_cfgA, unsigned presetN, double coeff )
     {
       rc_t rc = kOkRC;
 
       const char* preset_label_0 = "<None>";
       const char* preset_label_1 = "<None>";
 
-      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), inst->label );
+      //cwLogInfo("Channelizing '%s' preset %i vars for '%s'.",type_src_label, preset_cfg==nullptr ? 0 : preset_cfg->child_count(), proc->label );
 
       if( presetN < 2 )
       {
@@ -520,7 +496,7 @@ namespace cw
       for(unsigned i=0; i<presetN; ++i)
         if( !preset_cfgA[i]->is_dict() )
         {
-          rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", presetLabelA[i], type_src_label, inst->class_desc->label );
+          rc = cwLogError(kSyntaxErrorRC,"The preset record '%s' on %s '%s' is not a dictionary.", presetLabelA[i], type_src_label, proc->class_desc->label );
           goto errLabel;
         }
 
@@ -535,7 +511,7 @@ namespace cw
 
         if( value_0 == nullptr && value_1 == nullptr )
         {
-          rc = cwLogError(kSyntaxErrorRC,"Unexpected missig values on %s preset '%s' instance '%s' variable '%s'.", type_src_label, presetLabelA[0], inst->label, cwStringNullGuard(var_label) );
+          rc = cwLogError(kSyntaxErrorRC,"Unexpected missig values on %s preset '%s' proc instance '%s' variable '%s'.", type_src_label, presetLabelA[0], proc->label, cwStringNullGuard(var_label) );
           goto errLabel;
         }
 
@@ -543,7 +519,7 @@ namespace cw
         {
           cwLogWarning("The preset variable '%s' was not found for the preset: '%s'. Falling back to single value assign.",cwStringNullGuard(var_label),cwStringNullGuard(presetLabelA[0]));
 
-          rc = _var_channelize( inst, preset_label_1, "dual class", var_label, value_1 );
+          rc = _var_channelize( proc, preset_label_1, "dual class", var_label, value_1 );
           goto errLabel;
         }
         
@@ -551,12 +527,12 @@ namespace cw
         {
           cwLogWarning("The preset variable '%s' was not found for the preset: '%s'. Falling back to single value assign.",cwStringNullGuard(var_label),cwStringNullGuard(presetLabelA[1]));
           
-          rc = _var_channelize( inst, preset_label_0, "dual class", var_label, value_0 );
+          rc = _var_channelize( proc, preset_label_0, "dual class", var_label, value_0 );
           goto errLabel;
         }
 
 
-        if((rc = _set_var_from_dual_preset( inst, var_label, value_0, value_1, coeff )) != kOkRC )
+        if((rc = _set_var_from_dual_preset( proc, var_label, value_0, value_1, coeff )) != kOkRC )
         {
           rc = cwLogError(rc,"Multi preset application failed on variable:%s.",cwStringNullGuard(var_label));
           goto errLabel;
@@ -565,13 +541,13 @@ namespace cw
 
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(rc,"Apply %s multi-preset failed on instance:%s class:%s presetA:%s presetB:%s.", type_src_label, inst->label, inst->class_desc->label, preset_label_0, preset_label_1 );
+        rc = cwLogError(rc,"Apply %s multi-preset failed on proc instance:%s class:%s presetA:%s presetB:%s.", type_src_label, proc->label, proc->class_desc->label, preset_label_0, preset_label_1 );
 
       return rc;
     }
 
 
-    rc_t _class_multi_preset_channelize_vars(instance_t* inst, const char** class_preset_labelA, unsigned presetN, double coeff )
+    rc_t _class_multi_preset_channelize_vars(proc_t* proc, const char** class_preset_labelA, unsigned presetN, double coeff )
     {
       rc_t            rc = kOkRC;
       const object_t* presetCfgA[ presetN ];
@@ -585,15 +561,15 @@ namespace cw
           const preset_t* pr;
           
           // locate the requestd preset record
-          if((pr = class_preset_find(inst->class_desc, class_preset_labelA[i])) == nullptr )
+          if((pr = class_preset_find(proc->class_desc, class_preset_labelA[i])) == nullptr )
           {
-            rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the instance '%s'.", class_preset_labelA[i], inst->label);
+            rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the proc instance '%s'.", class_preset_labelA[i], proc->label);
             goto errLabel;
           }
 
           if( pr->cfg == nullptr )
           {
-            rc = cwLogError(kInvalidIdRC,"The value of preset '%s' was empty in instance '%s'.", class_preset_labelA[i], inst->label);
+            rc = cwLogError(kInvalidIdRC,"The value of preset '%s' was empty in proc instance '%s'.", class_preset_labelA[i], proc->label);
             goto errLabel;            
           }
 
@@ -612,12 +588,12 @@ namespace cw
           
         case 1:
           // only one valid preset was located - apply it directly
-          rc = _preset_channelize_vars( inst, "class", presetLabelA[0], presetCfgA[0]);
+          rc = _preset_channelize_vars( proc, "class", presetLabelA[0], presetCfgA[0]);
           break;
           
         default:
           // more than one preset was located - apply it's interpolated values
-          rc = _multi_preset_channelize_vars( inst, "class", presetLabelA, presetCfgA, presetCfgN, coeff);
+          rc = _multi_preset_channelize_vars( proc, "class", presetLabelA, presetCfgA, presetCfgN, coeff);
       }
       
       
@@ -626,7 +602,7 @@ namespace cw
       
     }
     
-    rc_t _class_preset_channelize_vars( instance_t* inst, const char* preset_label )
+    rc_t _class_preset_channelize_vars( proc_t* proc, const char* preset_label )
     {
       rc_t            rc = kOkRC;
       const preset_t* pr;
@@ -635,31 +611,31 @@ namespace cw
         return kOkRC;
       
       // locate the requestd preset record
-      if((pr = class_preset_find(inst->class_desc, preset_label)) == nullptr )
+      if((pr = class_preset_find(proc->class_desc, preset_label)) == nullptr )
       {
-        rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the instance '%s'.", preset_label, inst->label);
+        rc = cwLogError(kInvalidIdRC,"The preset '%s' could not be found for the proc instance '%s'.", preset_label, proc->label);
         goto errLabel;
       }
       
-      rc = _preset_channelize_vars( inst, "class", preset_label, pr->cfg);
+      rc = _preset_channelize_vars( proc, "class", preset_label, pr->cfg);
       
     errLabel:                  
       return rc;
     }
 
 
-    rc_t _class_apply_presets( instance_t* inst, const object_t* preset_labels )
+    rc_t _class_apply_presets( proc_t* proc, const object_t* preset_labels )
     {
       rc_t        rc = kOkRC;
       const char* s  = nullptr;
       
       // if preset_labels is a string
       if( preset_labels->is_string() && preset_labels->value(s)==kOkRC )
-        return _class_preset_channelize_vars(inst,s);
+        return _class_preset_channelize_vars(proc,s);
 
       // if the preset_labels is not a list
       if( !preset_labels->is_list() )
-        rc = cwLogError(kSyntaxErrorRC,"The preset list on instance '%s' is neither a list nor a string.",inst->label);
+        rc = cwLogError(kSyntaxErrorRC,"The preset list on proc instance '%s' is neither a list nor a string.",proc->label);
       else        
       {
         // preset_labels is a list.
@@ -672,12 +648,12 @@ namespace cw
           // verify that the label is a strng
           if( !label_obj->is_string() || label_obj->value(s) != kOkRC )
           {
-            rc = cwLogError(kSyntaxErrorRC,"The preset list does not contain string on instance '%s'.",inst->label);
+            rc = cwLogError(kSyntaxErrorRC,"The preset list does not contain string on proc instance '%s'.",proc->label);
             goto errLabel;
           }
 
           // apply a preset label
-          if((rc = _class_preset_channelize_vars( inst, s)) != kOkRC )
+          if((rc = _class_preset_channelize_vars( proc, s)) != kOkRC )
             goto errLabel;          
         }
       }
@@ -689,14 +665,14 @@ namespace cw
                                  
     
 
-    rc_t _proc_inst_args_channelize_vars( instance_t* inst, const char* arg_label, const object_t* arg_cfg )
+    rc_t _proc_inst_args_channelize_vars( proc_t* proc, const char* arg_label, const object_t* arg_cfg )
     {
       rc_t rc = kOkRC;
       
       if( arg_cfg == nullptr )
         return rc;
 
-      return _preset_channelize_vars( inst, "instance", arg_label, arg_cfg );
+      return _preset_channelize_vars( proc, "proc instance", arg_label, arg_cfg );
       
     }
 
@@ -736,8 +712,8 @@ namespace cw
 
     typedef struct proc_inst_parse_statestr
     {
-      const char*     inst_label;       // 
-      const char*     inst_clas_label;  //
+      const char*     proc_label;       // 
+      const char*     proc_clas_label;  //
       const char*     arg_label;        //
       const object_t* preset_labels;    //
       const object_t* arg_cfg;          //
@@ -867,7 +843,7 @@ namespace cw
       // if a literal proc sfx_id was given then use it otherwise use the default base-sfx-id (0)
       unsigned sfx_id = src_proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_proc_ele.base_sfx_id;
       unsigned n;
-      for(n=0; instance_find(net, src_proc_ele.label, sfx_id ) != nullptr; ++n )
+      for(n=0; proc_find(net, src_proc_ele.label, sfx_id ) != nullptr; ++n )
         sfx_id += 1;
 
       if( n == 0 )
@@ -884,15 +860,15 @@ namespace cw
     rc_t _calc_src_var_ele_count(network_t& net, const in_ele_t& src_proc_ele, const in_ele_t& src_var_ele, unsigned& cnt_ref)
     {
       rc_t              rc          = kOkRC;
-      instance_t*       src_proc    = nullptr;
+      proc_t*       src_proc    = nullptr;
       unsigned          proc_sfx_id = src_proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_proc_ele.base_sfx_id;
 
       cnt_ref = 0;
 
       // locate the parent proc of this var
-      if((src_proc = instance_find(net,src_proc_ele.label,proc_sfx_id)) == nullptr )
+      if((src_proc = proc_find(net,src_proc_ele.label,proc_sfx_id)) == nullptr )
       {
-        cwLogError(kSyntaxErrorRC,"The src-proc instance '%s:%i' could not be found.",cwStringNullGuard(src_proc_ele.label),proc_sfx_id);
+        cwLogError(kSyntaxErrorRC,"The src-proc proc instance '%s:%i' could not be found.",cwStringNullGuard(src_proc_ele.label),proc_sfx_id);
         goto errLabel;
       }
       else
@@ -921,7 +897,7 @@ namespace cw
     // If the in-var is iterating then the count of iterations must be controlled by exactly one
     // of the 3 parts of the in-stmt: in-var,src_proc, or src_var.  This function determines
     // which element is used to determine the iteration count.
-    rc_t _determine_in_stmt_iter_count_ctl_ele(network_t& net, instance_t* inst, in_stmt_t& in_stmt )
+    rc_t _determine_in_stmt_iter_count_ctl_ele(network_t& net, proc_t* proc, in_stmt_t& in_stmt )
     {
       assert( in_stmt.in_var_ele.is_iter_fl );
       rc_t rc = kOkRC;
@@ -1008,7 +984,7 @@ namespace cw
       return rc;
     }
     
-    rc_t _determine_in_stmt_iter_count( network_t& net,instance_t* inst, in_stmt_t& in_stmt )
+    rc_t _determine_in_stmt_iter_count( network_t& net,proc_t* proc, in_stmt_t& in_stmt )
     {
       rc_t rc = kOkRC;
 
@@ -1095,26 +1071,26 @@ namespace cw
 
 
     // Recursively search the tree of networks rooted on 'net' for the
-    // network named 'net_inst_label'.
-    network_t*  _find_labeled_network( network_t& net, const char* net_inst_label )
+    // network named 'net_proc_label'.
+    network_t*  _find_labeled_network( network_t& net, const char* net_proc_label )
     {
       network_t* labeled_net = nullptr;
 
-      // for each instance in the network
+      // for each proc instance in the network
       for(unsigned i=0; i<net.proc_arrayN && labeled_net==nullptr; ++i)
       {
-        instance_t* inst =  net.proc_array[i];
+        proc_t* proc =  net.proc_array[i];
           
-        // if this instance has an  internal network
-        if( inst->internal_net != nullptr )
+        // if this proc instance has an  internal network
+        if( proc->internal_net != nullptr )
         {
           // if the name of the network matches the key ...
-          if( textIsEqual(inst->label,net_inst_label) )            
-            labeled_net = inst->internal_net; // .. we are done
+          if( textIsEqual(proc->label,net_proc_label) )            
+            labeled_net = proc->internal_net; // .. we are done
           else
           {
             // ... otherwise recurse
-            labeled_net = _find_labeled_network(*inst->internal_net,net_inst_label);
+            labeled_net = _find_labeled_network(*proc->internal_net,net_proc_label);
           }
         }
         
@@ -1123,7 +1099,7 @@ namespace cw
     }
 
     // Set  'in_stmt.src_net' based on 'in_stmt.src_net_label'
-    rc_t _locate_src_net(network_t& net,instance_t* inst, in_stmt_t& in_stmt)
+    rc_t _locate_src_net(network_t& net,proc_t* proc, in_stmt_t& in_stmt)
     {
       rc_t rc = kOkRC;
       network_t* src_net = nullptr;
@@ -1135,10 +1111,10 @@ namespace cw
       else
       {        
         if( textIsEqual(in_stmt.src_net_label,"_") )
-          src_net = &inst->ctx->net;
+          src_net = &proc->ctx->net;
         else
         {
-          if((src_net = _find_labeled_network(inst->ctx->net,in_stmt.src_net_label)) == nullptr )
+          if((src_net = _find_labeled_network(proc->ctx->net,in_stmt.src_net_label)) == nullptr )
           {
             rc = cwLogError(kSyntaxErrorRC,"The source net '%s' was not found.",cwStringNullGuard(in_stmt.src_net_label));
             goto errLabel;
@@ -1155,7 +1131,7 @@ namespace cw
     }
 
 
-    rc_t _create_in_stmt( network_t& net, instance_t* inst, in_stmt_t& in_stmt, const char* in_var_str, const char* src_proc_var_str )
+    rc_t _create_in_stmt( network_t& net, proc_t* proc, in_stmt_t& in_stmt, const char* in_var_str, const char* src_proc_var_str )
     {
       rc_t     rc          = kOkRC;
       unsigned src_char_cnt = 0;
@@ -1209,14 +1185,14 @@ namespace cw
         }
 
         // get the var class desc. for the in-var
-        if(( in_stmt.in_var_desc = var_desc_find(inst->class_desc,in_stmt.in_var_ele.label)) == nullptr )
+        if(( in_stmt.in_var_desc = var_desc_find(proc->class_desc,in_stmt.in_var_ele.label)) == nullptr )
         {
           rc = cwLogError(kEleNotFoundRC,"Unable to locate the var class desc for the in-var from '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label));
           goto errLabel;
         }
 
         // get the src net
-        if((rc = _locate_src_net(net,inst,in_stmt)) != kOkRC )
+        if((rc = _locate_src_net(net,proc,in_stmt)) != kOkRC )
         {
           rc = cwLogError(rc,"Unable to locate the src-net '%s'.",cwStringNullGuard(in_stmt.src_net_label));
           goto errLabel;
@@ -1232,7 +1208,7 @@ namespace cw
 
         // if the src-proc is not iterating and the src-proc was not given a literal sfx-id
         if( in_stmt.src_proc_ele.is_iter_fl==false && in_stmt.src_proc_ele.base_sfx_id==kInvalidId && in_stmt.src_net==&net)
-          in_stmt.src_proc_ele.base_sfx_id = inst->label_sfx_id;
+          in_stmt.src_proc_ele.base_sfx_id = proc->label_sfx_id;
 
         // if this is not an iterating in-stmt ... 
         if( !in_stmt.in_var_ele.is_iter_fl )
@@ -1242,14 +1218,14 @@ namespace cw
         else
         {
           // if the in-stmt is iterating then determine the in-stmt element which controls the iteration count
-          if((rc = _determine_in_stmt_iter_count_ctl_ele(net,inst,in_stmt)) != kOkRC || in_stmt.iter_cnt_ctl_ele==nullptr)
+          if((rc = _determine_in_stmt_iter_count_ctl_ele(net,proc,in_stmt)) != kOkRC || in_stmt.iter_cnt_ctl_ele==nullptr)
           {
             rc = cwLogError(rc,"Unable to determine the iter count control ele.");
             goto errLabel;
           }
 
           // if the in-stmt is iterating then determine the iteration count
-          if((rc = _determine_in_stmt_iter_count(net,inst,in_stmt)) != kOkRC )
+          if((rc = _determine_in_stmt_iter_count(net,proc,in_stmt)) != kOkRC )
           {
             cwLogError(rc,"Unable to determine the in-stmt iteration count.");
             goto errLabel;
@@ -1264,15 +1240,15 @@ namespace cw
       return rc;      
     }
 
-    const variable_t* _find_proxy_var( const char* procInstLabel, const char* varLabel, const variable_t* proxyVarL )
+    const variable_t* _find_proxy_var( const char* procProcLabel, const char* varLabel, const variable_t* proxyVarL )
     {
       for(const variable_t* proxyVar=proxyVarL; proxyVar!=nullptr; proxyVar=proxyVar->var_link)
-        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procInstLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
+        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procProcLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
           return proxyVar;
       return nullptr;
     }
     
-    rc_t _parse_in_list( network_t& net, instance_t* inst, variable_t* proxyVarL, proc_inst_parse_state_t& pstate )
+    rc_t _parse_in_list( network_t& net, proc_t* proc, variable_t* proxyVarL, proc_inst_parse_state_t& pstate )
     {
       rc_t            rc     = kOkRC;
       
@@ -1281,7 +1257,7 @@ namespace cw
       
       if( !pstate.in_dict->is_dict() )
       {
-        cwLogError(kSyntaxErrorRC,"The 'in' dict in instance '%s' is not a valid dictionary.",inst->label);
+        cwLogError(kSyntaxErrorRC,"The 'in' dict in proc instance '%s' is not a valid dictionary.",proc->label);
         goto errLabel;
       }
 
@@ -1314,7 +1290,7 @@ namespace cw
         }
 
         // 
-        if((rc= _create_in_stmt(net, inst, in_stmt, in_var_str, src_proc_var_str )) != kOkRC )
+        if((rc= _create_in_stmt(net, proc, in_stmt, in_var_str, src_proc_var_str )) != kOkRC )
         {
           cwLogError(rc,"Parse failed on the in-connection '%s:%s'.",cwStringNullGuard(in_var_str),cwStringNullGuard(src_proc_var_str));
           goto errLabel;
@@ -1326,7 +1302,7 @@ namespace cw
           const variable_t* proxy_var;
           
           // a variable cannot be in the 'in' list if it is used a a subnet variable
-          if((proxy_var = _find_proxy_var(inst->label, in_stmt.in_var_ele.label, proxyVarL)) != nullptr )
+          if((proxy_var = _find_proxy_var(proc->label, in_stmt.in_var_ele.label, proxyVarL)) != nullptr )
           {
             rc = cwLogError(kSyntaxErrorRC,"The variable:'%s' cannot be used as the in-var of an 'in' statement if it is a subnet variable: '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label),cwStringNullGuard(proxy_var->label));
             goto errLabel;
@@ -1337,7 +1313,7 @@ namespace cw
           {
             variable_t* dum = nullptr;        
 
-            if((rc = var_create( inst, in_stmt.in_var_desc->label,
+            if((rc = var_create( proc, in_stmt.in_var_desc->label,
                                  in_stmt.in_var_ele.base_sfx_id + i,
                                  kInvalidId,
                                  kAnyChIdx,
@@ -1357,39 +1333,38 @@ namespace cw
       return rc;      
     }
 
-    // This function is used to create the variables on procs
-    // inside subnets which are represented by interface variables
-    // on the subnet wrapper.
-    // 'inst' is a proc on the subnet's internal proc list
+    // This function is used to create the variables on subnet procs
+    // which are represented by interface variables on the subnet proxy (wrapper) proc.
+    // 'proc' is a proc on the subnet's internal proc list
     // 'wrap_varL' is a list of all the variables on the wrapper proc.
-    // These wrapper variables mirror variables on some of the internal subnet proc's.
-    // The function finds the variables in wrap_varL that mirror
-    // variables in 'inst' and instantiates them.  It then connects the wrapper
-    // variable to the proc-inst variable for input variables or
-    // proc-inst variable to the wrapper variable for output variables.
-    rc_t  _create_proxied_vars( instance_t* inst, variable_t* wrap_varL )
+    // These wrapper variables mirror variables on the internal subnet proc's.
+    // This function finds the variables in wrap_varL that mirror
+    // variables in 'proc' and instantiates them.  
+    rc_t  _create_proxied_vars( proc_t* proc, variable_t* wrap_varL )
     {
       rc_t rc = kOkRC;
-      
+
+      // for each proxy var
       for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link )
       {
-        // if this wrap_var is on this proc (inst->label)
-        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,inst->label) )
+        // if this proxy var is on this internal proc (proc->label)
+        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,proc->label) )
         {
           
           variable_t* var;
-
-          if((rc = var_create( inst, wrap_var->varDesc->proxyVarLabel, wrap_var->label_sfx_id, kInvalidId, wrap_var->chIdx, nullptr, kInvalidTFl, var )) != kOkRC )
+          
+          // create the proxied var
+          if((rc = var_create( proc, wrap_var->varDesc->proxyVarLabel, wrap_var->label_sfx_id, kInvalidId, wrap_var->chIdx, nullptr, kInvalidTFl, var )) != kOkRC )
           {
-            rc = cwLogError(rc,"Subnet variable creation failed for %s:%s on wrapper variable:%s:%s.",cwStringNullGuard(wrap_var->varDesc->proxyProcLabel),cwStringNullGuard(wrap_var->varDesc->proxyVarLabel),cwStringNullGuard(wrap_var->inst->label),cwStringNullGuard(wrap_var->label));
+            rc = cwLogError(rc,"Subnet variable creation failed for %s:%s on wrapper variable:%s:%s.",cwStringNullGuard(wrap_var->varDesc->proxyProcLabel),cwStringNullGuard(wrap_var->varDesc->proxyVarLabel),cwStringNullGuard(wrap_var->proc->label),cwStringNullGuard(wrap_var->label));
             goto errLabel;
           }
 
-          //printf("Proxy matched: %s %s %s : flags:%i.\n",inst->label, wrap_var->varDesc->proxyVarLabel, wrap_var->label,wrap_var->varDesc->flags );
+          //printf("Proxy matched: %s %s %s : flags:%i.\n",proc->label, wrap_var->varDesc->proxyVarLabel, wrap_var->label,wrap_var->varDesc->flags );
 
           var->flags |= kProxiedVarFl;
           
-          if( cwIsFlag(wrap_var->varDesc->flags,kSubnetOutVarFl) )
+          if( cwIsFlag(wrap_var->varDesc->flags,kSubnetOutVarDescFl) )
             var->flags |= kProxiedOutVarFl;
         }
       }
@@ -1398,42 +1373,42 @@ namespace cw
       return rc;
     }
 
-    variable_t* _find_wrap_var( variable_t* wrap_varL, variable_t* var )
+    variable_t* _find_proxy_var( variable_t* wrap_varL, variable_t* var )
     {
       for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link)
-        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,var->inst->label) && textIsEqual(wrap_var->varDesc->proxyVarLabel,var->label) && (wrap_var->label_sfx_id==var->label_sfx_id) )
+        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,var->proc->label) && textIsEqual(wrap_var->varDesc->proxyVarLabel,var->label) && (wrap_var->label_sfx_id==var->label_sfx_id) )
           return wrap_var;
         
       return nullptr;
     }
     
-    rc_t _connect_wrapped_vars( instance_t* inst, variable_t* wrap_varL )
+    rc_t _connect_proxy_vars( proc_t* proc, variable_t* wrap_varL )
     {
       rc_t rc = kOkRC;
-      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
       {
         if( cwIsFlag(var->flags,kProxiedVarFl) )
         {
           variable_t* wrap_var;
-          if((wrap_var = _find_wrap_var(wrap_varL,var)) == nullptr )
+          if((wrap_var = _find_proxy_var(wrap_varL,var)) == nullptr )
           {
-            rc = cwLogError(kEleNotFoundRC,"The wrapped variable '%s:%i' not found on '%s:%i'.",var->label,var->label_sfx_id,inst->label,inst->label_sfx_id);
+            rc = cwLogError(kEleNotFoundRC,"The wrapped variable '%s:%i' not found on '%s:%i'.",var->label,var->label_sfx_id,proc->label,proc->label_sfx_id);
             goto errLabel;
           }
           
           if( cwIsFlag(var->flags,kProxiedOutVarFl) )
           {
             //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
-            //       var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id,
-            //       wrap_var->inst->label,wrap_var->inst->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id );
+            //       var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id,
+            //       wrap_var->proc->label,wrap_var->proc->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id );
             
             var_connect(var,wrap_var);
           }
           else
           {
             //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
-            //       wrap_var->inst->label,wrap_var->inst->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id,
-            //       var->inst->label,var->inst->label_sfx_id,var->label,var->label_sfx_id );
+            //       wrap_var->proc->label,wrap_var->proc->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id,
+            //       var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id );
             
             var_connect(wrap_var,var);
           }          
@@ -1443,23 +1418,22 @@ namespace cw
       errLabel:
         return rc;
     }
-    
 
-    
-    bool _is_var_inst_already_created( instance_t* inst, const char* var_label, const proc_inst_parse_state_t& pstate )
+    // Check if the var named 'label' already exists in 'proc->varL'.
+    bool _is_var_proc_already_created( proc_t* proc, const char* var_label, const proc_inst_parse_state_t& pstate )
     {
       for(unsigned i=0; i<pstate.in_arrayN; ++i)
         if( textIsEqual(pstate.in_array[i].in_var_ele.label,var_label) && pstate.in_array[i].create_in_fl )
           return true;
 
-      for(variable_t* var=inst->varL; var!=nullptr; var=var->var_link)
+      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
         if( textIsEqual(var->label,var_label) )
           return true;
       
       return false;
     }
 
-    rc_t _connect_in_vars(network_t& net, instance_t* inst, const proc_inst_parse_state_t& pstate)
+    rc_t _connect_in_vars(network_t& net, proc_t* proc, const proc_inst_parse_state_t& pstate)
     {
       rc_t rc = kOkRC;
       
@@ -1471,7 +1445,7 @@ namespace cw
         {
           variable_t* in_var    = nullptr;
           network_t*  src_net   = in_stmt.src_net;
-          instance_t* src_proc  = nullptr;
+          proc_t* src_proc  = nullptr;
           variable_t* src_var   = nullptr;
 
           const char* in_var_label   = in_stmt.in_var_ele.label;
@@ -1510,14 +1484,14 @@ namespace cw
             src_var_sfx_id += j;
           
           // locate input value
-          if((rc = var_find( inst, in_var_label, in_var_sfx_id, kAnyChIdx, in_var )) != kOkRC )
+          if((rc = var_find( proc, in_var_label, in_var_sfx_id, kAnyChIdx, in_var )) != kOkRC )
           {
             rc = cwLogError(rc,"The in-var '%s:%i' was not found.", in_stmt.in_var_ele.label, in_stmt.in_var_ele.base_sfx_id + j);
             goto errLabel;        
           }
           
-          // locate source instance 
-          if((src_proc = instance_find(*src_net, src_proc_label, src_proc_sfx_id )) == nullptr )
+          // locate source proc instance 
+          if((src_proc = proc_find(*src_net, src_proc_label, src_proc_sfx_id )) == nullptr )
           {
             rc = cwLogError(kSyntaxErrorRC,"The src-proc '%s:%i' was not found.", in_stmt.src_proc_ele.label, src_proc_sfx_id );
             goto errLabel;
@@ -1551,7 +1525,7 @@ namespace cw
 
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(rc,"Connection failed on proc '%s:%i'.",inst->label,inst->label_sfx_id);
+        rc = cwLogError(rc,"Connection failed on proc '%s:%i'.",proc->label,proc->label_sfx_id);
       return rc;
     }
       
@@ -1564,23 +1538,23 @@ namespace cw
       // validate the syntax of the proc_inst_cfg pair
       if( !_is_non_null_pair(proc_inst_cfg))
       {
-        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. is not a valid pair. No instance label could be parsed.");
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. is not a valid pair. No proc instance label could be parsed.");
         goto errLabel;
       }
       
-      pstate.inst_label = proc_inst_cfg->pair_label();
+      pstate.proc_label = proc_inst_cfg->pair_label();
 
-      // verify that the instance label is unique
-      if( instance_find(net,pstate.inst_label,sfx_id) != nullptr )
+      // verify that the proc instance label is unique
+      if( proc_find(net,pstate.proc_label,sfx_id) != nullptr )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance label '%s:%i' has already been used.",pstate.inst_label,sfx_id);
+        rc = cwLogError(kSyntaxErrorRC,"The proc proc instance label '%s:%i' has already been used.",pstate.proc_label,sfx_id);
         goto errLabel;
       }
       
-      // get the instance class label
-      if((rc = proc_inst_cfg->pair_value()->getv("class",pstate.inst_clas_label)) != kOkRC )
+      // get the proc instance class label
+      if((rc = proc_inst_cfg->pair_value()->getv("class",pstate.proc_clas_label)) != kOkRC )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. %s is missing: 'type'.",pstate.inst_label);
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. %s is missing: 'type'.",pstate.proc_label);
         goto errLabel;        
       }
       
@@ -1591,11 +1565,11 @@ namespace cw
                                                      "preset",   pstate.preset_labels,
                                                      "log",      pstate.log_labels )) != kOkRC )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The instance cfg. '%s' missing: 'type'.",pstate.inst_label);
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. '%s' missing: 'type'.",pstate.proc_label);
         goto errLabel;        
       }
 
-      // if an argument dict was given in the instance cfg
+      // if an argument dict was given in the proc instance cfg
       if( arg_dict != nullptr  )
       {
         bool rptErrFl = true;
@@ -1603,7 +1577,7 @@ namespace cw
         // verify the arg. dict is actually a dict.
         if( !arg_dict->is_dict() )
         {
-          cwLogError(kSyntaxErrorRC,"The instance argument dictionary on instance '%s' is not a dictionary.",pstate.inst_label);
+          cwLogError(kSyntaxErrorRC,"The proc instance argument dictionary on proc instance '%s' is not a dictionary.",pstate.proc_label);
           goto errLabel;
         }
         
@@ -1621,11 +1595,11 @@ namespace cw
           // if an explicit arg. label was given but it was not found
           if( rptErrFl )
           {
-            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on instance cfg. '%s'.",pstate.arg_label,pstate.inst_label);
+            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on proc instance cfg. '%s'.",pstate.arg_label,pstate.proc_label);
             goto errLabel;
           }
 
-          // no explicit arg. label was given - make arg_dict the instance arg cfg.
+          // no explicit arg. label was given - make arg_dict the proc instance arg cfg.
           pstate.arg_cfg = arg_dict;
           pstate.arg_label = nullptr;
         }        
@@ -1633,7 +1607,7 @@ namespace cw
 
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on instance: '%s'.", cwStringNullGuard(pstate.inst_label) );
+        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on proc instance: '%s'.", cwStringNullGuard(pstate.proc_label) );
       
       return rc;
     }
@@ -1645,7 +1619,7 @@ namespace cw
       mem::release(pstate.in_array);
     }
 
-    // Count of proc instances which exist in the network with a given class.
+    // Count of proc proc instances which exist in the network with a given class.
     unsigned _poly_copy_count( const network_t& net, const char* proc_clas_label )
     {
       unsigned n = 0;
@@ -1656,153 +1630,153 @@ namespace cw
       return n;
     }
 
-    rc_t _create_instance( flow_t*         p,
-                           const object_t* proc_inst_cfg,
-                           unsigned        sfx_id,
-                           network_t&      net,
-                           variable_t*     proxyVarL,
-                           instance_t*&    inst_ref )
+    rc_t _create_proc_instance( flow_t*         p,
+                                const object_t* proc_inst_cfg,
+                                unsigned        sfx_id,
+                                network_t&      net,
+                                variable_t*     proxyVarL,
+                                proc_t*&    proc_ref )
     {
       rc_t                    rc         = kOkRC;
       proc_inst_parse_state_t pstate     = {};
-      instance_t*             inst       = nullptr;
+      proc_t*             proc       = nullptr;
       class_desc_t*           class_desc = nullptr;
 
-      inst_ref = nullptr;
+      proc_ref = nullptr;
 
-      // parse the instance configuration 
+      // parse the proc instance configuration 
       if((rc = _parse_proc_inst_cfg( net, proc_inst_cfg, sfx_id, pstate )) != kOkRC )
         goto errLabel;
       
       // locate the proc class desc
-      if(( class_desc = class_desc_find(p,pstate.inst_clas_label)) == nullptr )
+      if(( class_desc = class_desc_find(p,pstate.proc_clas_label)) == nullptr )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pstate.inst_clas_label));
+        rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pstate.proc_clas_label));
         goto errLabel;
       }
 
-      // if the poly instance count has been exceeded for this proc inst class ...
-      if(class_desc->polyLimitN > 0 && _poly_copy_count(net,pstate.inst_clas_label) >= class_desc->polyLimitN )
+      // if the poly proc instance count has been exceeded for this proc proc class ...
+      if(class_desc->polyLimitN > 0 && _poly_copy_count(net,pstate.proc_clas_label) >= class_desc->polyLimitN )
       {
         // ... then silently skip this instantiation
-        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.inst_label,sfx_id);
+        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.proc_label,sfx_id);
         goto errLabel;
       }
       
-      // instantiate the instance
-      inst = mem::allocZ<instance_t>();
+      // instantiate the proc instance
+      proc = mem::allocZ<proc_t>();
 
-      inst->ctx           = p;
-      inst->label         = mem::duplStr(pstate.inst_label);
-      inst->label_sfx_id  = sfx_id;
-      inst->proc_cfg      = proc_inst_cfg->pair_value();
-      inst->arg_label     = pstate.arg_label;
-      inst->arg_cfg       = pstate.arg_cfg;
-      inst->class_desc    = class_desc;
-      inst->net           = &net;
+      proc->ctx           = p;
+      proc->label         = mem::duplStr(pstate.proc_label);
+      proc->label_sfx_id  = sfx_id;
+      proc->proc_cfg      = proc_inst_cfg->pair_value();
+      proc->arg_label     = pstate.arg_label;
+      proc->arg_cfg       = pstate.arg_cfg;
+      proc->class_desc    = class_desc;
+      proc->net           = &net;
 
-      // parse the in-list ,fill in pstate.in_array, and create var instances for var's referenced by in-list
-      if((rc = _parse_in_list( net, inst, proxyVarL, pstate )) != kOkRC )
+      // parse the in-list ,fill in pstate.in_array, and create var proc instances for var's referenced by in-list
+      if((rc = _parse_in_list( net, proc, proxyVarL, pstate )) != kOkRC )
       {
-        rc = cwLogError(rc,"in-list parse failed on proc instance '%s:%i'.",cwStringNullGuard(inst->label),sfx_id);
+        rc = cwLogError(rc,"in-list parse failed on proc proc instance '%s:%i'.",cwStringNullGuard(proc->label),sfx_id);
         goto errLabel;
       }
 
-      // create the vars that are connected to the wrapper proxy vars
-      if((rc = _create_proxied_vars( inst, proxyVarL )) != kOkRC )
+      // create the vars that are connected to the proxy vars
+      if((rc = _create_proxied_vars( proc, proxyVarL )) != kOkRC )
       {
-        rc = cwLogError(rc,"Proxy vars create failed on proc instance '%s:%i'.",cwStringNullGuard(inst->label),sfx_id);
+        rc = cwLogError(rc,"Proxy vars create failed on proc proc instance '%s:%i'.",cwStringNullGuard(proc->label),sfx_id);
         goto errLabel;
       }
 
       // Instantiate all the variables in the class description - that were not already created in _parse_in_list()
       for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
-        if( !_is_var_inst_already_created( inst, vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
+        if( !_is_var_proc_already_created( proc, vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
         {
           variable_t* var = nullptr;        
-          if((rc = var_create( inst, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, kInvalidTFl, var )) != kOkRC )
+          if((rc = var_create( proc, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, kInvalidTFl, var )) != kOkRC )
             goto errLabel;
         }
 
-      // All the variables that can be used by this instance have now been created
+      // All the variables that can be used by this proc instance have now been created
       // and the chIdx of each variable is set to 'any'.
       
       // If a 'preset' field was included in the class cfg then apply the specified class preset
       if( pstate.preset_labels != nullptr )      
-        if((rc = _class_apply_presets(inst, pstate.preset_labels )) != kOkRC )
+        if((rc = _class_apply_presets(proc, pstate.preset_labels )) != kOkRC )
           goto errLabel;
 
       // All the class presets values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
-      // Apply the proc instance 'args:{}' values.
+      // Apply the proc proc instance 'args:{}' values.
       if( pstate.arg_cfg != nullptr )
       {
-        if((rc = _proc_inst_args_channelize_vars( inst, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
+        if((rc = _proc_inst_args_channelize_vars( proc, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
           goto errLabel;
       }
       
-      // All the instance arg values have now been set and those variables
+      // All the proc instance arg values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
 
       // TODO: Should the 'all' variable be removed for variables that have numeric channel indexes?
 
       // Connect the in-list variables to their sources.
-      if((rc = _connect_in_vars(net, inst, pstate)) != kOkRC )
+      if((rc = _connect_in_vars(net, proc, pstate)) != kOkRC )
       {
         rc = cwLogError(rc,"Input connection processing failed.");
         goto errLabel;
       }
 
-      // Connect the wrapped vars in this subnet proc
-      if((rc = _connect_wrapped_vars( inst, proxyVarL )) != kOkRC )
+      // Connect the proxied vars in this subnet proc
+      if((rc = _connect_proxy_vars( proc, proxyVarL )) != kOkRC )
       {
-        rc = cwLogError(rc,"Wrapped connection processing failed.");
+        rc = cwLogError(rc,"Proxy connection processing failed.");
         goto errLabel;
       }
 
       
-      // Complete the instantiation of the proc instance by calling the custom instance creation function.
+      // Complete the instantiation of the proc proc instance by calling the custom proc instance creation function.
 
-      // Call the custom instance create() function.
-      if((rc = class_desc->members->create( inst )) != kOkRC )
+      // Call the custom proc instance create() function.
+      if((rc = class_desc->members->create( proc )) != kOkRC )
       {
         rc = cwLogError(kInvalidArgRC,"Custom instantiation failed." );
         goto errLabel;
       }
 
-      // Create the instance->varMap[] lookup array
-      if((rc =_create_instance_var_map( inst )) != kOkRC )
+      // Create the proc instance->varMap[] lookup array
+      if((rc =_create_proc_var_map( proc )) != kOkRC )
       {
         rc = cwLogError(rc,"Variable map creation failed.");
         goto errLabel;
       }
 
       // the custom creation function may have added channels to in-list vars fix up those connections here.
-      //_complete_input_connections(inst);
+      //_complete_input_connections(proc);
 
-      // set the log flags again so that vars created by the instance can be included in the log output
-      if((rc = _set_log_flags(inst,pstate.log_labels)) != kOkRC )
+      // set the log flags again so that vars created by the proc instance can be included in the log output
+      if((rc = _set_log_flags(proc,pstate.log_labels)) != kOkRC )
         goto errLabel;
       
-      // call the 'value()' function to inform the instance of the current value of all of it's variables.
-      if((rc = _call_value_func_on_all_variables( inst )) != kOkRC )
+      // call the 'value()' function to inform the proc instance of the current value of all of it's variables.
+      if((rc = _call_value_func_on_all_variables( proc )) != kOkRC )
         goto errLabel;
 
-      if((rc = instance_validate(inst)) != kOkRC )
+      if((rc = proc_validate(proc)) != kOkRC )
       {
-        rc = cwLogError(rc,"Proc instance validation failed.");
+        rc = cwLogError(rc,"Proc proc instance validation failed.");
         goto errLabel;
       }
       
-      inst_ref = inst;
+      proc_ref = proc;
       
     errLabel:
       if( rc != kOkRC )
       {
-        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.inst_label),sfx_id);
-        _destroy_inst(inst);
+        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.proc_label),sfx_id);
+        proc_destroy(proc);
       }
       
       _destroy_pstate(pstate);
@@ -2018,7 +1992,7 @@ namespace cw
       return result;
     }
     
-    rc_t _find_network_preset_instance_pair( network_t& net, const char* preset_label, const char* instance_label, const object_t*& preset_val_ref )
+    rc_t _find_network_preset_proc_pair( network_t& net, const char* preset_label, const char* proc_label, const object_t*& preset_val_ref )
     {
       rc_t rc = kOkRC;
       const object_t* net_preset_pair = nullptr;
@@ -2032,20 +2006,20 @@ namespace cw
         goto errLabel;
       }
 
-      // locate the instance matching 'instance_label'.
+      // locate the proc instance matching 'proc_label'.
       for(unsigned i=0; i<net_preset_pair->child_count(); ++i)
       {
-        const object_t* inst_pair;
-        if((inst_pair = net_preset_pair->child_ele(i)) != nullptr && inst_pair->is_pair() && textIsEqual(inst_pair->pair_label(),instance_label) )
+        const object_t* proc_pair;
+        if((proc_pair = net_preset_pair->child_ele(i)) != nullptr && proc_pair->is_pair() && textIsEqual(proc_pair->pair_label(),proc_label) )
         {      
 
-          preset_val_ref = inst_pair->pair_value();
+          preset_val_ref = proc_pair->pair_value();
 
           goto errLabel;
         }
       }
   
-      rc = cwLogError(kInvalidArgRC,"The preset instance label '%s' was not found.",cwStringNullGuard(preset_label));
+      rc = cwLogError(kInvalidArgRC,"The preset proc instance label '%s' was not found.",cwStringNullGuard(preset_label));
   
     errLabel:
       return rc;
@@ -2088,7 +2062,7 @@ cw::rc_t cw::flow::network_create( flow_t*            p,
   }
 
   net.proc_arrayAllocN = polyCnt * net.procsCfg->child_count();
-  net.proc_array       = mem::allocZ<instance_t*>(net.proc_arrayAllocN);
+  net.proc_array       = mem::allocZ<proc_t*>(net.proc_arrayAllocN);
   net.proc_arrayN      = 0;
 
   for(unsigned i=0; i<outerN; ++i)
@@ -2104,8 +2078,8 @@ cw::rc_t cw::flow::network_create( flow_t*            p,
 
         assert(net.proc_arrayN < net.proc_arrayAllocN );
         
-        // create the proc instance
-        if( (rc= _create_instance( p, proc_cfg, sfx_id, net, proxyVarL, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
+        // create the proc proc instance
+        if( (rc= _create_proc_instance( p, proc_cfg, sfx_id, net, proxyVarL, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
         {
           //rc = cwLogError(rc,"The instantiation at proc index %i is invalid.",net.proc_arrayN);
           goto errLabel;
@@ -2162,30 +2136,30 @@ cw::rc_t cw::flow::exec_cycle( network_t& net )
   return rc;
 }
 
-cw::rc_t cw::flow::get_variable( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, instance_t*& instPtrRef, variable_t*& varPtrRef )
+cw::rc_t cw::flow::get_variable( network_t& net, const char* proc_label, const char* var_label, unsigned chIdx, proc_t*& procPtrRef, variable_t*& varPtrRef )
 {
   rc_t        rc   = kOkRC;
-  instance_t* inst = nullptr;
+  proc_t* proc = nullptr;
   variable_t* var  = nullptr;
 
   varPtrRef = nullptr;
-  instPtrRef = nullptr;
+  procPtrRef = nullptr;
 
-  // locate the proc instance
-  if((inst = instance_find(net,inst_label,kBaseSfxId)) == nullptr )
+  // locate the proc proc instance
+  if((proc = proc_find(net,proc_label,kBaseSfxId)) == nullptr )
   {
-    rc = cwLogError(kInvalidIdRC,"Unknown proc instance label '%s'.", cwStringNullGuard(inst_label));
+    rc = cwLogError(kInvalidIdRC,"Unknown proc proc instance label '%s'.", cwStringNullGuard(proc_label));
     goto errLabel;
   }
 
   // locate the variable
-  if((rc = var_find( inst, var_label, kBaseSfxId, chIdx, var)) != kOkRC )
+  if((rc = var_find( proc, var_label, kBaseSfxId, chIdx, var)) != kOkRC )
   {
-    rc = cwLogError(kInvalidArgRC,"The variable '%s' could not be found on the proc instance '%s'.",cwStringNullGuard(var_label),cwStringNullGuard(inst_label));
+    rc = cwLogError(kInvalidArgRC,"The variable '%s' could not be found on the proc proc instance '%s'.",cwStringNullGuard(var_label),cwStringNullGuard(proc_label));
     goto errLabel;
   }
 
-  instPtrRef = inst;
+  procPtrRef = proc;
   varPtrRef = var;
       
 errLabel:
@@ -2206,20 +2180,20 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel
     goto errLabel;
   }
 
-  // for each instance in the preset
+  // for each proc instance in the preset
   for(unsigned i=0; i<net_preset_value->child_count(); ++i)
   {
-    // get the instance label/value pair
+    // get the proc instance label/value pair
     if((preset_pair = net_preset_value->child_ele(i)) != nullptr && preset_pair->is_pair() )
     {
-      const char* inst_label = preset_pair->pair_label();
+      const char* proc_label = preset_pair->pair_label();
       const object_t* preset_value_cfg = preset_pair->pair_value();
-      instance_t* inst;
+      proc_t* proc;
 
-      // locate the instance
-      if((inst = instance_find(net,inst_label,proc_label_sfx_id)) == nullptr )
+      // locate the proc instance
+      if((proc = proc_find(net,proc_label,proc_label_sfx_id)) == nullptr )
       {
-        rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel);
+        rc = cwLogError(kInvalidIdRC,"The network proc instance '%s' refered to in network preset '%s' could not be found.",proc_label,presetLabel);
         goto errLabel;
       }
 
@@ -2228,23 +2202,23 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel
       {
         const char* class_preset_label;
         preset_value_cfg->value(class_preset_label);
-        _class_preset_channelize_vars(inst, class_preset_label );
+        _class_preset_channelize_vars(proc, class_preset_label );
       }
       else
       {
         // if the preset value is a dict then apply it directly
         if( preset_value_cfg->is_dict() )
         {
-          if((rc =  _preset_channelize_vars( inst, "network", presetLabel, preset_value_cfg )) != kOkRC )
+          if((rc =  _preset_channelize_vars( proc, "network", presetLabel, preset_value_cfg )) != kOkRC )
           {
-            rc = cwLogError(rc,"The preset  '%s' application failed on instance '%s'.", presetLabel, inst_label );
+            rc = cwLogError(rc,"The preset  '%s' application failed on proc instance '%s'.", presetLabel, proc_label );
             goto errLabel;
           }
           
         }
         else
         {
-          rc = cwLogError(kSyntaxErrorRC,"The network preset '%s' instance '%s' does not have a string or dictionary value.", presetLabel, inst_label );
+          rc = cwLogError(kSyntaxErrorRC,"The network preset '%s' proc instance '%s' does not have a string or dictionary value.", presetLabel, proc_label );
           goto errLabel;
         }
       }
@@ -2276,18 +2250,18 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
     goto errLabel;
   }
 
-  // for each instance in the preset
+  // for each proc instance in the preset
   for(unsigned i=0; i<net_preset_value_0->child_count(); ++i)
   {
     const object_t* preset_pair_0      = net_preset_value_0->child_ele(i);
-    const char*     inst_label         = preset_pair_0->pair_label(); 
+    const char*     proc_label         = preset_pair_0->pair_label(); 
     const object_t* preset_value_cfg_0 = preset_pair_0->pair_value();
-    instance_t*     inst               = nullptr;
+    proc_t*     proc               = nullptr;
     const object_t* preset_value_cfg_1 = nullptr;
     const int two = 2;
     const char* class_preset_labelA[two];
     
-    // get the instance label/value pair
+    // get the proc instance label/value pair
     if((preset_pair_0 = net_preset_value_0->child_ele(i)) == nullptr || !preset_pair_0->is_pair() )
     {
       rc = cwLogError(kSyntaxErrorRC,"An invalid preset value pair was encountered in '%s'.",presetLabel_0);
@@ -2297,25 +2271,25 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
     // verify that the preset value is a string or dict
     if( preset_pair_0->pair_value()==nullptr || (!preset_value_cfg_0->is_dict() && !preset_value_cfg_0->is_string() ))
     {
-      rc = cwLogError(kSyntaxErrorRC,"The preset value pair for instance '%s' in '%s' is not a 'dict' or 'string'.",inst_label,presetLabel_0);
+      rc = cwLogError(kSyntaxErrorRC,"The preset value pair for proc instance '%s' in '%s' is not a 'dict' or 'string'.",proc_label,presetLabel_0);
       goto errLabel;
     }
 
-    // locate the instance associated with the primary and secondary preset
-    if((inst = instance_find(net,inst_label,kBaseSfxId)) == nullptr )
+    // locate the proc instance associated with the primary and secondary preset
+    if((proc = proc_find(net,proc_label,kBaseSfxId)) == nullptr )
     {
-      rc = cwLogError(kInvalidIdRC,"The network instance '%s' refered to in network preset '%s' could not be found.",cwStringNullGuard(inst_label),cwStringNullGuard(presetLabel_0));
+      rc = cwLogError(kInvalidIdRC,"The network proc instance '%s' refered to in network preset '%s' could not be found.",cwStringNullGuard(proc_label),cwStringNullGuard(presetLabel_0));
       goto errLabel;
     }
             
-    // locate the second instance/preset value pair 
-    if((rc = _find_network_preset_instance_pair(net, presetLabel_1, inst_label, preset_value_cfg_1 )) != kOkRC )
+    // locate the second proc instance/preset value pair 
+    if((rc = _find_network_preset_proc_pair(net, presetLabel_1, proc_label, preset_value_cfg_1 )) != kOkRC )
     {
-      rc = cwLogError(kInvalidIdRC,"The second network instance '%s' refered to in network preset '%s' could not be found.",inst_label,presetLabel_1);
+      rc = cwLogError(kInvalidIdRC,"The second network proc instance '%s' refered to in network preset '%s' could not be found.",proc_label,presetLabel_1);
       goto errLabel;
     }
     
-    // TODO: We require that the instance presets both be of the same type: string or dict.
+    // TODO: We require that the proc instance presets both be of the same type: string or dict.
     // There's no good reason for this, as string's resolve to class dict presets anyway.
     // Fix this!
     if( !(preset_value_cfg_0->is_dict() == preset_value_cfg_1->is_dict() && preset_value_cfg_0->is_string() == preset_value_cfg_1->is_string()) )
@@ -2331,7 +2305,7 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
     // if the preset value is a string then look it up in the class dictionary
     if( preset_value_cfg_0->is_string() )
     {
-      rc = _class_multi_preset_channelize_vars(inst, class_preset_labelA, two, coeff );        
+      rc = _class_multi_preset_channelize_vars(proc, class_preset_labelA, two, coeff );        
     }
     else
     {
@@ -2339,9 +2313,9 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
         
       const object_t* preset_value_cfgA[] = { preset_value_cfg_0, preset_value_cfg_1};
                   
-      if((rc =  _multi_preset_channelize_vars( inst, "network", class_preset_labelA, preset_value_cfgA, two, coeff )) != kOkRC )
+      if((rc =  _multi_preset_channelize_vars( proc, "network", class_preset_labelA, preset_value_cfgA, two, coeff )) != kOkRC )
       {
-        rc = cwLogError(rc,"The dual preset  '%s':'%s' application failed on instance '%s'.", cwStringNullGuard(class_preset_labelA[0]), cwStringNullGuard(class_preset_labelA[1]), inst_label );
+        rc = cwLogError(rc,"The dual preset  '%s':'%s' application failed on proc instance '%s'.", cwStringNullGuard(class_preset_labelA[0]), cwStringNullGuard(class_preset_labelA[1]), proc_label );
         goto errLabel;
       }
     }
diff --git a/cwFlowNet.h b/cwFlowNet.h
index b9e5016..ca8cf60 100644
--- a/cwFlowNet.h
+++ b/cwFlowNet.h
@@ -25,13 +25,13 @@ namespace cw
     rc_t exec_cycle( network_t& net );
 
 
-    rc_t get_variable( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, instance_t*& instPtrRef, variable_t*& varPtrRef );
+    rc_t get_variable( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, proc_t*& instPtrRef, variable_t*& varPtrRef );
 
     template< typename T >
     rc_t set_variable_value( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, T value )
     {
       rc_t rc = kOkRC;
-      instance_t* inst = nullptr;
+      proc_t* inst = nullptr;
       variable_t* var = nullptr;
 
       // get the variable
@@ -53,7 +53,7 @@ namespace cw
     rc_t get_variable_value( network_t& net, const char* inst_label, const char* var_label, unsigned chIdx, T& valueRef )
     {
       rc_t rc = kOkRC;
-      instance_t* inst = nullptr;
+      proc_t* inst = nullptr;
       variable_t* var = nullptr;
 
       // get the variable 

From 172ada9fddf26c829c18a5156dc476435df7dd63 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:47:13 -0400
Subject: [PATCH 057/101] cwFlow.cpp : Made common parser for subnet and
 non-subnet var descriptions. Renamed instance_t to proc_t.

---
 cwFlow.cpp | 358 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 203 insertions(+), 155 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index c846b76..ffe2c36 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -103,6 +103,161 @@ namespace cw
       }
       return rc;
     }
+
+    rc_t _parse_subnet_var_proxy_string( const char* proxyStr, var_desc_t* var_desc )
+    {
+      rc_t rc       = kOkRC;
+
+      const char* period;
+
+      // find the separating period
+      if((period = firstMatchChar(proxyStr,'.')) == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The separating '.' could not be found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
+        goto errLabel;
+      }
+
+      // validate the length of the proc inst label
+      if( period-proxyStr == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"No proxy proc instance was found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
+        goto errLabel;        
+      }
+
+      // validate the length of the var label
+      if( textLength(period+1) == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"No proxy var was found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
+        goto errLabel;        
+      }
+
+      
+      var_desc->proxyProcLabel = mem::duplStr(proxyStr,period-proxyStr);
+      var_desc->proxyVarLabel  = mem::duplStr(period+1);
+
+    errLabel:
+      return rc;
+    }
+
+
+    rc_t _parse_class_var_attribute_flags(const object_t* var_flags_obj, unsigned& flags_ref)
+    {
+      rc_t     rc           = kOkRC;
+      unsigned result_flags = 0;
+      
+      flags_ref = 0;
+      
+      if( !var_flags_obj->is_list() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The variable description 'flags' field must be a list.");
+        goto errLabel;
+      }
+        
+      for(unsigned i=0; i<var_flags_obj->child_count(); ++i)
+      {
+        const object_t* flag_obj   = var_flags_obj->child_ele(i);
+        const char*     flag_label = nullptr;
+        unsigned        flag       = 0;
+
+        // validate the flag syntax
+        if( flag_obj == nullptr || !flag_obj->is_string() || flag_obj->value(flag_label)!=kOkRC )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Invalid variable description flag syntax on flag index %i.",i);
+          goto errLabel;
+        }
+
+        // parse the flag
+        if((flag = var_desc_attr_label_to_flag(flag_label)) == kInvalidVarDescFl )
+        {
+          rc = cwLogError(kInvalidArgRC,"The variable description flag ('%s') at flag index %i is not valid.",cwStringNullGuard(flag_label),i);
+          goto errLabel;
+        }
+
+        result_flags |= flag;        
+      }
+
+      flags_ref = result_flags;
+    errLabel:
+      return rc;
+      
+    }
+    
+    rc_t _parse_class_var_cfg(flow_t* p, class_desc_t* class_desc, const object_t* var_desc_pair, var_desc_t*& var_desc_ref )
+    {
+      rc_t            rc                  = kOkRC;      
+      const object_t* var_flags_obj       = nullptr;
+      const char*     var_value_type_str  = nullptr;
+      const char*     var_label           = nullptr;
+      const char*     proxy_string        = nullptr;
+      var_desc_t*     vd                  = nullptr;
+
+      var_desc_ref = nullptr;
+
+      if(var_desc_pair==nullptr || !var_desc_pair->is_pair() || var_desc_pair->pair_label()==nullptr || (var_label = var_desc_pair->pair_label())==nullptr || var_desc_pair->pair_value()==nullptr || !var_desc_pair->pair_value()->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"An invalid variable description syntax was encountered.");
+        goto errLabel;
+      }
+
+      // Allocate the var. desc record
+      if((vd = var_desc_create( var_label, var_desc_pair->pair_value())) == nullptr )
+      {
+        rc = cwLogError(kObjAllocFailRC,"Variable description allocation failed.");
+        goto errLabel;
+      }
+      
+
+      // get the variable description 
+      if((rc = vd->cfg->getv("doc",  vd->docText)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parsing failed on class:%s variable: '%s'.", class_desc->label, vd->label );
+        goto errLabel;
+      }
+
+      // get the variable description 
+      if((rc = vd->cfg->getv_opt("flags", var_flags_obj,
+                                 "type", var_value_type_str,
+                                 "value", vd->val_cfg,
+                                 "proxy", proxy_string )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parsing optional fields failed.");
+        goto errLabel;
+      }
+      
+      // convert the type string to a numeric type flag
+      if( var_value_type_str  != nullptr )
+        if( (vd->type = value_type_label_to_flag( var_value_type_str )) == kInvalidTId )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Invalid variable description type flag: '%s' was encountered.", var_value_type_str );
+          goto errLabel;            
+        }
+
+      // parse the proxy string into it's two parts: <proc>.<var>
+      if( proxy_string != nullptr )
+      {
+        if((rc = _parse_subnet_var_proxy_string( proxy_string, vd )) != kOkRC )
+          goto errLabel;
+      }
+
+      // parse the var desc attribute flags
+      if( var_flags_obj != nullptr )
+      {
+        vd->flags = 0;
+        if((rc = _parse_class_var_attribute_flags(var_flags_obj, vd->flags)) != kOkRC )
+          goto errLabel;
+      }
+
+      var_desc_ref = vd;
+
+    errLabel:
+      if( rc != kOkRC )
+      {
+        rc = cwLogError(rc,"A variable description create failed on class desc:'%s' var:'%s'.",cwStringNullGuard(class_desc->label),cwStringNullGuard(var_label));
+        var_desc_destroy(vd);
+      }
+
+      return rc;
+    }
     
     rc_t  _parse_class_cfg(flow_t* p, const object_t* classCfg)
     {
@@ -183,56 +338,31 @@ namespace cw
           // for each class value description
           for(unsigned j=0; j<varD->child_count(); ++j)
           {
-            const object_t* var_obj   = varD->child_ele(j);
-            const object_t* var_flags_obj = nullptr;
-            const char*     type_str  = nullptr;
-            unsigned        type_flag = 0;
-            bool            srcVarFl  = false;
-            bool            srcOptFl  = false;
-            var_desc_t*     vd        = mem::allocZ<var_desc_t>();
-
-            vd->label = var_obj->pair_label();
-            vd->cfg   = var_obj->pair_value();
-
-            // get the variable description 
-            if((rc = vd->cfg->getv("type", type_str,
-                                   "doc",  vd->docText)) != kOkRC )
+            const object_t* var_obj       = varD->child_ele(j);
+            var_desc_t* vd = nullptr;
+            
+            if((rc = _parse_class_var_cfg(p, cd, var_obj, vd )) != kOkRC )
             {
-              rc = cwLogError(rc,"Parsing failed on class:%s variable: '%s'.", cd->label, vd->label );
+              rc = cwLogError(rc,"Variable description created failed on the class desc '%s' on the variable description at index '%i'.",cwStringNullGuard(cd->label),j);
               goto errLabel;
             }
 
-            // convert the type string to a numeric type flag
-            if( (type_flag = value_type_label_to_flag( type_str )) == kInvalidTId )
+            if( vd->type == kInvalidTFl )
             {
-              rc = cwLogError(kSyntaxErrorRC,"Invalid type flag: '%s' class:'%s' value:'%s'.", type_str, cd->label, vd->label );
-              goto errLabel;            
-            }
-
-            // get the variable description 
-            if((rc = vd->cfg->getv_opt("flags", var_flags_obj,
-                                       "value",vd->val_cfg)) != kOkRC )
-            {
-              rc = cwLogError(rc,"Parsing optional fields failed on class:%s variable: '%s'.", cd->label, vd->label );
+              rc = cwLogError(rc,"The variable description '%s' in class description '%s' does not have a valid 'type' field.",cwStringNullGuard(vd->label),cwStringNullGuard(cd->label));
               goto errLabel;
             }
 
-            // check for 'src' flag
-            if((rc = _is_var_flag_set( var_flags_obj, "src", cd->label, vd->label, srcVarFl )) != kOkRC )
-              goto errLabel;
-
-            // check for 'src_opt' flag
-            if((rc = _is_var_flag_set( var_flags_obj, "src_opt", cd->label, vd->label, srcOptFl )) != kOkRC )
-              goto errLabel;
-          
-            vd->type |= type_flag;
-
-            if( srcVarFl )
-              vd->flags |= kSrcVarFl;
-
-            if( srcOptFl )
-              vd->flags |= kSrcOptVarFl;
+            if( vd->proxyProcLabel != nullptr || vd->proxyVarLabel != nullptr )
+            {
+              cwLogWarning("The 'proxy' field in the variable description '%s' on class description '%s' will be ignored because the variable is not part of a subnet definition.",cwStringNullGuard(vd->label),cwStringNullGuard(cd->label));
+            }
 
+            if( cwIsFlag(vd->flags,kSubnetOutVarDescFl ) )
+            {
+              cwLogWarning("The 'out' flag in the variable description '%s' on class description '%s' will be ignored because the variable is not part of a subnet definition.",cwStringNullGuard(vd->label),cwStringNullGuard(cd->label));
+            }
+            
             vd->link     = cd->varDescL;
             cd->varDescL = vd;
           }
@@ -281,130 +411,65 @@ namespace cw
     }
 
 
-    rc_t _parse_subnet_var_proxy_string( const char* proxyStr, char*& procLabel_ref, char*& varLabel_ref )
-    {
-      rc_t rc       = kOkRC;
-      procLabel_ref = nullptr;
-      varLabel_ref  = nullptr;
-
-      const char* period;
-
-      // find the separating period
-      if((period = firstMatchChar(proxyStr,'.')) == nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The separating '.' could not be found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
-        goto errLabel;
-      }
-
-      // validate the length of the proc inst label
-      if( period-proxyStr == 0 )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"No proxy proc instance was found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
-        goto errLabel;        
-      }
-
-      // validate the length of the var label
-      if( textLength(period+1) == 0 )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"No proxy var was found in the proxy string '%s'.",cwStringNullGuard(proxyStr));
-        goto errLabel;        
-      }
-
-      
-      procLabel_ref = mem::duplStr(proxyStr,period-proxyStr);
-      varLabel_ref  = mem::duplStr(period+1);
-
-    errLabel:
-      return rc;
-    }
-
-    void _var_desc_release( var_desc_t*& vd )
-    {
-      mem::release(vd->proxyProcLabel);
-      mem::release(vd->proxyVarLabel);
-      mem::release(vd);
-    }
-
-    rc_t _create_subnet_var_desc( flow_t* p, class_desc_t* wrapProcClassDesc, const object_t* subnetProcD, const object_t* varDescPair, var_desc_t*& vd_ref )
+    rc_t _create_subnet_var_desc( flow_t* p, class_desc_t* subnetClassDesc, const object_t* subnetProcD, const object_t* varDescPair, var_desc_t*& vd_ref )
     {
       rc_t                rc               = kOkRC;
-      const object_t*     flagsCfg         = nullptr;
-      const char*         proxyStr         = nullptr;
-      const char*         docStr           = nullptr;
-      const char*         varLabel         = nullptr;
-      char*               proxyProcLabel   = nullptr;
-      char*               proxyVarLabel    = nullptr;
-      unsigned            proxyVarFlags    = 0;
       const class_desc_t* proxy_class_desc = nullptr;
       const var_desc_t*   proxy_var_desc   = nullptr;
       bool                subnetOutVarFl   = false;
-      var_desc_t*         var_desc         = mem::allocZ<var_desc_t>();
+      var_desc_t*         var_desc         = nullptr;
       
       vd_ref = nullptr;
 
-      // verify that the var label is valid
-      if(!varDescPair->is_pair() || (varLabel=varDescPair->pair_label())==nullptr || varDescPair->pair_value()==nullptr || !varDescPair->pair_value()->is_dict() )
+      // parse the variable descripiton and create a var_desc_t record
+      if((rc = _parse_class_var_cfg(p, subnetClassDesc, varDescPair, var_desc )) != kOkRC )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The proxy var entry is not valid.");
         goto errLabel;
       }
 
-      // parse the var desc dictionary
-      if((rc = varDescPair->pair_value()->getv("proxy",proxyStr,
-                                               "doc",  docStr)) != kOkRC )
+      if( var_desc->type != 0 )
       {
-        rc = cwLogError(rc,"Parsing failed on the proxy var dictionary.");
-        goto errLabel;
+        cwLogWarning("The 'type' field int the variable description '%s' on the class description '%s' will be ignored because the variable is proxied.",cwStringNullGuard(subnetClassDesc->label),cwStringNullGuard(var_desc->label));
       }
 
-      // parse the var desc dictionary optional fields
-      if((rc = varDescPair->pair_value()->getv_opt("flags", flagsCfg)) != kOkRC )
-      {
-        rc = cwLogError(rc,"Optional attribute parsing failed on the proxy var dictionary.");
-        goto errLabel;
-      }
-      
-      // parse the proxy string into it's two parts: <proc>.<var>
-      if((rc = _parse_subnet_var_proxy_string( proxyStr, proxyProcLabel, proxyVarLabel )) != kOkRC )
+      // verify that a proxy-proc-label and proxy-var-label were specified in the variable descripiton
+      if( var_desc->proxyProcLabel == nullptr || var_desc->proxyVarLabel == nullptr )
       {
+        rc = cwLogError(kSyntaxErrorRC,"The subnet variable description '%s' in the subnet '%s' must have a valid 'proxy' field.",cwStringNullGuard(var_desc->label),cwStringNullGuard(subnetClassDesc->label));
         goto errLabel;
       }
       
       // locate the class desc associated with proxy proc
-      if((rc = _find_subnet_proc_class_desc( p, subnetProcD, proxyProcLabel, proxy_class_desc )) != kOkRC )
+      if((rc = _find_subnet_proc_class_desc( p, subnetProcD, var_desc->proxyProcLabel, proxy_class_desc )) != kOkRC )
       {
         goto errLabel;
       }
 
       // locate the var desc associated with the proxy proc var
-      if((proxy_var_desc = var_desc_find( proxy_class_desc, proxyVarLabel)) == nullptr )
+      if((proxy_var_desc = var_desc_find( proxy_class_desc, var_desc->proxyVarLabel)) == nullptr )
       {
-        rc = cwLogError(kEleNotFoundRC,"The variable desc '%s.%s' could not be found.",cwStringNullGuard(proxyProcLabel),cwStringNullGuard(proxyVarLabel));
+        rc = cwLogError(kEleNotFoundRC,"The subnet proxied variable desc '%s.%s' could not be found in subnet '%s'.",cwStringNullGuard(var_desc->proxyProcLabel),cwStringNullGuard(var_desc->proxyVarLabel),cwStringNullGuard(subnetClassDesc->label));
         goto errLabel;                        
       }
 
-      // most of the fields for the proxy are taken directly from the the actual var ...
-      *var_desc = *proxy_var_desc;
-      
-      var_desc->label   = varLabel;  // ... but the label and doc are overwritten from subnet desc.
-      var_desc->docText = docStr;
-      var_desc->proxyProcLabel = proxyProcLabel;
-      var_desc->proxyVarLabel  = proxyVarLabel;
-      var_desc->link    = nullptr;
+      // get the subnet var_desc type from the proxied var_desc
+      var_desc->type  = proxy_var_desc->type;
 
-      if((rc = _is_var_flag_set( flagsCfg, "out", wrapProcClassDesc->label, var_desc->label, subnetOutVarFl )) != kOkRC )
-        goto errLabel;
+      // augment the subnet var_desc flags from the proxied var_desc
+      var_desc->flags |= proxy_var_desc->flags;
+
+      // if no default value was given to the subnet var desc then get it from the proxied var desc
+      if( var_desc->val_cfg == nullptr )
+        var_desc->val_cfg = proxy_var_desc->val_cfg;
 
-      var_desc->flags = cwEnaFlag(var_desc->flags, kSubnetOutVarFl, subnetOutVarFl);
-      
       vd_ref = var_desc;
 
     errLabel:
 
       if( rc != kOkRC )
       {        
-        rc = cwLogError(rc,"The creation of proxy var '%s' failed.",cwStringNullGuard(varLabel));
-        _var_desc_release(var_desc);
+        rc = cwLogError(rc,"The creation of proxy var '%s' failed.",var_desc==nullptr ? "<unknown>" : cwStringNullGuard(var_desc->label));
+        var_desc_destroy(var_desc);
       }
       
       return rc;
@@ -531,10 +596,9 @@ namespace cw
           goto errLabel;
         }
 
-        // we have to update the size of the subnet class array
-        // as we go because we may want to find subnets classes within
-        // subnets which are definted later and so the length p->subnetA[]
-        // must be correct 
+        // We have to update the size of the subnet class array
+        // as we go because we may want be able to search p->subnetDescA[]
+        // aand to do that we must now the current length.
         p->subnetDescN += 1;
       }
 
@@ -557,26 +621,7 @@ namespace cw
       for(unsigned i=0; i<classDescN; ++i)
       {
         class_desc_t* cd  = classDescA + i;
-
-        // release the var desc list
-        var_desc_t*   vd0 = cd->varDescL;
-        var_desc_t*   vd1 = nullptr;        
-        while( vd0 != nullptr )
-        {
-          vd1 = vd0->link;
-          _var_desc_release(vd0);
-          vd0 = vd1;
-        }
-
-        // release the preset list
-        preset_t* pr0 = cd->presetL;
-        preset_t* pr1 = nullptr;
-        while( pr0 != nullptr )
-        {
-          pr1 = pr0->link;
-          mem::release(pr0);
-          pr0 = pr1;
-        }
+        class_desc_destroy(cd);
       }
 
       mem::release(classDescA);      
@@ -646,6 +691,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
     goto errLabel;    
   }
 
+  // parse the subnet descriptions
   if( subnetCfg != nullptr )
     if((rc = _parse_subnet_cfg(p,subnetCfg)) != kOkRC )
     {
@@ -868,7 +914,7 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     goto errLabel;
   }
   
-  if((rc                                                 = cfg->getv("proc_cfg_fname",proc_cfg_fname,
+  if((rc = cfg->getv("proc_cfg_fname",proc_cfg_fname,
                      "test_cases",     test_cases_cfg)) != kOkRC )
   {
     rc = cwLogError(rc,"The name of the flow_proc_dict file could not be parsed.");
@@ -910,8 +956,6 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     goto errLabel;
   }
 
-  //print_network(flowH);
-  
   // run the network
   if((rc = exec( flowH )) != kOkRC )
     rc = cwLogError(rc,"Execution failed.");
@@ -927,6 +971,10 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
  errLabel:
   if( class_cfg != nullptr )
     class_cfg->free();
+
+  if( subnet_cfg != nullptr )
+    subnet_cfg->free();
+  
   return rc;
 }
 

From 5782ddf7afe2261dabdd6af5f1fa4a614dded731 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:47:34 -0400
Subject: [PATCH 058/101] cwFlowProc.cpp : Renamed instance_t to proc_t.

---
 cwFlowProc.cpp | 906 ++++++++++++++++++++++++-------------------------
 1 file changed, 453 insertions(+), 453 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 2e9cb82..b5066bc 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -33,7 +33,7 @@ namespace cw
   {
     
     template< typename inst_t >
-    rc_t std_destroy( instance_t* proc )
+    rc_t std_destroy( proc_t* proc )
     {
       inst_t* p = (inst_t*)proc->userPtr;
       rc_t rc = _destroy(proc,p);
@@ -42,7 +42,7 @@ namespace cw
     }
     
     template< typename inst_t >
-    rc_t std_create( instance_t* proc )
+    rc_t std_create( proc_t* proc )
     {
       rc_t rc = kOkRC;
       proc->userPtr = mem::allocZ<inst_t>();
@@ -52,15 +52,15 @@ namespace cw
     }
 
     template< typename inst_t >
-    rc_t std_value( instance_t* proc, variable_t* var )
+    rc_t std_value( proc_t* proc, variable_t* var )
     { return _value(proc,(inst_t*)proc->userPtr, var); }
         
     template< typename inst_t >
-    rc_t std_exec( instance_t* proc )
+    rc_t std_exec( proc_t* proc )
     { return _exec(proc,(inst_t*)proc->userPtr); }
 
     template< typename inst_t >
-    rc_t std_report( instance_t* proc )
+    rc_t std_report( proc_t* proc )
     { return _report(proc,(inst_t*)proc->userPtr); }
 
     
@@ -76,7 +76,7 @@ namespace cw
       } inst_t;
 
 
-      rc_t _create( instance_t* proc, inst_t* p )
+      rc_t _create( proc_t* proc, inst_t* p )
       {
         rc_t    rc   = kOkRC;        
 
@@ -85,7 +85,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _destroy( instance_t* proc, inst_t* p )
+      rc_t _destroy( proc_t* proc, inst_t* p )
       {
         rc_t rc = kOkRC;
 
@@ -94,20 +94,20 @@ namespace cw
         return rc;
       }
 
-      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
+      rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t _exec( instance_t* proc, inst_t* p )
+      rc_t _exec( proc_t* proc, inst_t* p )
       {
         rc_t rc      = kOkRC;
         
         return rc;
       }
 
-      rc_t _report( instance_t* proc, inst_t* p )
+      rc_t _report( proc_t* proc, inst_t* p )
       { return kOkRC; }
 
       class_members_t members = {
@@ -132,7 +132,7 @@ namespace cw
       } inst_t;
 
 
-      rc_t _create( instance_t* proc, inst_t* p )
+      rc_t _create( proc_t* proc, inst_t* p )
       {
         rc_t            rc         = kOkRC;        
         const object_t* networkCfg = nullptr;
@@ -157,7 +157,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _destroy( instance_t* proc, inst_t* p )
+      rc_t _destroy( proc_t* proc, inst_t* p )
       {
         rc_t rc = kOkRC;
 
@@ -166,13 +166,13 @@ namespace cw
         return rc;
       }
 
-      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
+      rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t _exec( instance_t* proc, inst_t* p )
+      rc_t _exec( proc_t* proc, inst_t* p )
       {
         rc_t rc      = kOkRC;
 
@@ -182,7 +182,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _report( instance_t* proc, inst_t* p )
+      rc_t _report( proc_t* proc, inst_t* p )
       { return kOkRC; }
 
       class_members_t members = {
@@ -215,7 +215,7 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* proc )
+      rc_t create( proc_t* proc )
       {
         rc_t            rc          = kOkRC;        
         inst_t*         inst        = mem::allocZ<inst_t>();
@@ -271,7 +271,7 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t destroy( proc_t* proc )
       {
         inst_t* p = (inst_t*)proc->userPtr;
         network_destroy(p->net);
@@ -281,14 +281,14 @@ namespace cw
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         return kOkRC;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
-        inst_t* p = (inst_t*)ctx->userPtr;
+        inst_t* p = (inst_t*)proc->userPtr;
         rc_t   rc = kOkRC;
 
         if((rc = exec_cycle(p->net)) != kOkRC )
@@ -328,16 +328,16 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t rc = kOkRC;        
         coeff_t in_value = 0.5;
-        ctx->userPtr = mem::allocZ<inst_t>();
+        proc->userPtr = mem::allocZ<inst_t>();
         
-        if((rc  = var_register_and_get( ctx, kAnyChIdx, kInPId, "in", kBaseSfxId, in_value )) != kOkRC )
+        if((rc  = var_register_and_get( proc, kAnyChIdx, kInPId, "in", kBaseSfxId, in_value )) != kOkRC )
           goto errLabel;
 
-        if((rc = var_register_and_set( ctx, kAnyChIdx,
+        if((rc = var_register_and_set( proc, kAnyChIdx,
                                        kOutPId,    "out",     kBaseSfxId, in_value,
                                        kInvOutPId, "inv_out", kBaseSfxId, (coeff_t)(1.0-in_value) )) != kOkRC )
         {
@@ -348,27 +348,27 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
-        mem::release( ctx->userPtr );
+        mem::release( proc->userPtr );
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         return kOkRC;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t   rc = kOkRC;
-        inst_t* inst = (inst_t*)(ctx->userPtr);
+        inst_t* inst = (inst_t*)(proc->userPtr);
         
         coeff_t value = 1;
         
-        var_get(ctx, kInPId,     kAnyChIdx, value);
-        var_set(ctx, kOutPId,    kAnyChIdx, value);
-        var_set(ctx, kInvOutPId, kAnyChIdx, (coeff_t)(1.0 - value) );
+        var_get(proc, kInPId,     kAnyChIdx, value);
+        var_set(proc, kOutPId,    kAnyChIdx, value);
+        var_set(proc, kInvOutPId, kAnyChIdx, (coeff_t)(1.0 - value) );
 
         if( inst->value != value )
         {
@@ -380,11 +380,11 @@ namespace cw
       }
 
       class_members_t members = {
-        .create               = create,
-        .destroy              = destroy,
-        .value                = value,
-        .exec                 = exec,
-        .report               = nullptr
+        .create  = create,
+        .destroy = destroy,
+        .value   = value,
+        .exec    = exec,
+        .report  = nullptr
       };
       
     }    
@@ -413,17 +413,17 @@ namespace cw
         external_device_t* ext_dev;
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t        rc         = kOkRC;
         const char* dev_label  = nullptr;
         const char* port_label = nullptr;        
         inst_t*     inst       = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // Register variable and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx,
+        if((rc = var_register_and_get( proc, kAnyChIdx,
                                        kDevLabelPId,  "dev_label",  kBaseSfxId, dev_label,
                                        kPortLabelPId, "port_label", kBaseSfxId, port_label )) != kOkRC )
           
@@ -431,7 +431,7 @@ namespace cw
           goto errLabel;
         }
 
-        if((rc = var_register( ctx, kAnyChIdx, kOutPId, "out", kBaseSfxId)) != kOkRC )
+        if((rc = var_register( proc, kAnyChIdx, kOutPId, "out", kBaseSfxId)) != kOkRC )
         {
           goto errLabel;
         }
@@ -454,7 +454,7 @@ namespace cw
         
         
         
-        if((inst->ext_dev = external_device_find( ctx->ctx, dev_label, kMidiDevTypeId, kInFl, port_label )) == nullptr )
+        if((inst->ext_dev = external_device_find( proc->ctx, dev_label, kMidiDevTypeId, kInFl, port_label )) == nullptr )
         {
           rc = cwLogError(kOpFailRC,"The MIDI input device '%s' port '%s' could not be found.", cwStringNullGuard(dev_label), cwStringNullGuard(port_label));
           goto errLabel;
@@ -465,18 +465,18 @@ namespace cw
         inst->buf = mem::allocZ<midi::ch_msg_t>( inst->bufN );
 
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, nullptr, 0  );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, nullptr, 0  );
 
 
       errLabel: 
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         mem::release(inst->buf);
 
         mem::release(inst);
@@ -484,21 +484,21 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       { return kOkRC; }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t     rc           = kOkRC;
 
-        inst_t*  inst         = (inst_t*)ctx->userPtr;
+        inst_t*  inst         = (inst_t*)proc->userPtr;
         mbuf_t*  mbuf         = nullptr;
 
 
         // get the output variable
-        if((rc = var_get(ctx,kOutPId,kAnyChIdx,mbuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId,kAnyChIdx,mbuf)) != kOkRC )
         {
-          rc = cwLogError(kInvalidStateRC,"The MIDI file instance '%s' does not have a valid MIDI output buffer.",ctx->label);
+          rc = cwLogError(kInvalidStateRC,"The MIDI file instance '%s' does not have a valid MIDI output buffer.",proc->label);
         }
         else
         {
@@ -527,11 +527,11 @@ namespace cw
       }
 
       class_members_t members = {
-        .create = create,
+        .create  = create,
         .destroy = destroy,
         .value   = value,
-        .exec = exec,
-        .report = nullptr
+        .exec    = exec,
+        .report  = nullptr
       };
       
     }
@@ -556,7 +556,7 @@ namespace cw
         external_device_t* ext_dev;
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t        rc         = kOkRC; //
         inst_t*     inst       = mem::allocZ<inst_t>(); //
@@ -564,10 +564,10 @@ namespace cw
         const char* port_label = nullptr;
         mbuf_t*     mbuf       = nullptr;
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
         
         // Register variables and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx,
+        if((rc = var_register_and_get( proc, kAnyChIdx,
                                        kDevLabelPId, "dev_label",  kBaseSfxId, dev_label,
                                        kPortLabelPId,"port_label", kBaseSfxId, port_label,
                                        kInPId,       "in",         kBaseSfxId, mbuf)) != kOkRC )
@@ -575,7 +575,7 @@ namespace cw
           goto errLabel;
         }
 
-        if((inst->ext_dev = external_device_find( ctx->ctx, dev_label, kMidiDevTypeId, kOutFl, port_label )) == nullptr )
+        if((inst->ext_dev = external_device_find( proc->ctx, dev_label, kMidiDevTypeId, kOutFl, port_label )) == nullptr )
         {
           rc = cwLogError(kOpFailRC,"The audio output device description '%s' could not be found.", cwStringNullGuard(dev_label));
           goto errLabel;
@@ -585,30 +585,30 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t    rc   = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst);
 
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const mbuf_t* src_mbuf = nullptr;
 
-        if((rc = var_get(ctx,kInPId,kAnyChIdx,src_mbuf)) != kOkRC )
-          rc = cwLogError(kInvalidStateRC,"The MIDI output instance '%s' does not have a valid input connection.",ctx->label);
+        if((rc = var_get(proc,kInPId,kAnyChIdx,src_mbuf)) != kOkRC )
+          rc = cwLogError(kInvalidStateRC,"The MIDI output instance '%s' does not have a valid input connection.",proc->label);
         else
         {
           for(unsigned i=0; i<src_mbuf->msgN; ++i)
@@ -654,21 +654,21 @@ namespace cw
         external_device_t* ext_dev;
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t rc = kOkRC;
         
         inst_t*                  inst = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // Register variable and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx, kDevLabelPId, "dev_label", kBaseSfxId, inst->dev_label )) != kOkRC )
+        if((rc = var_register_and_get( proc, kAnyChIdx, kDevLabelPId, "dev_label", kBaseSfxId, inst->dev_label )) != kOkRC )
         {
           goto errLabel;
         }
 
-        if((inst->ext_dev = external_device_find( ctx->ctx, inst->dev_label, kAudioDevTypeId, kInFl )) == nullptr )
+        if((inst->ext_dev = external_device_find( proc->ctx, inst->dev_label, kAudioDevTypeId, kInFl )) == nullptr )
         {
           rc = cwLogError(kOpFailRC,"The audio input device description '%s' could not be found.", cwStringNullGuard(inst->dev_label));
           goto errLabel;
@@ -676,40 +676,40 @@ namespace cw
         
 
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, inst->ext_dev->u.a.abuf->srate, inst->ext_dev->u.a.abuf->chN, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, inst->ext_dev->u.a.abuf->srate, inst->ext_dev->u.a.abuf->chN, proc->ctx->framesPerCycle );
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst);
         
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t     rc           = kOkRC;
-        inst_t*  inst         = (inst_t*)ctx->userPtr;
+        inst_t*  inst         = (inst_t*)proc->userPtr;
         abuf_t*  abuf         = nullptr;
 
 
         // verify that a source buffer exists
-        if((rc = var_get(ctx,kOutPId,kAnyChIdx,abuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId,kAnyChIdx,abuf)) != kOkRC )
         {
-          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid audio output buffer.",ctx->label);
+          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid audio output buffer.",proc->label);
         }
         else
         {
@@ -752,22 +752,22 @@ namespace cw
 
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc            = kOkRC;                 //
         inst_t*       inst          = mem::allocZ<inst_t>(); //
         const abuf_t* src_abuf      = nullptr;
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // Register variables and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx,
+        if((rc = var_register_and_get( proc, kAnyChIdx,
                                        kDevLabelPId, "dev_label", kBaseSfxId, inst->dev_label,
                                        kInPId,       "in",        kBaseSfxId, src_abuf)) != kOkRC )
         {
           goto errLabel;
         }
 
-        if((inst->ext_dev = external_device_find( ctx->ctx, inst->dev_label, kAudioDevTypeId, kOutFl )) == nullptr )
+        if((inst->ext_dev = external_device_find( proc->ctx, inst->dev_label, kAudioDevTypeId, kOutFl )) == nullptr )
         {
           rc = cwLogError(kOpFailRC,"The audio output device description '%s' could not be found.", cwStringNullGuard(inst->dev_label));
           goto errLabel;
@@ -777,30 +777,30 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t    rc   = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst);
 
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* src_abuf = nullptr;
 
-        if((rc = var_get(ctx,kInPId,kAnyChIdx,src_abuf)) != kOkRC )
-          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid input connection.",ctx->label);
+        if((rc = var_get(proc,kInPId,kAnyChIdx,src_abuf)) != kOkRC )
+          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid input connection.",proc->label);
         else
         {
           unsigned  chN    = std::min(inst->ext_dev->u.a.abuf->chN,    src_abuf->chN);
@@ -849,21 +849,21 @@ namespace cw
         const char*         filename;
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t rc = kOkRC;
         audiofile::info_t info;
         ftime_t seekSecs;
         inst_t* inst = mem::allocZ<inst_t>();
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
-        if((rc = var_register( ctx, kAnyChIdx, kOnOffFlPId, "on_off", kBaseSfxId)) != kOkRC )
+        if((rc = var_register( proc, kAnyChIdx, kOnOffFlPId, "on_off", kBaseSfxId)) != kOkRC )
         {
           goto errLabel;
         }
 
         // Register variable and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx,
+        if((rc = var_register_and_get( proc, kAnyChIdx,
                                        kFnamePId,    "fname",    kBaseSfxId, inst->filename,
                                        kSeekSecsPId, "seekSecs", kBaseSfxId, seekSecs,
                                        kEofFlPId,    "eofFl",    kBaseSfxId, inst->eofFl )) != kOkRC )
@@ -888,17 +888,17 @@ namespace cw
         cwLogInfo("Audio '%s' srate:%f chs:%i frames:%i %f seconds.",inst->filename,info.srate,info.chCnt,info.frameCnt, info.frameCnt/info.srate );
 
         // create one output audio buffer - with the same configuration as the source audio file
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, info.srate, info.chCnt, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, info.srate, info.chCnt, proc->ctx->framesPerCycle );
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         if((rc = audiofile::close(inst->afH)) != kOkRC )
         {
@@ -910,13 +910,13 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         ftime_t seekSecs = 0;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
-        if((rc = var_get(ctx,kSeekSecsPId,kAnyChIdx,seekSecs)) != kOkRC )
+        if((rc = var_get(proc,kSeekSecsPId,kAnyChIdx,seekSecs)) != kOkRC )
           goto errLabel;
 
         if((rc = seek( inst->afH, (unsigned)lround(seekSecs * audiofile::sampleRate(inst->afH) ) )) != kOkRC )
@@ -930,22 +930,22 @@ namespace cw
         return kOkRC;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t     rc           = kOkRC;
         unsigned actualFrameN = 0;
-        inst_t*  inst         = (inst_t*)ctx->userPtr;
+        inst_t*  inst         = (inst_t*)proc->userPtr;
         abuf_t*  abuf         = nullptr;
         bool     onOffFl      = false;
 
         // get the 'on-off; flag
-        if((rc = var_get(ctx,kOnOffFlPId,kAnyChIdx,onOffFl)) != kOkRC )
+        if((rc = var_get(proc,kOnOffFlPId,kAnyChIdx,onOffFl)) != kOkRC )
           goto errLabel;
 
         // verify that a source buffer exists
-        if((rc = var_get(ctx,kOutPId,kAnyChIdx,abuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId,kAnyChIdx,abuf)) != kOkRC )
         {
-          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid audio output buffer.",ctx->label);
+          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid audio output buffer.",proc->label);
         }
         else
         {
@@ -1004,16 +1004,16 @@ namespace cw
         unsigned            durSmpN;
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc            = kOkRC;                 //
         unsigned      audioFileBits = 0;                     // set audio file sample format to 'float32'.
         inst_t*       inst          = mem::allocZ<inst_t>(); //
         const abuf_t* src_abuf      = nullptr;
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // Register variables and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx,
+        if((rc = var_register_and_get( proc, kAnyChIdx,
                                        kFnamePId, "fname", kBaseSfxId, inst->filename,
                                        kBitsPId,  "bits",  kBaseSfxId, audioFileBits,
                                        kInPId,    "in",    kBaseSfxId, src_abuf )) != kOkRC )
@@ -1032,10 +1032,10 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t    rc   = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         // close the audio file
         if((rc = audiofile::close( inst->afH )) != kOkRC )
@@ -1050,20 +1050,20 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* src_abuf = nullptr;
         
-        if((rc = var_get(ctx,kInPId,kAnyChIdx,src_abuf)) != kOkRC )
-          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid input connection.",ctx->label);
+        if((rc = var_get(proc,kInPId,kAnyChIdx,src_abuf)) != kOkRC )
+          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid input connection.",proc->label);
         else
         {
           sample_t*     chBuf[ src_abuf->chN ];
@@ -1072,7 +1072,7 @@ namespace cw
             chBuf[i] = src_abuf->buf + (i*src_abuf->frameN);
         
           if((rc = audiofile::writeFloat(inst->afH, src_abuf->frameN, src_abuf->chN, chBuf )) != kOkRC )
-            rc = cwLogError(rc,"Audio file write failed on instance: '%s'.", ctx->label );
+            rc = cwLogError(rc,"Audio file write failed on instance: '%s'.", proc->label );
 
           // print a minutes counter
           inst->durSmpN += src_abuf->frameN;          
@@ -1116,63 +1116,63 @@ namespace cw
         coeff_t gain;
       } inst_t;
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* abuf    = nullptr; //
-        ctx->userPtr = mem::allocZ<inst_t>();
+        proc->userPtr = mem::allocZ<inst_t>();
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
         // register the gain 
         for(unsigned i=0; i<abuf->chN; ++i)
-          if((rc = var_register( ctx, i, kGainPId, "gain", kBaseSfxId )) != kOkRC )
+          if((rc = var_register( proc, i, kGainPId, "gain", kBaseSfxId )) != kOkRC )
             goto errLabel;
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
 
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
-        inst_t* inst = (inst_t*)(ctx->userPtr);
+        inst_t* inst = (inst_t*)(proc->userPtr);
         mem::release(inst);
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         coeff_t value = 0;
-        inst_t* inst = (inst_t*)ctx->userPtr;
-        var_get(ctx,kGainPId,0,value);
+        inst_t* inst = (inst_t*)proc->userPtr;
+        var_get(proc,kGainPId,0,value);
         
         if( inst->vgain != value )
         {
           inst->vgain = value;
-          //printf("VALUE GAIN: %s %s : %f\n", ctx->label, var->label, value );
+          //printf("VALUE GAIN: %s %s : %f\n", proc->label, var->label, value );
         }
         return kOkRC;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t     rc           = kOkRC;
         const abuf_t* ibuf = nullptr;
         abuf_t*       obuf = nullptr;
-        inst_t*  inst = (inst_t*)(ctx->userPtr);
+        inst_t*  inst = (inst_t*)(proc->userPtr);
 
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
           goto errLabel;
 
         // for each channel
@@ -1182,7 +1182,7 @@ namespace cw
           sample_t* osig = obuf->buf + i*obuf->frameN;
           sample_t  gain = 1;
           
-          var_get(ctx,kGainPId,i,gain);
+          var_get(proc,kGainPId,i,gain);
 
           // apply the gain
           for(unsigned j=0; j<ibuf->frameN; ++j)
@@ -1191,8 +1191,8 @@ namespace cw
           if( i==0 && gain != inst->gain )
           {
             inst->gain = gain;
-            //printf("EXEC GAIN: %s %f\n",ctx->label,gain);
-            //instance_print(ctx);
+            //printf("EXEC GAIN: %s %f\n",proc->label,gain);
+            //proc_print(proc);
           }
         }  
         
@@ -1233,16 +1233,16 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc   = kOkRC;        
         const abuf_t* abuf = nullptr; //        
         inst_t*       inst = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId, abuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId, abuf )) != kOkRC )
           goto errLabel;
 
         if( abuf->chN )
@@ -1251,20 +1251,20 @@ namespace cw
           
           inst->chSelMap = mem::allocZ<bool>(abuf->chN);
           
-          if((rc = var_channel_count(ctx,"select",kBaseSfxId,selChN)) != kOkRC )
+          if((rc = var_channel_count(proc,"select",kBaseSfxId,selChN)) != kOkRC )
             goto errLabel;
           
           // register the gain 
           for(unsigned i=0; i<abuf->chN; ++i)
           {
             if( i < selChN )
-              if((rc = var_register_and_get( ctx, i, kSelectPId, "select", kBaseSfxId, inst->chSelMap[i] )) != kOkRC )
+              if((rc = var_register_and_get( proc, i, kSelectPId, "select", kBaseSfxId, inst->chSelMap[i] )) != kOkRC )
                 goto errLabel;
 
             if( inst->chSelMap[i] )
             {
               // register an output gain control
-              if((rc = var_register( ctx, inst->outChN, kGainPId, "gain", kBaseSfxId)) != kOkRC )
+              if((rc = var_register( proc, inst->outChN, kGainPId, "gain", kBaseSfxId)) != kOkRC )
                 goto errLabel;
 
               // count the number of selected channels to determine the count of output channels
@@ -1274,20 +1274,20 @@ namespace cw
           
           // create the output audio buffer
           if( inst->outChN == 0 )
-            cwLogWarning("The audio split instance '%s' has no selected channels.",ctx->label);
+            cwLogWarning("The audio split instance '%s' has no selected channels.",proc->label);
           else
-            rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
+            rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
         }
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst->chSelMap);
 
@@ -1296,28 +1296,28 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc       = kOkRC;
         const abuf_t* ibuf     = nullptr;
         abuf_t*       obuf     = nullptr;
-        inst_t*       inst     = (inst_t*)ctx->userPtr;
+        inst_t*       inst     = (inst_t*)proc->userPtr;
         unsigned      outChIdx = 0;
         
         if( inst->outChN )
         {
           // get the src buffer
-          if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+          if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
             goto errLabel;
 
           // get the dst buffer
-          if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+          if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
             goto errLabel;
 
           // for each channel          
@@ -1329,7 +1329,7 @@ namespace cw
               sample_t* osig = obuf->buf + outChIdx * obuf->frameN;
               sample_t  gain = 1;
           
-              var_get(ctx,kGainPId,outChIdx,gain);
+              var_get(proc,kGainPId,outChIdx,gain);
 
               // apply the gain
               for(unsigned j=0; j<ibuf->frameN; ++j)
@@ -1374,16 +1374,16 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc   = kOkRC;        
         const abuf_t* abuf = nullptr; //        
         inst_t*       inst = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
         if( abuf->chN )
@@ -1393,13 +1393,13 @@ namespace cw
           // register the gain 
           for(unsigned i=0; i<abuf->chN; ++i)
           {
-            if((rc = var_register_and_get( ctx, i, kDuplicatePId, "duplicate", kBaseSfxId, inst->chDuplMap[i] )) != kOkRC )
+            if((rc = var_register_and_get( proc, i, kDuplicatePId, "duplicate", kBaseSfxId, inst->chDuplMap[i] )) != kOkRC )
               goto errLabel;
 
             if( inst->chDuplMap[i] )
             {
               // register an input gain control
-              if((rc = var_register( ctx, inst->outChN, kGainPId, "gain", kBaseSfxId)) != kOkRC )
+              if((rc = var_register( proc, inst->outChN, kGainPId, "gain", kBaseSfxId)) != kOkRC )
                 goto errLabel;
 
               // count the number of selected channels to determine the count of output channels
@@ -1409,20 +1409,20 @@ namespace cw
           
           // create the output audio buffer
           if( inst->outChN == 0 )
-            cwLogWarning("The audio split instance '%s' has no selected channels.",ctx->label);
+            cwLogWarning("The audio split instance '%s' has no selected channels.",proc->label);
           else
-            rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
+            rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, inst->outChN, abuf->frameN );
         }
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst->chDuplMap);
 
@@ -1431,28 +1431,28 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc       = kOkRC;
         const abuf_t* ibuf     = nullptr;
         abuf_t*       obuf     = nullptr;
-        inst_t*       inst     = (inst_t*)ctx->userPtr;
+        inst_t*       inst     = (inst_t*)proc->userPtr;
         unsigned      outChIdx = 0;
         
         if( inst->outChN )
         {
           // get the src buffer
-          if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+          if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
             goto errLabel;
 
           // get the dst buffer
-          if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+          if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
             goto errLabel;
 
           // for each input channel          
@@ -1461,7 +1461,7 @@ namespace cw
             sample_t* isig = ibuf->buf + i * ibuf->frameN;
             sample_t  gain = 1;
           
-            var_get(ctx,kGainPId,i,gain);
+            var_get(proc,kGainPId,i,gain);
             
             for(unsigned j=0; j<inst->chDuplMap[i]; ++j )
             {            
@@ -1508,7 +1508,7 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         unsigned      outChN = 0;
@@ -1517,7 +1517,7 @@ namespace cw
         
         inst_t*       inst = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
         
         for(unsigned i=0; 1; ++i)
         {
@@ -1530,11 +1530,11 @@ namespace cw
           // TODO: allow non-contiguous source labels
           
           // the source labels must be contiguous
-          if( !var_has_value( ctx, label, kBaseSfxId, kAnyChIdx ) )
+          if( !var_has_value( proc, label, kBaseSfxId, kAnyChIdx ) )
             break;
           
           // get the source audio buffer
-          if((rc = var_register_and_get(ctx, kAnyChIdx,kInBasePId+i,label,kBaseSfxId, abuf )) != kOkRC )
+          if((rc = var_register_and_get(proc, kAnyChIdx,kInBasePId+i,label,kBaseSfxId, abuf )) != kOkRC )
           {
             goto errLabel;
           }
@@ -1558,29 +1558,29 @@ namespace cw
 
         // register the gain 
         for(unsigned i=0; i<outChN; ++i)
-          if((rc = var_register( ctx, i, kGainPId, "gain", kBaseSfxId )) != kOkRC )
+          if((rc = var_register( proc, i, kGainPId, "gain", kBaseSfxId )) != kOkRC )
             goto errLabel;
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, outChN, frameN );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srate, outChN, frameN );
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       { 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         
         mem::release(inst);
 
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       { return kOkRC; }
 
-      unsigned _exec( instance_t* ctx, const abuf_t* ibuf, abuf_t* obuf, unsigned outChIdx )
+      unsigned _exec( proc_t* proc, const abuf_t* ibuf, abuf_t* obuf, unsigned outChIdx )
       {
         // for each channel          
         for(unsigned i=0; i<ibuf->chN  && outChIdx<obuf->chN; ++i)
@@ -1590,7 +1590,7 @@ namespace cw
           sample_t* osig = obuf->buf + outChIdx * obuf->frameN;
           sample_t  gain = 1;
           
-          var_get(ctx,kGainPId,outChIdx,gain);
+          var_get(proc,kGainPId,outChIdx,gain);
 
           // apply the gain
           for(unsigned j=0; j<ibuf->frameN; ++j)
@@ -1603,7 +1603,7 @@ namespace cw
       }
 
       /*
-        rc_t exec( instance_t* ctx )
+        rc_t exec( proc_t* proc )
         {
         rc_t          rc    = kOkRC;
         const abuf_t* ibuf0 = nullptr;
@@ -1611,17 +1611,17 @@ namespace cw
         abuf_t*       obuf  = nullptr;
         unsigned      oChIdx = 0;
         
-        if((rc = var_get(ctx,kIn0PId, kAnyChIdx, ibuf0 )) != kOkRC )
+        if((rc = var_get(proc,kIn0PId, kAnyChIdx, ibuf0 )) != kOkRC )
         goto errLabel;
 
-        if((rc = var_get(ctx,kIn1PId, kAnyChIdx, ibuf1 )) != kOkRC )
+        if((rc = var_get(proc,kIn1PId, kAnyChIdx, ibuf1 )) != kOkRC )
         goto errLabel;
         
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
         goto errLabel;
 
-        oChIdx = _exec( ctx, ibuf0, obuf, oChIdx );
-        oChIdx = _exec( ctx, ibuf1, obuf, oChIdx );
+        oChIdx = _exec( proc, ibuf0, obuf, oChIdx );
+        oChIdx = _exec( proc, ibuf1, obuf, oChIdx );
 
         assert( oChIdx == obuf->chN );
 
@@ -1630,24 +1630,24 @@ namespace cw
         }
       */
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc    = kOkRC;
-        inst_t*       inst     = (inst_t*)ctx->userPtr;
+        inst_t*       inst     = (inst_t*)proc->userPtr;
         abuf_t*       obuf  = nullptr;
         unsigned      oChIdx = 0;
         
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
           goto errLabel;
 
         for(unsigned i=0; i<inst->srcN; ++i)
         {
           const abuf_t* ibuf = nullptr;
 
-          if((rc = var_get(ctx,kInBasePId+i, kAnyChIdx, ibuf )) != kOkRC )
+          if((rc = var_get(proc,kInBasePId+i, kAnyChIdx, ibuf )) != kOkRC )
             goto errLabel;
 
-          oChIdx = _exec( ctx, ibuf, obuf, oChIdx );
+          oChIdx = _exec( proc, ibuf, obuf, oChIdx );
         }
 
       errLabel:
@@ -1684,7 +1684,7 @@ namespace cw
       } inst_t;
 
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* abuf0  = nullptr; //
@@ -1693,7 +1693,7 @@ namespace cw
         double dum;
         
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,
+        if((rc = var_register_and_get(proc, kAnyChIdx,
                                       kIn0PId,"in0",kBaseSfxId,abuf0,
                                       kIn1PId,"in1",kBaseSfxId,abuf1 )) != kOkRC )
         {
@@ -1705,28 +1705,28 @@ namespace cw
         outChN = std::max(abuf0->chN, abuf1->chN);
 
         // register the gain
-        var_register_and_get( ctx, kAnyChIdx, kGain0PId, "gain0", kBaseSfxId, dum );
-        var_register_and_get( ctx, kAnyChIdx, kGain1PId, "gain1", kBaseSfxId, dum );
+        var_register_and_get( proc, kAnyChIdx, kGain0PId, "gain0", kBaseSfxId, dum );
+        var_register_and_get( proc, kAnyChIdx, kGain1PId, "gain1", kBaseSfxId, dum );
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf0->srate, outChN, abuf0->frameN );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf0->srate, outChN, abuf0->frameN );
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       { return kOkRC; }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       { return kOkRC; }
 
-      rc_t _mix( instance_t* ctx, unsigned inPId, unsigned gainPId, abuf_t* obuf )
+      rc_t _mix( proc_t* proc, unsigned inPId, unsigned gainPId, abuf_t* obuf )
       {
         rc_t          rc   = kOkRC;
         const abuf_t* ibuf = nullptr;
         
-        if((rc = var_get(ctx, inPId, kAnyChIdx, ibuf )) != kOkRC )
+        if((rc = var_get(proc, inPId, kAnyChIdx, ibuf )) != kOkRC )
           goto errLabel;
 
 
@@ -1740,7 +1740,7 @@ namespace cw
             sample_t*       osig = obuf->buf + i*obuf->frameN;
             coeff_t          gain = 1;
 
-            if((rc = var_get(ctx, gainPId, kAnyChIdx, gain)) != kOkRC )
+            if((rc = var_get(proc, gainPId, kAnyChIdx, gain)) != kOkRC )
               goto errLabel;
             
             for(unsigned j=0; j<obuf->frameN; ++j)
@@ -1753,26 +1753,26 @@ namespace cw
         
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc    = kOkRC;
         abuf_t*       obuf  = nullptr;
         //const abuf_t* ibuf0 = nullptr;
         //const abuf_t* ibuf1 = nullptr;
 
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
           goto errLabel;
 
-        //if((rc = var_get(ctx,kIn0PId, kAnyChIdx, ibuf0 )) != kOkRC )
+        //if((rc = var_get(proc,kIn0PId, kAnyChIdx, ibuf0 )) != kOkRC )
         //  goto errLabel;
         
-        //if((rc = var_get(ctx,kIn1PId, kAnyChIdx, ibuf1 )) != kOkRC )
+        //if((rc = var_get(proc,kIn1PId, kAnyChIdx, ibuf1 )) != kOkRC )
         //  goto errLabel;
 
         vop::zero(obuf->buf, obuf->frameN*obuf->chN );
         
-        _mix( ctx, kIn0PId, kGain0PId, obuf );
-        _mix( ctx, kIn1PId, kGain1PId, obuf );
+        _mix( proc, kIn0PId, kGain0PId, obuf );
+        _mix( proc, kIn1PId, kGain1PId, obuf );
         
       errLabel:
         return rc;
@@ -1812,7 +1812,7 @@ namespace cw
         double *phaseA;
       } inst_t;
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t     rc    = kOkRC;
         inst_t*  inst  = mem::allocZ<inst_t>();
@@ -1823,10 +1823,10 @@ namespace cw
         coeff_t   phase;
         coeff_t   dc;
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // Register variables and get their current value
-        if((rc = var_register_and_get( ctx, kAnyChIdx,
+        if((rc = var_register_and_get( proc, kAnyChIdx,
                                        kChCntPid, "chCnt", kBaseSfxId, chCnt,
                                        kSratePId, "srate", kBaseSfxId, srate)) != kOkRC )
         {
@@ -1840,14 +1840,14 @@ namespace cw
 
         // if no sample rate was given then use the system sample rate.
         if( srate == 0 )
-          srate = ctx->ctx->sample_rate;
+          srate = proc->ctx->sample_rate;
         
         // register each oscillator variable
         for(unsigned i=0; i<chCnt; ++i)
         {
           unsigned ch_srate = 0;
           
-          if((rc = var_register_and_get( ctx, i,
+          if((rc = var_register_and_get( proc, i,
                                          kSratePId,  "srate", kBaseSfxId, ch_srate,
                                          kFreqHzPId, "hz",    kBaseSfxId, hz,
                                          kPhasePId,  "phase", kBaseSfxId, phase,
@@ -1859,15 +1859,15 @@ namespace cw
 
           // if no srate was set on this channel then use the default sample rate
           if( ch_srate == 0 )
-            if((rc = var_set(ctx,kSratePId,i,srate)) != kOkRC )
+            if((rc = var_set(proc,kSratePId,i,srate)) != kOkRC )
               goto errLabel;
         }
 
-        printf("%s: sr:%f hz:%f phs:%f dc:%f gain:%f\n",ctx->label,srate,hz,phase,dc,gain);
+        //printf("%s: sr:%f hz:%f phs:%f dc:%f gain:%f\n",proc->label,srate,hz,phase,dc,gain);
         
         // create one output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId,
-                                   kOutPId, kAnyChIdx, srate, chCnt, ctx->ctx->framesPerCycle );
+        rc = var_register_and_set( proc, "out", kBaseSfxId,
+                                   kOutPId, kAnyChIdx, srate, chCnt, proc->ctx->framesPerCycle );
 
         inst->phaseA = mem::allocZ<double>( chCnt );
         
@@ -1876,11 +1876,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst->phaseA);
         mem::release(inst);
@@ -1888,32 +1888,32 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t     rc           = kOkRC;
-        inst_t*  inst         = (inst_t*)ctx->userPtr;
+        inst_t*  inst         = (inst_t*)proc->userPtr;
         abuf_t*  abuf         = nullptr;
 
         // get the output signal buffer
-        if((rc = var_get(ctx,kOutPId,kAnyChIdx,abuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId,kAnyChIdx,abuf)) != kOkRC )
         {
-          rc = cwLogError(kInvalidStateRC,"The Sine Tone instance '%s' does not have a valid audio output buffer.",ctx->label);
+          rc = cwLogError(kInvalidStateRC,"The Sine Tone instance '%s' does not have a valid audio output buffer.",proc->label);
         }
         else
         {
           for(unsigned i=0; i<abuf->chN; ++i)
           {
-            coeff_t    gain  = val_get<coeff_t>( ctx, kGainPId, i );
-            coeff_t    hz    = val_get<coeff_t>( ctx, kFreqHzPId, i );
-            coeff_t    phase = val_get<coeff_t>( ctx, kPhasePId, i );
-            coeff_t    dc    = val_get<coeff_t>( ctx, kDcPId, i );
-            srate_t   srate = val_get<srate_t>(ctx, kSratePId, i );                        
+            coeff_t    gain  = val_get<coeff_t>( proc, kGainPId, i );
+            coeff_t    hz    = val_get<coeff_t>( proc, kFreqHzPId, i );
+            coeff_t    phase = val_get<coeff_t>( proc, kPhasePId, i );
+            coeff_t    dc    = val_get<coeff_t>( proc, kDcPId, i );
+            srate_t   srate = val_get<srate_t>(proc, kSratePId, i );                        
             sample_t* v     = abuf->buf + (i*abuf->frameN);
             
             for(unsigned j=0; j<abuf->frameN; ++j)
@@ -1967,15 +1967,15 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* srcBuf = nullptr; //
         unsigned      flags  = 0;
         inst_t*       inst   = mem::allocZ<inst_t>();
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
-        if((rc = var_register_and_get( ctx, kAnyChIdx,kInPId, "in", kBaseSfxId, srcBuf )) != kOkRC )
+        if((rc = var_register_and_get( proc, kAnyChIdx,kInPId, "in", kBaseSfxId, srcBuf )) != kOkRC )
         {
           cwLogError(kInvalidArgRC,"Unable to access the 'src' buffer.");
         }
@@ -2001,7 +2001,7 @@ namespace cw
             unsigned hopSmpN = 0;
             bool hzFl = false;
             
-            if((rc = var_register_and_get( ctx, i,
+            if((rc = var_register_and_get( proc, i,
                                            kMaxWndSmpNPId, "maxWndSmpN", kBaseSfxId, maxWndSmpN,
                                            kWndSmpNPId, "wndSmpN",       kBaseSfxId, wndSmpN,
                                            kHopSmpNPId, "hopSmpN",       kBaseSfxId, hopSmpN,
@@ -2010,9 +2010,9 @@ namespace cw
               goto errLabel;
             }
             
-            if((rc = create( inst->pvA[i], ctx->ctx->framesPerCycle, srcBuf->srate, maxWndSmpN, wndSmpN, hopSmpN, flags )) != kOkRC )
+            if((rc = create( inst->pvA[i], proc->ctx->framesPerCycle, srcBuf->srate, maxWndSmpN, wndSmpN, hopSmpN, flags )) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The PV analysis object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The PV analysis object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
 
@@ -2027,7 +2027,7 @@ namespace cw
 
         
           // create the fbuf 'out'
-          if((rc = var_register_and_set(ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, maxBinNV, binNV, hopNV, magV, phsV, hzV )) != kOkRC )
+          if((rc = var_register_and_set(proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, maxBinNV, binNV, hopNV, magV, phsV, hzV )) != kOkRC )
           {
             cwLogError(kOpFailRC,"The output freq. buffer could not be created.");
             goto errLabel;
@@ -2038,11 +2038,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         
         for(unsigned i=0; i<inst->pvN; ++i)
           destroy(inst->pvA[i]);
@@ -2053,10 +2053,10 @@ namespace cw
         return rc;
       }
       
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         if( var->chIdx != kAnyChIdx && var->chIdx < inst->pvN )
         {
@@ -2077,24 +2077,24 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* srcBuf = nullptr;
         fbuf_t*       dstBuf = nullptr;
 
         // verify that a source buffer exists
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",proc->label);
           goto errLabel;
         }
 
         // verify that the dst buffer exits
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid output.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid output.",proc->label);
           goto errLabel;
         }
 
@@ -2151,14 +2151,14 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const fbuf_t* srcBuf = nullptr; //
         inst_t*       inst   = mem::allocZ<inst_t>();
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
-        if((rc = var_register_and_get( ctx, kAnyChIdx,kInPId, "in", kBaseSfxId, srcBuf)) != kOkRC )
+        if((rc = var_register_and_get( proc, kAnyChIdx,kInPId, "in", kBaseSfxId, srcBuf)) != kOkRC )
         {
           goto errLabel;
         }
@@ -2174,29 +2174,29 @@ namespace cw
           {
             unsigned wndSmpN = (srcBuf->binN_V[i]-1)*2;
             
-            if((rc = create( inst->pvA[i], ctx->ctx->framesPerCycle, srcBuf->srate, wndSmpN, srcBuf->hopSmpN_V[i] )) != kOkRC )
+            if((rc = create( inst->pvA[i], proc->ctx->framesPerCycle, srcBuf->srate, wndSmpN, srcBuf->hopSmpN_V[i] )) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The PV synthesis object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The PV synthesis object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
           }
 
-          if((rc = var_register( ctx, kAnyChIdx, kInPId, "in", kBaseSfxId)) != kOkRC )
+          if((rc = var_register( proc, kAnyChIdx, kInPId, "in", kBaseSfxId)) != kOkRC )
             goto errLabel;
 
           // create the abuf 'out'
-          rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, ctx->ctx->framesPerCycle );
+          rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, proc->ctx->framesPerCycle );
         }
         
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->pvN; ++i)
           destroy(inst->pvA[i]);
         
@@ -2206,25 +2206,25 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const fbuf_t* srcBuf = nullptr;
         abuf_t*       dstBuf = nullptr;
         
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
           goto errLabel;
         
         for(unsigned i=0; i<srcBuf->chN; ++i)
@@ -2282,18 +2282,18 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const fbuf_t* srcBuf = nullptr; //
         inst_t*       inst   = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",proc->label);
           goto errLabel;
         }
         else
@@ -2306,7 +2306,7 @@ namespace cw
           const fd_sample_t* phsV[ srcBuf->chN ];
           const fd_sample_t*  hzV[ srcBuf->chN ];
 
-          //if((rc = var_register(ctx, kAnyChIdx, kInPId, "in")) != kOkRC )
+          //if((rc = var_register(proc, kAnyChIdx, kInPId, "in")) != kOkRC )
           //  goto errLabel;
         
           // create a spec_dist object for each input channel
@@ -2314,7 +2314,7 @@ namespace cw
           {
             if((rc = create( inst->sdA[i], srcBuf->binN_V[i] )) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The 'spec dist' object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The 'spec dist' object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
 
@@ -2325,7 +2325,7 @@ namespace cw
 
             spec_dist_t* sd = inst->sdA[i];
 
-            if((rc = var_register_and_get( ctx, i,
+            if((rc = var_register_and_get( proc, i,
                                            kBypassPId,   "bypass",   kBaseSfxId, sd->bypassFl,
                                            kCeilingPId,  "ceiling",  kBaseSfxId, sd->ceiling,
                                            kExpoPId,     "expo",     kBaseSfxId, sd->expo,
@@ -2340,7 +2340,7 @@ namespace cw
           }
           
           // create the output buffer
-          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->maxBinN_V, srcBuf->binN_V, srcBuf->hopSmpN_V, magV, phsV, hzV )) != kOkRC )
+          if((rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->maxBinN_V, srcBuf->binN_V, srcBuf->hopSmpN_V, magV, phsV, hzV )) != kOkRC )
             goto errLabel;
         }
         
@@ -2348,11 +2348,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->sdN; ++i)
           destroy(inst->sdA[i]);
         
@@ -2362,10 +2362,10 @@ namespace cw
         return rc;
       }
       
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t    rc   = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         if( var->chIdx != kAnyChIdx && var->chIdx < inst->sdN )
         {
@@ -2383,7 +2383,7 @@ namespace cw
             case kLwrSlopePId: rc = var_get( var, val ); sd->lwrSlope = val; break;
             case kMixPId:      rc = var_get( var, val ); sd->mix = val;     break;
             default:
-              cwLogWarning("Unhandled variable id '%i' on instance: %s.", var->vid, ctx->label );
+              cwLogWarning("Unhandled variable id '%i' on instance: %s.", var->vid, proc->label );
           }
 
           //printf("%i sd: ceil:%f expo:%f thresh:%f upr:%f lwr:%f mix:%f : rc:%i val:%f var:%s \n",
@@ -2393,20 +2393,20 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const fbuf_t* srcBuf = nullptr;
         fbuf_t*       dstBuf = nullptr;
         unsigned      chN    = 0;
         
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
           goto errLabel;
 
         chN = std::min(srcBuf->chN,inst->sdN);
@@ -2470,18 +2470,18 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* srcBuf = nullptr; //
         inst_t*       inst   = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",proc->label);
           goto errLabel;
         }
         else
@@ -2499,7 +2499,7 @@ namespace cw
 
 
             // get the compressor variable values
-            if((rc = var_register_and_get( ctx, i,
+            if((rc = var_register_and_get( proc, i,
                                            kBypassPId,   "bypass",    kBaseSfxId, bypassFl,
                                            kInGainPId,   "igain",     kBaseSfxId, igain,
                                            kThreshPId,   "thresh",    kBaseSfxId, thresh,
@@ -2516,14 +2516,14 @@ namespace cw
             // create the compressor instance
             if((rc = dsp::compressor::create( inst->cmpA[i], srcBuf->srate, srcBuf->frameN, igain, maxWnd_ms, wnd_ms, thresh, ratio, atk_ms, rls_ms, ogain, bypassFl)) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The 'compressor' object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The 'compressor' object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
                 
           }
           
           // create the output audio buffer
-          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
+          if((rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
             goto errLabel;
         }
         
@@ -2531,11 +2531,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->cmpN; ++i)
           destroy(inst->cmpA[i]);
         
@@ -2545,10 +2545,10 @@ namespace cw
         return rc;
       }
       
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t    rc   = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         ftime_t  tmp;
 
         if( var->chIdx != kAnyChIdx && var->chIdx < inst->cmpN )
@@ -2567,7 +2567,7 @@ namespace cw
             case kWndMsPId:    rc = var_get( var, tmp ); dsp::compressor::set_rms_wnd_ms(c, tmp ); break;
             case kMaxWndMsPId: break;
             default:
-              cwLogWarning("Unhandled variable id '%i' on instance: %s.", var->vid, ctx->label );
+              cwLogWarning("Unhandled variable id '%i' on instance: %s.", var->vid, proc->label );
           }
           //printf("cmp byp:%i igain:%f ogain:%f rat:%f thresh:%f atk:%i rls:%i wnd:%i : rc:%i val:%f\n",
           //       c->bypassFl, c->inGain, c->outGain,c->ratio_num,c->threshDb,c->atkSmp,c->rlsSmp,c->rmsWndCnt,rc,tmp);
@@ -2577,20 +2577,20 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* srcBuf = nullptr;
         abuf_t*       dstBuf = nullptr;
         unsigned      chN    = 0;
         
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
           goto errLabel;
 
         chN = std::min(srcBuf->chN,inst->cmpN);
@@ -2607,15 +2607,15 @@ namespace cw
         return rc;
       }
 
-      rc_t report( instance_t* ctx )
+      rc_t report( proc_t* proc )
       {
         rc_t rc = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->cmpN; ++i)
         {
           compressor_t* c = inst->cmpA[i];
           cwLogInfo("%s ch:%i : sr:%f bypass:%i procSmpN:%i igain:%f threshdb:%f ratio:%f atkSmp:%i rlsSmp:%i ogain:%f rmsWndN:%i maxRmsWndN%i",
-                    ctx->label,i,c->srate,c->bypassFl,c->procSmpCnt,c->inGain,c->threshDb,c->ratio_num,c->atkSmp,c->rlsSmp,c->outGain,c->rmsWndCnt,c->rmsWndAllocCnt
+                    proc->label,i,c->srate,c->bypassFl,c->procSmpCnt,c->inGain,c->threshDb,c->ratio_num,c->atkSmp,c->rlsSmp,c->outGain,c->rmsWndCnt,c->rmsWndAllocCnt
                     );
         }
         
@@ -2659,18 +2659,18 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* srcBuf = nullptr; //
         inst_t*       inst   = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",proc->label);
           goto errLabel;
         }
         else
@@ -2687,7 +2687,7 @@ namespace cw
 
 
             // get the limiter variable values
-            if((rc = var_register_and_get( ctx, i,
+            if((rc = var_register_and_get( proc, i,
                                            kBypassPId,   "bypass",    kBaseSfxId, bypassFl,
                                            kInGainPId,   "igain",     kBaseSfxId, igain,
                                            kThreshPId,   "thresh",    kBaseSfxId, thresh,
@@ -2699,14 +2699,14 @@ namespace cw
             // create the limiter instance
             if((rc = dsp::limiter::create( inst->limA[i], srcBuf->srate, srcBuf->frameN, igain, thresh, ogain, bypassFl)) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The 'limiter' object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The 'limiter' object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
                 
           }
           
           // create the output audio buffer
-          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
+          if((rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
             goto errLabel;
         }
         
@@ -2714,11 +2714,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->limN; ++i)
           destroy(inst->limA[i]);
         
@@ -2728,10 +2728,10 @@ namespace cw
         return rc;
       }
       
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t    rc   = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         coeff_t  rtmp;
         bool btmp;
 
@@ -2746,7 +2746,7 @@ namespace cw
             case kOutGainPId:  rc = var_get( var, rtmp ); c->ogain=rtmp;  break;
             case kThreshPId:   rc = var_get( var, rtmp ); c->thresh=rtmp; break;
             default:
-              cwLogWarning("Unhandled variable id '%i' on instance: %s.", var->vid, ctx->label );
+              cwLogWarning("Unhandled variable id '%i' on instance: %s.", var->vid, proc->label );
           }
           //printf("lim byp:%i igain:%f ogain:%f rat:%f thresh:%f atk:%i rls:%i wnd:%i : rc:%i val:%f\n",
           //       c->bypassFl, c->inGain, c->outGain,c->ratio_num,c->threshDb,c->atkSmp,c->rlsSmp,c->rmsWndCnt,rc,tmp);
@@ -2756,20 +2756,20 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* srcBuf = nullptr;
         abuf_t*       dstBuf = nullptr;
         unsigned      chN    = 0;
         
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
           goto errLabel;
 
         chN = std::min(srcBuf->chN,inst->limN);
@@ -2786,15 +2786,15 @@ namespace cw
         return rc;
       }
 
-      rc_t report( instance_t* ctx )
+      rc_t report( proc_t* proc )
       {
         rc_t rc = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->limN; ++i)
         {
           limiter_t* c = inst->limA[i];
           cwLogInfo("%s ch:%i : bypass:%i procSmpN:%i igain:%f threshdb:%f  ogain:%f",
-                    ctx->label,i,c->bypassFl,c->procSmpCnt,c->igain,c->thresh,c->ogain );
+                    proc->label,i,c->bypassFl,c->procSmpCnt,c->igain,c->thresh,c->ogain );
         }
         
         return rc;
@@ -2831,7 +2831,7 @@ namespace cw
         unsigned* idxV;           // idxV[ chN ] per channel i/o idx
       } inst_t;
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc         = kOkRC;
         const abuf_t* abuf       = nullptr; //
@@ -2839,10 +2839,10 @@ namespace cw
         ftime_t        delayMs    = 0;
         ftime_t        maxDelayMs = 0;
 
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
 
@@ -2852,7 +2852,7 @@ namespace cw
         // register the gain 
         for(unsigned i=0; i<abuf->chN; ++i)
         {
-          if((rc = var_register_and_get( ctx, i,
+          if((rc = var_register_and_get( proc, i,
                                          kMaxDelayMsPId, "maxDelayMs", kBaseSfxId, maxDelayMs,
                                          kDelayMsPId,    "delayMs",    kBaseSfxId, delayMs)) != kOkRC )
           {
@@ -2861,7 +2861,7 @@ namespace cw
 
           if( delayMs > maxDelayMs )
           {
-            cwLogWarning("'delayMs' (%i) is being reduced to 'maxDelayMs' (%i) on the delay instance:%s.",delayMs,maxDelayMs,ctx->label);
+            cwLogWarning("'delayMs' (%i) is being reduced to 'maxDelayMs' (%i) on the delay instance:%s.",delayMs,maxDelayMs,proc->label);
             delayMs = maxDelayMs;
           }
 
@@ -2874,16 +2874,16 @@ namespace cw
         inst->delayBuf = abuf_create( abuf->srate, abuf->chN, inst->maxDelayFrameN );
         
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
 
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
 
         mem::release(inst->cntV);
         mem::release(inst->idxV);
@@ -2893,15 +2893,15 @@ namespace cw
         return kOkRC;
       }
 
-      rc_t _update_delay( instance_t* ctx, variable_t* var )
+      rc_t _update_delay( proc_t* proc, variable_t* var )
       {
         rc_t     rc          = kOkRC;
-        inst_t*  inst        = (inst_t*)ctx->userPtr;
+        inst_t*  inst        = (inst_t*)proc->userPtr;
         abuf_t*  ibuf        = nullptr;
         ftime_t   delayMs     = 0;
         unsigned delayFrameN = 0;
         
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
           goto errLabel;
 
         if((rc = var_get( var, delayMs )) != kOkRC )
@@ -2927,34 +2927,34 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         
         switch( var->vid )
         {
           case kDelayMsPId:
-            rc = _update_delay(ctx,var);
+            rc = _update_delay(proc,var);
             break;
         }
 
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc   = kOkRC;
-        inst_t*       inst = (inst_t*)ctx->userPtr;
+        inst_t*       inst = (inst_t*)proc->userPtr;
         const abuf_t* ibuf = nullptr;
         abuf_t*       obuf = nullptr;
         abuf_t*       dbuf = inst->delayBuf;
 
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
           goto errLabel;
 
         // for each channel
@@ -3023,18 +3023,18 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* srcBuf = nullptr; //
         inst_t*       inst   = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",proc->label);
           goto errLabel;
         }
         else
@@ -3051,7 +3051,7 @@ namespace cw
 
 
             // get the dc_filter variable values
-            if((rc = var_register_and_get( ctx, i,
+            if((rc = var_register_and_get( proc, i,
                                            kBypassPId,   "bypass",    kBaseSfxId, bypassFl,
                                            kGainPId,     "gain",      kBaseSfxId, gain )) != kOkRC )
             {
@@ -3061,14 +3061,14 @@ namespace cw
             // create the dc_filter instance
             if((rc = dsp::dc_filter::create( inst->dcfA[i], srcBuf->srate, srcBuf->frameN, gain, bypassFl)) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The 'dc_filter' object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The 'dc_filter' object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
                 
           }
           
           // create the output audio buffer
-          if((rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
+          if((rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, srcBuf->srate, srcBuf->chN, srcBuf->frameN )) != kOkRC )
             goto errLabel;
         }
         
@@ -3076,11 +3076,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->dcfN; ++i)
           destroy(inst->dcfA[i]);
         
@@ -3090,33 +3090,33 @@ namespace cw
         return rc;
       }
       
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         return kOkRC;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* srcBuf = nullptr;
         abuf_t*       dstBuf = nullptr;
         unsigned      chN    = 0;
         
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, dstBuf)) != kOkRC )
           goto errLabel;
 
         chN = std::min(srcBuf->chN,inst->dcfN);
        
         for(unsigned i=0; i<chN; ++i)
         {
-          coeff_t gain   = val_get<coeff_t>( ctx, kGainPId,   i );
-          bool bypassFl = val_get<bool>(   ctx, kBypassPId, i );
+          coeff_t gain   = val_get<coeff_t>( proc, kGainPId,   i );
+          bool bypassFl = val_get<bool>(   proc, kBypassPId, i );
 
           dsp::dc_filter::set( inst->dcfA[i], gain, bypassFl );
           
@@ -3127,15 +3127,15 @@ namespace cw
         return rc;
       }
 
-      rc_t report( instance_t* ctx )
+      rc_t report( proc_t* proc )
       {
         rc_t rc = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->dcfN; ++i)
         {
           dc_filter_t* c = inst->dcfA[i];
           cwLogInfo("%s ch:%i : bypass:%i gain:%f",
-                    ctx->label,i,c->bypassFl,c->gain );
+                    proc->label,i,c->bypassFl,c->gain );
         }
         
         return rc;
@@ -3179,18 +3179,18 @@ namespace cw
       } inst_t;
     
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* srcBuf = nullptr; //
         inst_t*       inst   = mem::allocZ<inst_t>();
         
-        ctx->userPtr = inst;
+        proc->userPtr = inst;
 
         // verify that a source buffer exists
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,srcBuf )) != kOkRC )
         {
-          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",ctx->label);
+          rc = cwLogError(rc,"The instance '%s' does not have a valid input connection.",proc->label);
           goto errLabel;
         }
         else
@@ -3207,7 +3207,7 @@ namespace cw
             bool dbFl;
 	    
             // get the audio_meter variable values
-            if((rc = var_register_and_get( ctx, i,
+            if((rc = var_register_and_get( proc, i,
                                            kDbFlPId,   "dbFl",    kBaseSfxId, dbFl,
                                            kWndMsPId, "wndMs",    kBaseSfxId, wndMs,
                                            kPeakDbPId, "peakDb",  kBaseSfxId, peakThreshDb )) != kOkRC )
@@ -3216,7 +3216,7 @@ namespace cw
             }
 
             // get the audio_meter variable values
-            if((rc = var_register( ctx, i,
+            if((rc = var_register( proc, i,
                                    kOutPId,   "out",     kBaseSfxId,
                                    kPeakFlPId, "peakFl", kBaseSfxId, 
                                    kClipFlPId, "clipFl", kBaseSfxId )) != kOkRC )
@@ -3229,7 +3229,7 @@ namespace cw
             // create the audio_meter instance
             if((rc = dsp::audio_meter::create( inst->mtrA[i], srcBuf->srate, maxWndMs, wndMs, peakThreshDb)) != kOkRC )
             {
-              rc = cwLogError(kOpFailRC,"The 'audio_meter' object create failed on the instance '%s'.",ctx->label);
+              rc = cwLogError(kOpFailRC,"The 'audio_meter' object create failed on the instance '%s'.",proc->label);
               goto errLabel;
             }
                 
@@ -3241,11 +3241,11 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->mtrN; ++i)
           destroy(inst->mtrA[i]);
         
@@ -3255,20 +3255,20 @@ namespace cw
         return rc;
       }
       
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         return kOkRC;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
-        inst_t*       inst   = (inst_t*)ctx->userPtr;
+        inst_t*       inst   = (inst_t*)proc->userPtr;
         const abuf_t* srcBuf = nullptr;
         unsigned      chN    = 0;
         
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, srcBuf )) != kOkRC )
           goto errLabel;
 
         chN = std::min(srcBuf->chN,inst->mtrN);
@@ -3276,24 +3276,24 @@ namespace cw
         for(unsigned i=0; i<chN; ++i)
         {
           dsp::audio_meter::exec( inst->mtrA[i], srcBuf->buf + i*srcBuf->frameN, srcBuf->frameN );
-          var_set(ctx, kOutPId,    i, inst->mtrA[i]->outDb  );
-          var_set(ctx, kPeakFlPId, i, inst->mtrA[i]->peakFl );
-          var_set(ctx, kClipFlPId, i, inst->mtrA[i]->clipFl );
+          var_set(proc, kOutPId,    i, inst->mtrA[i]->outDb  );
+          var_set(proc, kPeakFlPId, i, inst->mtrA[i]->peakFl );
+          var_set(proc, kClipFlPId, i, inst->mtrA[i]->clipFl );
         }
 
       errLabel:
         return rc;
       }
 
-      rc_t report( instance_t* ctx )
+      rc_t report( proc_t* proc )
       {
         rc_t rc = kOkRC;
-        inst_t* inst = (inst_t*)ctx->userPtr;
+        inst_t* inst = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<inst->mtrN; ++i)
         {
           audio_meter_t* c = inst->mtrA[i];
           cwLogInfo("%s ch:%i : %f %f db : pk:%i %i clip:%i %i ",
-                    ctx->label,i,c->outLin,c->outDb,c->peakFl,c->peakCnt,c->clipFl,c->clipCnt );
+                    proc->label,i,c->outLin,c->outDb,c->peakFl,c->peakCnt,c->clipFl,c->clipCnt );
         }
         
         return rc;
@@ -3326,57 +3326,57 @@ namespace cw
         sample_t mark;
       } inst_t;
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc     = kOkRC;
         const abuf_t* abuf    = nullptr; //
-        ctx->userPtr = mem::allocZ<inst_t>();
+        proc->userPtr = mem::allocZ<inst_t>();
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
+        if((rc = var_register_and_get(proc, kAnyChIdx,kInPId,"in",kBaseSfxId,abuf )) != kOkRC )
           goto errLabel;
 
         // register the marker input 
-        if((rc = var_register_and_set( ctx, kAnyChIdx, kMarkPId, "mark", kBaseSfxId, 0.0f )) != kOkRC )
+        if((rc = var_register_and_set( proc, kAnyChIdx, kMarkPId, "mark", kBaseSfxId, 0.0f )) != kOkRC )
           goto errLabel;
           
         // create the output audio buffer
-        rc = var_register_and_set( ctx, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
+        rc = var_register_and_set( proc, "out", kBaseSfxId, kOutPId, kAnyChIdx, abuf->srate, abuf->chN, abuf->frameN );
 
       errLabel:
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
-        inst_t* inst = (inst_t*)(ctx->userPtr);
+        inst_t* inst = (inst_t*)(proc->userPtr);
         mem::release(inst);
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         return kOkRC;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc   = kOkRC;
         const abuf_t* ibuf = nullptr;
         abuf_t*       obuf = nullptr;
-        //inst_t*       inst = (inst_t*)(ctx->userPtr);
+        //inst_t*       inst = (inst_t*)(proc->userPtr);
         sample_t      mark = 1;
 
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
           goto errLabel;
 
         // get the dst buffer
-        if((rc = var_get(ctx,kOutPId, kAnyChIdx, obuf)) != kOkRC )
+        if((rc = var_get(proc,kOutPId, kAnyChIdx, obuf)) != kOkRC )
           goto errLabel;
 
           
-        var_get(ctx,kMarkPId,kAnyChIdx,mark);
+        var_get(proc,kMarkPId,kAnyChIdx,mark);
         
         // for each channel
         for(unsigned i=0; i<ibuf->chN; ++i)
@@ -3389,7 +3389,7 @@ namespace cw
             osig[j] = mark + isig[j];
         }
 
-        var_set(ctx,kMarkPId,kAnyChIdx,0.0f);
+        var_set(proc,kMarkPId,kAnyChIdx,0.0f);
         
       errLabel:
         return rc;
@@ -3432,7 +3432,7 @@ namespace cw
       typedef struct
       {
         unsigned    xfadeDurMs;       // crossfade duration in milliseconds
-        instance_t* net_proc;         // source 'poly' network
+        proc_t* net_proc;         // source 'poly' network
         poly_ch_t*  netA;             // netA[ poly_ch_cnt ] internal proxy network 
         unsigned    poly_ch_cnt;      // count of poly channels in net_proc
         unsigned    net_proc_cnt;     // count of proc's in a single poly-channel (net_proc->proc_arrayN/poly_cnt)
@@ -3464,7 +3464,7 @@ namespace cw
 
       }
 
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t        rc            = kOkRC;
         const char* netLabel      = nullptr;
@@ -3475,12 +3475,12 @@ namespace cw
 
         inst_t* p = mem::allocZ<inst_t>();
 
-        ctx->userPtr = p;
+        proc->userPtr = p;
 
-        if((rc = var_register(ctx,kAnyChIdx,kTriggerPId,"trigger", kBaseSfxId )) != kOkRC )
+        if((rc = var_register(proc,kAnyChIdx,kTriggerPId,"trigger", kBaseSfxId )) != kOkRC )
           goto errLabel;
                 
-        if((rc = var_register_and_get(ctx,kAnyChIdx,
+        if((rc = var_register_and_get(proc,kAnyChIdx,
                                       kNetLabelPId,    "net",       kBaseSfxId, netLabel,
                                       kNetLabelSfxPId, "netSfxId",  kBaseSfxId, netLabelSfxId,
                                       kSrateRefPId,    "srateSrc",  kBaseSfxId, srateSrc,
@@ -3492,7 +3492,7 @@ namespace cw
         }
 
         // locate the source poly-network for this xfad-ctl
-        if((rc = instance_find(*ctx->net,netLabel,netLabelSfxId,p->net_proc)) != kOkRC )
+        if((rc = proc_find(*proc->net,netLabel,netLabelSfxId,p->net_proc)) != kOkRC )
         {
           cwLogError(rc,"The xfade_ctl source network proc instance '%s:%i' was not found.",cwStringNullGuard(netLabel),netLabelSfxId);
           goto errLabel;
@@ -3510,7 +3510,7 @@ namespace cw
         for(unsigned i=1; i<p->poly_ch_cnt; ++i)
         {
           variable_t* dum;
-          if((rc = var_create(ctx, "gain", i, kGainPId+i, kAnyChIdx, nullptr, kInvalidTFl, dum )) != kOkRC )
+          if((rc = var_create(proc, "gain", i, kGainPId+i, kAnyChIdx, nullptr, kInvalidTFl, dum )) != kOkRC )
           {
             cwLogError(rc,"'gain:%i' create failed.",i);
             goto errLabel;
@@ -3527,7 +3527,7 @@ namespace cw
         {
           p->netA[i].net.proc_arrayAllocN = p->net_proc_cnt;
           p->netA[i].net.proc_arrayN      = p->netA[i].net.proc_arrayAllocN;
-          p->netA[i].net.proc_array       = mem::allocZ<instance_t*>(p->netA[i].net.proc_arrayAllocN);
+          p->netA[i].net.proc_array       = mem::allocZ<proc_t*>(p->netA[i].net.proc_arrayAllocN);
           p->netA[i].net.presetsCfg       = p->net_proc->internal_net->presetsCfg;
 
           for(unsigned j=0,k=0; j<p->net_proc->internal_net->proc_arrayN; ++j)
@@ -3539,7 +3539,7 @@ namespace cw
         }
 
         if( srateSrc == nullptr )
-          p->srate = ctx->ctx->sample_rate;
+          p->srate = proc->ctx->sample_rate;
         else
           p->srate = srateSrc->srate;
 
@@ -3555,22 +3555,22 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
-        inst_t* p = (inst_t*)ctx->userPtr;
+        inst_t* p = (inst_t*)proc->userPtr;
         for(unsigned i=0; i<p->poly_ch_cnt; ++i)
           mem::release(p->netA[i].net.proc_array);
         
         mem::release(p->netA);
-        mem::release(ctx->userPtr);
+        mem::release(proc->userPtr);
         
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t    rc = kOkRC;
-        inst_t* p  = (inst_t*)ctx->userPtr;
+        inst_t* p  = (inst_t*)proc->userPtr;
 
         switch( var->vid )
         {
@@ -3589,16 +3589,16 @@ namespace cw
       // return sign of expression as a float
       float _signum( float v ) { return (0.0f < v) - (v < 0.0f); }
       
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t    rc     = kOkRC;
-        inst_t* p      = (inst_t*)ctx->userPtr;
+        inst_t* p      = (inst_t*)proc->userPtr;
 
         // time in sample frames to complete a xfade
         double xfade_dur_smp        = p->xfadeDurMs * p->srate / 1000.0;
 
         // fraction of a xfade which will be completed in on exec() cycle
-        float delta_gain_per_cycle =  (float)(ctx->ctx->framesPerCycle / xfade_dur_smp);
+        float delta_gain_per_cycle =  (float)(proc->ctx->framesPerCycle / xfade_dur_smp);
 
 
         if( p->preset_delta_fl )
@@ -3607,7 +3607,7 @@ namespace cw
           
           p->preset_delta_fl = false;
 
-          if((rc = var_get(ctx,kPresetPId,kAnyChIdx,preset_label)) != kOkRC )
+          if((rc = var_get(proc,kPresetPId,kAnyChIdx,preset_label)) != kOkRC )
           {
             rc = cwLogError(rc,"Preset label access failed.");
             goto errLabel;
@@ -3634,7 +3634,7 @@ namespace cw
           
           p->netA[i].cur_gain = std::min(1.0f, std::max(0.0f, p->netA[i].cur_gain));
           
-          var_set(ctx,kGainPId+i,kAnyChIdx,p->netA[i].cur_gain);
+          var_set(proc,kGainPId+i,kAnyChIdx,p->netA[i].cur_gain);
         }
         
         
@@ -3676,14 +3676,14 @@ namespace cw
       } inst_t;
 
 
-      rc_t _create( instance_t* proc, inst_t* p )
+      rc_t _create( proc_t* proc, inst_t* p )
       {
         rc_t    rc   = kOkRC;        
 
         unsigned inAudioChCnt = 0;
         srate_t  srate        = 0;
         unsigned audioFrameN  = 0;
-        unsigned sfxIdAllocN  = instance_var_count(proc);
+        unsigned sfxIdAllocN  = proc_var_count(proc);
         unsigned sfxIdA[ sfxIdAllocN ];
           
 
@@ -3757,17 +3757,17 @@ namespace cw
         return rc;
       }
 
-      rc_t _destroy( instance_t* proc, inst_t* p )
+      rc_t _destroy( proc_t* proc, inst_t* p )
       {
         return kOkRC;
       }
 
-      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
+      rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
       {
         return kOkRC;
       }
 
-      unsigned _merge_in_one_audio_var( instance_t* proc, const abuf_t* ibuf, abuf_t* obuf, unsigned outChIdx, coeff_t gain )
+      unsigned _merge_in_one_audio_var( proc_t* proc, const abuf_t* ibuf, abuf_t* obuf, unsigned outChIdx, coeff_t gain )
       {
         // for each channel          
         for(unsigned i=0; i<ibuf->chN  && outChIdx<obuf->chN; ++i)
@@ -3785,7 +3785,7 @@ namespace cw
         return outChIdx;
       }
       
-      rc_t _exec( instance_t* proc, inst_t* p )
+      rc_t _exec( proc_t* proc, inst_t* p )
       {
         rc_t          rc    = kOkRC;
         abuf_t*       obuf  = nullptr;
@@ -3822,7 +3822,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _report( instance_t* proc, inst_t* p )
+      rc_t _report( proc_t* proc, inst_t* p )
       { return kOkRC; }
 
       class_members_t members = {
@@ -3894,17 +3894,17 @@ namespace cw
         mem::release(p);        
       }
       
-      rc_t create( instance_t* ctx )
+      rc_t create( proc_t* proc )
       {
         rc_t          rc       = kOkRC;
         const abuf_t* abuf     = nullptr; //
         double        periodMs = 0;
         
-        ctx->userPtr = mem::allocZ<inst_t>();
-        inst_t* p = (inst_t*)ctx->userPtr;
+        proc->userPtr = mem::allocZ<inst_t>();
+        inst_t* p = (inst_t*)proc->userPtr;
 
         // get the source audio buffer
-        if((rc = var_register_and_get(ctx, kAnyChIdx,
+        if((rc = var_register_and_get(proc, kAnyChIdx,
                                       kInPId,       "in",       kBaseSfxId, abuf,
                                       kPeriodMsPId, "period_ms",kBaseSfxId, periodMs)) != kOkRC )
         {
@@ -3912,14 +3912,14 @@ namespace cw
         }
         
         p->chN          = abuf->chN;
-        p->bufAllocFrmN = _period_ms_to_smp( abuf->srate, ctx->ctx->framesPerCycle, periodMs );
+        p->bufAllocFrmN = _period_ms_to_smp( abuf->srate, proc->ctx->framesPerCycle, periodMs );
         p->periodFrmN   = p->bufAllocFrmN;
         p->buf          = mem::allocZ<sample_t*>(abuf->chN);
 
         for(unsigned i=0; i<abuf->chN; ++i)
         {
           p->buf[i] = mem::allocZ<sample_t>(p->bufAllocFrmN);
-          if((rc = var_register_and_set(ctx, i,
+          if((rc = var_register_and_set(proc, i,
                                         kOutPId,  "out",  kBaseSfxId, 0.0f,
                                         kMeanPId, "mean", kBaseSfxId, 0.0f)) != kOkRC )
           {
@@ -3933,14 +3933,14 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* ctx )
+      rc_t destroy( proc_t* proc )
       {
-        inst_t* p = (inst_t*)(ctx->userPtr);
+        inst_t* p = (inst_t*)(proc->userPtr);
         _destroy(p);
         return kOkRC;
       }
 
-      rc_t value( instance_t* ctx, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         
@@ -3950,13 +3950,13 @@ namespace cw
             {
               double periodMs;
               const abuf_t* abuf;
-              inst_t*  p = (inst_t*)(ctx->userPtr);
+              inst_t*  p = (inst_t*)(proc->userPtr);
                       
-              var_get(ctx,kInPId,kAnyChIdx,abuf);
+              var_get(proc,kInPId,kAnyChIdx,abuf);
               
               if((rc = var_get(var,periodMs)) == kOkRC )
               {
-                p->periodFrmN = _period_ms_to_smp( abuf->srate, ctx->ctx->framesPerCycle, p->bufAllocFrmN, periodMs );
+                p->periodFrmN = _period_ms_to_smp( abuf->srate, proc->ctx->framesPerCycle, p->bufAllocFrmN, periodMs );
               }
             }
             break;
@@ -3969,18 +3969,18 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* ctx )
+      rc_t exec( proc_t* proc )
       {
         rc_t          rc   = kOkRC;
         const abuf_t* ibuf = nullptr;
-        inst_t*       p    = (inst_t*)(ctx->userPtr);
+        inst_t*       p    = (inst_t*)(proc->userPtr);
         unsigned      chN  = 0;
         unsigned      oi   = 0;
         unsigned      n0   = 0;
        unsigned       n1   = 0;
 
         // get the src buffer
-        if((rc = var_get(ctx,kInPId, kAnyChIdx, ibuf )) != kOkRC )
+        if((rc = var_get(proc,kInPId, kAnyChIdx, ibuf )) != kOkRC )
           goto errLabel;
 
         chN = std::min(ibuf->chN,p->chN);
@@ -4023,10 +4023,10 @@ namespace cw
         for(unsigned i=0; i<ibuf->chN; ++i)
         {
           // the output is the first sample in the buffer
-          var_set(ctx,kOutPId,i, p->buf[i][oi] );
+          var_set(proc,kOutPId,i, p->buf[i][oi] );
 
-          if( var_is_a_source(ctx,kMeanPId,i) )
-            var_set(ctx,kMeanPId,i, _mean(p,i,oi,n0,n1));
+          if( var_is_a_source(proc,kMeanPId,i) )
+            var_set(proc,kMeanPId,i, _mean(p,i,oi,n0,n1));
         }
                 
       errLabel:
@@ -4056,7 +4056,7 @@ namespace cw
       
 
 
-      rc_t create( instance_t* proc )
+      rc_t create( proc_t* proc )
       {
         rc_t        rc    = kOkRC;        
         double      value = 0;
@@ -4071,19 +4071,19 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         return rc;
       }
 
-      rc_t exec( instance_t* proc )
+      rc_t exec( proc_t* proc )
       {
         rc_t rc      = kOkRC;
         return rc;
@@ -4117,12 +4117,12 @@ namespace cw
         unsigned periodPhase;
       } inst_t;
 
-      unsigned _period_ms_to_frame_count( instance_t* proc, inst_t* p, srate_t srate, ftime_t periodMs )
+      unsigned _period_ms_to_frame_count( proc_t* proc, inst_t* p, srate_t srate, ftime_t periodMs )
       {
         return std::max((unsigned)(srate * periodMs / 1000.0), proc->ctx->framesPerCycle);
       }
 
-      rc_t create( instance_t* proc )
+      rc_t create( proc_t* proc )
       {
         rc_t    rc       = kOkRC;
         ftime_t  periodMs = 0;
@@ -4153,7 +4153,7 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t destroy( proc_t* proc )
       {
         rc_t    rc = kOkRC;
         inst_t* p  = (inst_t*)proc->userPtr;
@@ -4161,7 +4161,7 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         switch( var->vid )
@@ -4185,7 +4185,7 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* proc )
+      rc_t exec( proc_t* proc )
       {
         rc_t    rc = kOkRC;
         inst_t* p  = (inst_t*)proc->userPtr;
@@ -4284,7 +4284,7 @@ namespace cw
         return cwLogError(kInvalidArgRC,"'%s' is not a valid counter 'mode'.",cwStringNullGuard(mode_label));
       }
 
-      rc_t create( instance_t* proc )
+      rc_t create( proc_t* proc )
       {
         rc_t    rc    = kOkRC;        
         inst_t* p     = mem::allocZ<inst_t>();
@@ -4344,7 +4344,7 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
@@ -4354,7 +4354,7 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         inst_t* p = (inst_t*)proc->userPtr;
@@ -4387,7 +4387,7 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* proc )
+      rc_t exec( proc_t* proc )
       {
         rc_t rc      = kOkRC;
         inst_t* p = (inst_t*)proc->userPtr;
@@ -4610,7 +4610,7 @@ namespace cw
       }
 
       template< typename T >
-      rc_t _set_out_tmpl( instance_t* proc, inst_t* p, unsigned idx, unsigned vid, T& v )
+      rc_t _set_out_tmpl( proc_t* proc, inst_t* p, unsigned idx, unsigned vid, T& v )
       {
         rc_t rc;
         const object_t* ele;        
@@ -4640,7 +4640,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _set_output( instance_t* proc, inst_t* p, unsigned idx, unsigned vid )
+      rc_t _set_output( proc_t* proc, inst_t* p, unsigned idx, unsigned vid )
       {
         rc_t rc;
 
@@ -4698,7 +4698,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _set_output( instance_t* proc, inst_t* p )
+      rc_t _set_output( proc_t* proc, inst_t* p )
       {
         rc_t rc;
         unsigned idx;
@@ -4724,7 +4724,7 @@ namespace cw
         
       
 
-      rc_t create( instance_t* proc )
+      rc_t create( proc_t* proc )
       {
         rc_t    rc   = kOkRC;        
         inst_t* p = mem::allocZ<inst_t>();
@@ -4790,7 +4790,7 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
@@ -4801,7 +4801,7 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         if( var->vid == kInPId )
@@ -4814,7 +4814,7 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* proc )
+      rc_t exec( proc_t* proc )
       {
         rc_t rc = kOkRC;
         inst_t*  p   = (inst_t*)proc->userPtr;
@@ -4857,7 +4857,7 @@ namespace cw
 
 
       template< typename T >
-      rc_t _sum( instance_t* proc, variable_t* var )
+      rc_t _sum( proc_t* proc, variable_t* var )
       {
         rc_t rc      = kOkRC;
         inst_t*  p = (inst_t*)proc->userPtr;
@@ -4888,7 +4888,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _exec( instance_t* proc, variable_t* out_var=nullptr )
+      rc_t _exec( proc_t* proc, variable_t* out_var=nullptr )
       {
         rc_t rc = kOkRC;
         inst_t* p = (inst_t*)(proc->userPtr);
@@ -4925,7 +4925,7 @@ namespace cw
 
       }
       
-      rc_t create( instance_t* proc )
+      rc_t create( proc_t* proc )
       {
         rc_t    rc   = kOkRC;        
         inst_t* p = mem::allocZ<inst_t>();
@@ -4934,7 +4934,7 @@ namespace cw
         variable_t* out_var        = nullptr;
         const char* out_type_label = nullptr;
         unsigned    out_type_flag  = kInvalidTFl;
-        unsigned    sfxIdAllocN    = instance_var_count(proc);
+        unsigned    sfxIdAllocN    = proc_var_count(proc);
         unsigned    sfxIdA[ sfxIdAllocN ];
         p->inN = 0;
 
@@ -5001,7 +5001,7 @@ namespace cw
         return rc;
       }
 
-      rc_t destroy( instance_t* proc )
+      rc_t destroy( proc_t* proc )
       {
         rc_t rc = kOkRC;
 
@@ -5012,7 +5012,7 @@ namespace cw
         return rc;
       }
 
-      rc_t value( instance_t* proc, variable_t* var )
+      rc_t value( proc_t* proc, variable_t* var )
       {
         rc_t rc = kOkRC;
         inst_t* p = (inst_t*)(proc->userPtr);
@@ -5023,7 +5023,7 @@ namespace cw
         return rc;
       }
 
-      rc_t exec( instance_t* proc )
+      rc_t exec( proc_t* proc )
       {
         return _exec(proc);
       }
@@ -5056,7 +5056,7 @@ namespace cw
       } inst_t;
 
 
-      rc_t _set_preset( instance_t* proc, inst_t* p )
+      rc_t _set_preset( proc_t* proc, inst_t* p )
       {
         rc_t rc = kOkRC;
         unsigned presetLabelCharN = 0;
@@ -5105,7 +5105,7 @@ namespace cw
         
       }
 
-      rc_t _create( instance_t* proc, inst_t* p )
+      rc_t _create( proc_t* proc, inst_t* p )
       {
         rc_t    rc   = kOkRC;        
 
@@ -5123,10 +5123,10 @@ namespace cw
         return rc;
       }
 
-      rc_t _destroy( instance_t* proc, inst_t* p )
+      rc_t _destroy( proc_t* proc, inst_t* p )
       { return kOkRC; }
 
-      rc_t _value( instance_t* proc, inst_t* p, variable_t* var )
+      rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
       {
         rc_t rc = kOkRC;
         if( var->vid == kInPId )
@@ -5135,7 +5135,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _exec( instance_t* proc, inst_t* p )
+      rc_t _exec( proc_t* proc, inst_t* p )
       {
         rc_t rc      = kOkRC;
         
@@ -5145,7 +5145,7 @@ namespace cw
         return rc;
       }
 
-      rc_t _report( instance_t* proc, inst_t* p )
+      rc_t _report( proc_t* proc, inst_t* p )
       { return kOkRC; }
 
       

From c98eb88e78ac523329b849d50231df4e0bebf3b2 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:47:53 -0400
Subject: [PATCH 059/101] flow/flow_doc.md : Updates.

---
 flow/flow_doc.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 9acf6a7..6b26c12 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -131,14 +131,16 @@ report   | Print the state of the process.
 
 ### Var Syntax
 
-__label__ : { type: __type__, value: __value__, doc:"q-string" }
+__label__ : { type: __type__, { value: __value__ }, {proxy: __proxy__}, {flags:[{__flag__}*]}, doc:"q-string" }
 
 Part   | Description
 -------|-------------------------------------------------------
 label  | Variable name
 type   | Variable type.  See Data types below.
 value  | The default value of the variable.
+proxy  | 
 doc    | Documentation string for this variable.
+flags  | 
 
 Notes:
 

From 1a6282cd6b4802cd24a8de78866cfb00afc8d9c2 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 6 May 2024 15:48:02 -0400
Subject: [PATCH 060/101] README.md : Updates.

---
 README.md | 49 ++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 520c3bb..94160d8 100644
--- a/README.md
+++ b/README.md
@@ -877,11 +877,10 @@ but would almost certainly not do what the user expects.
   when the proc instance create is complete. This checks that both the type is assigned and
   a valid value has been assigned - since the type is assigned the first time a value is set.
   
-  
 - DONE: 'poly' should be implemented as a proc-inst with an internal network - but the 
 elements of the network should be visible outside of it.
 
-- 'sub' should be implemented as proc-inst with an internal network, but the
+- DONE: 'sub' should be implemented as proc-inst with an internal network, but the
 elements of the network should not be visible outside of it. Instead it should
 include the idea of input and output ports which act as proxies to the physical
 ports of the internal elements.
@@ -904,21 +903,41 @@ ports of the internal elements.
 This might be a better approach to logging than having a 'printer' object.
 Add proc instance field: `log:{ var_label_0:0, var_label_1:0 } `
 
-- log: should print the values for all channels - right now it is only
-printing the values for kAnyChIdx
+- log: 
+    + should print the values for all channels - right now it is only
+	printing the values for kAnyChIdx
+	+ log should print values for abuf (mean,max), fbuf (mean,max) mag, mbuf
 
 Next:
 
-- subnet vars should be the same as non-subnet vars but include the 'proxy' field.
-  In particular they should get default values.
+- Complete subnets:
+	+ subnet var desc's should be the same as non+subnet vars but also include the 'proxy' field.
+	In particular they should get default values.
+	If a var desc is part of a subnet then it must have a proxy.
+	The output variables of var desc's must have the 'out' attribute
+
+	+ subnets should have presets written in terms of the subnet vars rather than the network vars
+
+	+ improve the subnet creating code by using consistent naming + use proxy or wrap but not both
+
+	+ improve code comments on subnet creation
+
+	+ write a paragraph in the flow_doc.md about overall approach taken to subnet implementation.
+	
+- Implement the var attributes and attribute checking.
+- Implement dynamic loading of procs.
+- Implement a debug mode to aid in building networks and subnets (or is logging good enough)
+- Implement multi-field messages.
+- Implement the ability to set backward connections - from late to early proc's.
+  This can be done by implementing the same process as 'in_stmt' but in a separate 
+  'out_stmt'. The difficulty is that it prevents doing some checks until the network
+  is completely specified.  For example if audio inputs can accept connections from 
+  later proc's then they will not have all of their inputs when they are instantiated.
+  One way around this is to instantiate them with an initial set of inputs but then
+  allow those inputs to be replaced by a later connection.
   
-- subnets should have presets written in terms of the subnet vars rather than the network vars
+- DONE: Fix up the coding language - change the use of `instance_t` to `proc_t` and `inst` to `proc`, change use of `ctx` in cwFlowProc
 
-- improve the subnet creating code by using consistent naming - use proxy or wrap but not both
-
-- improve code comments on subnet creation
-
-- write a paragraph in the flow_doc.md about overall approach taken to subnet implementation
 
 
 
@@ -935,7 +954,11 @@ Consider:
    e.g. `lfo: { class:sine_tone, in:{ osc_.dc:list.value_ } }` 
 
 
-
+Host Environments:
+------------------
+- CLI, no GUI, no I/O, non-real-time only.
+- CLI, no GUI, w/ I/O and real-time
+- GUI, with configurable control panels
 
 
 - DONE: Implement 'preset' proc. This will involve implementing the 'cfg' datatype.

From c7c31200a8fc25081e3ea5d1b94b888764478c1e Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 8 May 2024 10:18:43 -0400
Subject: [PATCH 061/101] cwFlowNet.cpp : Added the ability for in-stmts to
 iterate over the in-proc. This allows poly procs to draw per voice input from
 non-poly procs.

---
 cwFlowNet.cpp | 357 +++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 266 insertions(+), 91 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index fbbfd6e..d6809f2 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -184,7 +184,7 @@ namespace cw
           variable_t* var = proc->varMapA[i];
 
           if((rc = var_call_custom_value_func( var )) != kOkRC )
-            rc1 = cwLogError(rc,"The proc proc instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->proc->label, var->proc->label_sfx_id, var->label, var->chIdx );
+            rc1 = cwLogError(rc,"The proc inst instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->proc->label, var->proc->label_sfx_id, var->label, var->chIdx );
         }
       
       return rc1;
@@ -249,7 +249,7 @@ namespace cw
         const object_t* value     = preset_cfg->child_ele(i)->pair_value();
         const char*     var_label = preset_cfg->child_ele(i)->pair_label();
 
-        //cwLogInfo("variable:%s",value_label);
+        //cwLogInfo("variable:%s",var_label);
         
         if((rc = _var_channelize( proc, preset_label, type_src_label, var_label, value )) != kOkRC )
           goto errLabel;
@@ -683,9 +683,10 @@ namespace cw
     //
     
     enum {
-      kInVarTypeId   = 0x01,
-      kSrcProcTypeId = 0x02,
-      kSrcVarTypeId  = 0x04
+      kInProcTypeId  = 0x01,
+      kInVarTypeId   = 0x02,
+      kSrcProcTypeId = 0x04,
+      kSrcVarTypeId  = 0x08
     };
     
     typedef struct in_ele_str
@@ -699,12 +700,14 @@ namespace cw
     
     typedef struct in_stmt_str
     {
+      in_ele_t    in_proc_ele;      // in-proc element
       in_ele_t    in_var_ele;       // in-var element
       char*       src_net_label;    // src-net label  (null=in-var net, '_'=root net, string=named net)
       network_t*  src_net;          // network containing the src-proc
       in_ele_t    src_proc_ele;     // src-proc element
       in_ele_t    src_var_ele;      // src-var element
       var_desc_t* in_var_desc;      // Pointer to the in-var var_desc.
+      bool        in_proc_iter_fl;  // Is the 'in' proc iterating (this is a poly iteration rather than a var iterator)
       bool        create_in_fl;     // True if the in_var needs to be created with an sfx_id, false create the var by the default process (w/o sfx_id)
       in_ele_t*   iter_cnt_ctl_ele; // Pointer to the ele which is controlling the iteration count (or null if in-var is non-iterating)
       unsigned    iter_cnt;         // Count of iterations or 0 if in-var is non-iterating.
@@ -712,7 +715,8 @@ namespace cw
 
     typedef struct proc_inst_parse_statestr
     {
-      const char*     proc_label;       // 
+      char*           proc_label;       //
+      unsigned        proc_label_sfx_id;//
       const char*     proc_clas_label;  //
       const char*     arg_label;        //
       const object_t* preset_labels;    //
@@ -726,8 +730,27 @@ namespace cw
     bool _is_non_null_pair( const object_t* cfg )
     { return cfg != nullptr && cfg->is_pair() && cfg->pair_label()!=nullptr && cfg->pair_value()!=nullptr; }
 
+    unsigned _digit_suffix_char_count( const char* s )
+    {
+      unsigned digitN = 0;
+      unsigned sn = textLength(s);
+      if( sn==0 )
+        return 0;
+      
+      const char* s0 = s + (textLength(s)-1);
+      
+      // go backward from the last char until the begin-of-string or a non-digit is found
+      for(; s0>=s; --s0)
+      {
+        if(!isdigit(*s0) )
+          break;
+        ++digitN;
+      }
+
+      return digitN;      
+    }
     
-    rc_t _parse_in_ele( const char* id_str, in_ele_t& r  )
+    rc_t _parse_in_ele( const char* id_str, in_ele_t& r, bool inProcFl=false  )
     {
       rc_t rc = kOkRC;
       unsigned bufN;
@@ -737,17 +760,23 @@ namespace cw
       
       if((bufN = textLength(id_str)) == 0 )
       {
-        rc = cwLogError(kSyntaxErrorRC,"A blank connection id string was encountered.");
+        if( !inProcFl )         
+          rc = cwLogError(kSyntaxErrorRC,"A blank connection id string was encountered.");
         goto errLabel;
       }
       else
       {
         char* underscore = nullptr;
         char* digit      = nullptr;
-        char  buf[ bufN+1 ];
+        int   offs       = inProcFl ? 1 : 0; 
+        char  buf[ bufN+(1+offs) ];
+
+        // in-proc's don't have a leading label - add one here to please the parser
+        if(inProcFl)
+          buf[0] = 'x';
 
         // copy the id string into a non-const scratch buffer 
-        textCopy(buf,bufN+1,id_str);
+        textCopy(buf+offs,bufN+1,id_str);
 
         // locate the last underscore
         if((underscore = lastMatchChar(buf,'_')) != nullptr )
@@ -801,7 +830,7 @@ namespace cw
           }
 
         // if a digit was found then this is the 'priInt'
-        if( textLength(digit) )
+        if( digit>buf && textLength(digit) )
         {
           assert( buf <= digit-1 && digit-1 <= buf + bufN );
           
@@ -826,7 +855,8 @@ namespace cw
         else
         {
           // store the label
-          r.label = mem::duplStr(buf);
+          if( !inProcFl )
+            r.label = mem::duplStr(buf);
         }
       }
       
@@ -868,7 +898,7 @@ namespace cw
       // locate the parent proc of this var
       if((src_proc = proc_find(net,src_proc_ele.label,proc_sfx_id)) == nullptr )
       {
-        cwLogError(kSyntaxErrorRC,"The src-proc proc instance '%s:%i' could not be found.",cwStringNullGuard(src_proc_ele.label),proc_sfx_id);
+        cwLogError(kSyntaxErrorRC,"The src-proc inst instance '%s:%i' could not be found.",cwStringNullGuard(src_proc_ele.label),proc_sfx_id);
         goto errLabel;
       }
       else
@@ -1029,6 +1059,26 @@ namespace cw
       mem::release(s.src_var_ele.label);
     }
 
+    rc_t _parse_in_stmt_in_proc_var_string( char* str, const char*& in_proc_label, const char*& in_var_label )
+    {
+      rc_t  rc     = kOkRC;
+      char* period = nullptr;
+
+      if((period = firstMatchChar(str,'.')) == nullptr )
+      {
+        in_proc_label = nullptr;
+        in_var_label = str;
+      }
+      else
+      {
+        *period = '\0';
+        in_proc_label = str;
+        in_var_label = period + 1;
+      }
+      
+      return rc;
+    }
+
     rc_t _parse_in_stmt_src_net_proc_var_string( char* str, char*& src_net_label, const char*& src_proc_label, const char*& src_var_label )
     {
       rc_t rc = kOkRC;
@@ -1131,28 +1181,38 @@ namespace cw
     }
 
 
-    rc_t _create_in_stmt( network_t& net, proc_t* proc, in_stmt_t& in_stmt, const char* in_var_str, const char* src_proc_var_str )
+    rc_t _create_in_stmt( network_t& net, proc_t* proc, in_stmt_t& in_stmt, const char* in_proc_var_str, const char* src_proc_var_str )
     {
-      rc_t     rc          = kOkRC;
+      rc_t     rc           = kOkRC;
       unsigned src_char_cnt = 0;
+      unsigned in_char_cnt  = 0;
 
+      in_stmt.in_proc_ele.typeId  = kInProcTypeId;
       in_stmt.in_var_ele.typeId   = kInVarTypeId;
       in_stmt.src_proc_ele.typeId = kSrcProcTypeId;
       in_stmt.src_var_ele.typeId  = kSrcVarTypeId;
       
-      // verify the src proc/var string is valid
-      if( (src_char_cnt = textLength(src_proc_var_str)) == 0 )
+      // Both the src and in strings must exist to form an in:src pair.
+      if( (src_char_cnt = textLength(src_proc_var_str)) == 0 || (in_char_cnt = textLength(in_proc_var_str))==0)
       {
-        cwLogError(kSyntaxErrorRC,"No source variable was found for the input variable '%s'.",cwStringNullGuard(in_var_str));
+        cwLogError(kSyntaxErrorRC,"No source variable was found for the input variable '%s'.",cwStringNullGuard(in_proc_var_str));
         goto errLabel;
       }
       else
       {
+        const char* in_proc_label  = nullptr;
+        const char* in_var_label   = nullptr;
         const char* src_proc_label = nullptr;
-        const char* src_var_label = nullptr;
+        const char* src_var_label  = nullptr;
+        unsigned    str_char_cnt   = std::max( src_char_cnt, in_char_cnt );
         
-        char  str[ src_char_cnt+1 ];
+        char  str[ str_char_cnt+1 ];
 
+
+        //
+        //  Parse the src net/proc/var 
+        //
+        
         // put the src proc/var string into a non-const scratch buffer
         textCopy(str,src_char_cnt+1,src_proc_var_str);
 
@@ -1163,27 +1223,49 @@ namespace cw
           goto errLabel;
         }
 
-        // parse the in-var
-        if((rc = _parse_in_ele( in_var_str, in_stmt.in_var_ele  )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_str));
-          goto errLabel;
-        }
-
         // parse the src-proc
         if((rc = _parse_in_ele( src_proc_label, in_stmt.src_proc_ele  )) != kOkRC )
         {
-          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_str));
+          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_proc_var_str));
           goto errLabel;
         }
 
         // parse the src-var
         if((rc = _parse_in_ele( src_var_label, in_stmt.src_var_ele )) != kOkRC )
         {
-          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_str));
+          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_proc_var_str));
           goto errLabel;
         }
 
+        //
+        // Parse the in proc/var
+        //
+        
+        textCopy(str, in_char_cnt+1, in_proc_var_str );
+
+        // parse the 'in' part into it's 2 parts
+        if((rc = _parse_in_stmt_in_proc_var_string(str, in_proc_label, in_var_label )) != kOkRC )          
+        {
+          cwLogError(rc,"Unable to parse the 'in' part of an 'in-stmt'.");
+          goto errLabel;
+        }
+
+        // parse the in-proc
+        if((rc = _parse_in_ele( in_proc_label, in_stmt.in_proc_ele, true  )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the in-proc from '%s'.",cwStringNullGuard(in_proc_label));
+          goto errLabel;
+        }
+        
+        // parse the in-var
+        if((rc = _parse_in_ele( in_var_label, in_stmt.in_var_ele  )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_label));
+          goto errLabel;
+        }
+
+
+        
         // get the var class desc. for the in-var
         if(( in_stmt.in_var_desc = var_desc_find(proc->class_desc,in_stmt.in_var_ele.label)) == nullptr )
         {
@@ -1198,7 +1280,14 @@ namespace cw
           goto errLabel;
         }
 
-        // if the in-var has an sfx_id, or is iterating, then the var needs to be created (the dflt creation process assumes no sfx id)
+        // verify that both the in-proc and in-var are not iterating
+        if( in_stmt.in_proc_ele.is_iter_fl && in_stmt.in_var_ele.is_iter_fl )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Both the 'in' proc and 'in' var cannot be iterating. See:'%s'",cwStringNullGuard(in_proc_var_str));
+          goto errLabel;
+        }
+
+        // if the in-var has an sfx_id, or is iterating, then the var needs to be created (the dflt creation process assumes an sfx-id of 0)
         if( in_stmt.in_var_ele.base_sfx_id != kInvalidId || in_stmt.in_var_ele.is_iter_fl )
         {
           in_stmt.create_in_fl = true;
@@ -1206,14 +1295,15 @@ namespace cw
             in_stmt.in_var_ele.base_sfx_id = kBaseSfxId;
         }
 
-        // if the src-proc is not iterating and the src-proc was not given a literal sfx-id
+        // if the src-proc is not iterating and the src-proc was not given a literal sfx-id ...
         if( in_stmt.src_proc_ele.is_iter_fl==false && in_stmt.src_proc_ele.base_sfx_id==kInvalidId && in_stmt.src_net==&net)
-          in_stmt.src_proc_ele.base_sfx_id = proc->label_sfx_id;
+          in_stmt.src_proc_ele.base_sfx_id = proc->label_sfx_id; // ... then the src proc takes this proc's sfx id
+        // (This results in poly proc's selecting other poly procs with the same sfx-id as sources by default).
 
         // if this is not an iterating in-stmt ... 
         if( !in_stmt.in_var_ele.is_iter_fl )
         {
-          in_stmt.iter_cnt = 1;  // ... then it must be a simple 1:1 connection
+          in_stmt.iter_cnt = 1;  // ... then it must be a simple 1:1 connection (Note if in-proc is iterating then it this must also be true)
         }
         else
         {
@@ -1240,17 +1330,18 @@ namespace cw
       return rc;      
     }
 
-    const variable_t* _find_proxy_var( const char* procProcLabel, const char* varLabel, const variable_t* proxyVarL )
+    // Find the proxy var associated with the proxied var 'procLabel:varLabel'
+    const variable_t* _find_proxy_var( const char* procLabel, const char* varLabel, const variable_t* proxyVarL )
     {
       for(const variable_t* proxyVar=proxyVarL; proxyVar!=nullptr; proxyVar=proxyVar->var_link)
-        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procProcLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
+        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
           return proxyVar;
       return nullptr;
     }
     
     rc_t _parse_in_list( network_t& net, proc_t* proc, variable_t* proxyVarL, proc_inst_parse_state_t& pstate )
     {
-      rc_t            rc     = kOkRC;
+      rc_t rc = kOkRC;
       
       if( pstate.in_dict == nullptr )
         goto errLabel;
@@ -1301,7 +1392,8 @@ namespace cw
         {
           const variable_t* proxy_var;
           
-          // a variable cannot be in the 'in' list if it is used a a subnet variable
+          // a variable cannot be in the 'in' list if it is a proxied variable - because it will
+          // be connected to a proxy var.
           if((proxy_var = _find_proxy_var(proc->label, in_stmt.in_var_ele.label, proxyVarL)) != nullptr )
           {
             rc = cwLogError(kSyntaxErrorRC,"The variable:'%s' cannot be used as the in-var of an 'in' statement if it is a subnet variable: '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label),cwStringNullGuard(proxy_var->label));
@@ -1313,7 +1405,8 @@ namespace cw
           {
             variable_t* dum = nullptr;        
 
-            if((rc = var_create( proc, in_stmt.in_var_desc->label,
+            if((rc = var_create( proc,
+                                 in_stmt.in_var_desc->label,
                                  in_stmt.in_var_ele.base_sfx_id + i,
                                  kInvalidId,
                                  kAnyChIdx,
@@ -1436,34 +1529,34 @@ namespace cw
     rc_t _connect_in_vars(network_t& net, proc_t* proc, const proc_inst_parse_state_t& pstate)
     {
       rc_t rc = kOkRC;
-      
+
+      // for each in-stmt
       for(unsigned i=0; i<pstate.in_arrayN; ++i)
       {
         in_stmt_t& in_stmt = pstate.in_array[i];
 
+        // all in-stmts are iterating (but most only iterate once)
         for(unsigned j=0; j<in_stmt.iter_cnt; ++j)
         {
-          variable_t* in_var    = nullptr;
-          network_t*  src_net   = in_stmt.src_net;
-          proc_t* src_proc  = nullptr;
-          variable_t* src_var   = nullptr;
+          variable_t* in_var   = nullptr;
+          network_t*  src_net  = in_stmt.src_net;
+          proc_t*     src_proc = nullptr;
+          variable_t* src_var  = nullptr;
 
+          const char* in_proc_label  = in_stmt.in_proc_ele.label;
           const char* in_var_label   = in_stmt.in_var_ele.label;
           const char* src_proc_label = in_stmt.src_proc_ele.label;
           const char* src_var_label  = in_stmt.src_var_ele.label;
 
-          unsigned in_var_sfx_id   = (in_stmt.in_var_ele.base_sfx_id == kInvalidId ? kBaseSfxId : in_stmt.in_var_ele.base_sfx_id) + j;
+          unsigned in_var_sfx_id   = kInvalidId; //(in_stmt.in_var_ele.base_sfx_id == kInvalidId ? kBaseSfxId : in_stmt.in_var_ele.base_sfx_id) + j;
           unsigned src_proc_sfx_id = kInvalidId;
           unsigned src_var_sfx_id  = kInvalidId;
 
-          // if a literal in-var sfx id was no given ...
+          // if a literal in-var sfx id was not given ...
           if( in_stmt.in_var_ele.base_sfx_id == kInvalidId )
-            in_var_sfx_id = kBaseSfxId;
+            in_var_sfx_id = kBaseSfxId; // ... then use the default sfx-id
           else
-            in_var_sfx_id = in_stmt.in_var_ele.base_sfx_id;
-
-          if( in_stmt.in_var_ele.is_iter_fl )
-            in_var_sfx_id += j;
+            in_var_sfx_id = in_stmt.in_var_ele.base_sfx_id; 
 
           // if a literal src-proc sfx id was not given ...
           if( in_stmt.src_proc_ele.base_sfx_id == kInvalidId )
@@ -1471,18 +1564,31 @@ namespace cw
           else
             src_proc_sfx_id = in_stmt.src_proc_ele.base_sfx_id; // ... otherwise use the given literal
 
-          if( in_stmt.src_proc_ele.is_iter_fl ) // if this is an iterating src
-            src_proc_sfx_id += j;
-
           // if a literal src-var sfx id was not given ...
           if( in_stmt.src_var_ele.base_sfx_id == kInvalidId )
             src_var_sfx_id = kBaseSfxId; // ... then use the base-sfx-id
           else
             src_var_sfx_id = in_stmt.src_var_ele.base_sfx_id; // ... otherwise use the given literal
 
-          if( in_stmt.src_var_ele.is_iter_fl )  // if this is an iterating src
-            src_var_sfx_id += j;
-          
+          // When the in-proc is iterating then we incr by the in-proc sfx-id (in this case j will never exceed 0)
+          // otherwise increment by j - the current iteration count
+          unsigned iter_incr = in_stmt.in_proc_ele.is_iter_fl ? proc->label_sfx_id : j;
+
+          // both in-var and in-proc cannot be iterating
+          assert( !(in_stmt.in_var_ele.is_iter_fl && in_stmt.in_proc_ele.is_iter_fl) );
+
+          // if the in-var is iterating then incr. the in-var sfx-id
+          if( in_stmt.in_var_ele.is_iter_fl )
+            in_var_sfx_id += iter_incr;
+
+          // if this is an iterating src-proc then iter the src-proc-sfx-id
+          if( in_stmt.src_proc_ele.is_iter_fl ) 
+            src_proc_sfx_id += iter_incr;
+
+          // if this is an iterating src-var then iter the src-var-sfx-id
+          if( in_stmt.src_var_ele.is_iter_fl )  
+            src_var_sfx_id += iter_incr;
+                    
           // locate input value
           if((rc = var_find( proc, in_var_label, in_var_sfx_id, kAnyChIdx, in_var )) != kOkRC )
           {
@@ -1528,33 +1634,98 @@ namespace cw
         rc = cwLogError(rc,"Connection failed on proc '%s:%i'.",proc->label,proc->label_sfx_id);
       return rc;
     }
-      
-    
-    rc_t _parse_proc_inst_cfg( network_t& net, const object_t* proc_inst_cfg, unsigned sfx_id, proc_inst_parse_state_t& pstate )
-    {
-      rc_t            rc       = kOkRC;
-      const object_t* arg_dict = nullptr;
 
-      // validate the syntax of the proc_inst_cfg pair
-      if( !_is_non_null_pair(proc_inst_cfg))
+    // Set pstate.proc_label and pstate.label_sfx_id
+    rc_t  _parse_proc_inst_label( const char* proc_label_str, unsigned system_sfx_id, proc_inst_parse_state_t& pstate )
+    {
+      rc_t     rc         = kOkRC;
+      unsigned digitCharN = 0;
+      unsigned sfx_id     = kInvalidId;
+      unsigned sN         = textLength(proc_label_str);
+      char     s[sN+1];
+
+      if( sN == 0 )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. is not a valid pair. No proc instance label could be parsed.");
+        rc = cwLogError(kSyntaxErrorRC,"A blank proc-instance label was encountered.");
         goto errLabel;
       }
       
-      pstate.proc_label = proc_inst_cfg->pair_label();
+      textCopy(s,sN+1,proc_label_str,sN);
 
-      // verify that the proc instance label is unique
-      if( proc_find(net,pstate.proc_label,sfx_id) != nullptr )
+      // if this label has no digit suffix
+      if((digitCharN = _digit_suffix_char_count( s )) > 0)
       {
-        rc = cwLogError(kSyntaxErrorRC,"The proc proc instance label '%s:%i' has already been used.",pstate.proc_label,sfx_id);
+        if( digitCharN == sN )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"A proc-instance label ('%s') was encountered that appears to be a number rather than  identifier.",s);
+          goto errLabel;
+        }
+        else
+        {
+          if( string_to_number(s + sN-digitCharN,sfx_id) != kOkRC )
+          {
+            rc = cwLogError(kOpFailRC,"A proc-instance numeric suffix (%s) could not be converted into an integer.",s);
+            goto errLabel;
+          }
+          
+          s[sN-digitCharN] = '\0';
+        }
+      }
+
+      // if the parsed sfx-id did not exist 
+      if( sfx_id == kInvalidId )
+      {
+        sfx_id = system_sfx_id==kInvalidId ? kBaseSfxId : system_sfx_id;
+      }
+      
+      // be sure the parsed sfx-id does not conflict with the system provided sfx-id
+      if( system_sfx_id != kInvalidId && sfx_id != system_sfx_id )
+      {
+        rc = cwLogError(kInvalidStateRC,"The proc instance '%s' numeric suffix id (%i) conflicts with the system provided sfx id (%i).",cwStringNullGuard(proc_label_str),pstate.proc_label_sfx_id,system_sfx_id);
+        goto errLabel;
+      }
+
+      pstate.proc_label        = mem::duplStr(s);
+      pstate.proc_label_sfx_id = sfx_id;
+
+    errLabel:
+      return rc;
+      
+    }
+    
+    rc_t _parse_proc_inst_cfg( network_t& net, const object_t* proc_inst_cfg, unsigned system_sfx_id, proc_inst_parse_state_t& pstate )
+    {
+      rc_t            rc       = kOkRC;
+      const object_t* arg_dict = nullptr;
+      unsigned sfx_id;
+      
+      // validate the syntax of the proc_inst_cfg pair
+      if( !_is_non_null_pair(proc_inst_cfg))
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. is not a valid pair.");
+        goto errLabel;
+      }
+
+      pstate.proc_label_sfx_id = kInvalidId;
+      
+      // extract the proc instance label and (sfx-id suffix)
+      if((rc = _parse_proc_inst_label( proc_inst_cfg->pair_label(), system_sfx_id, pstate )) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"Parsing failed on the label and sfx-id for '%s'.",cwStringNullGuard(proc_inst_cfg->pair_label()));
+        goto errLabel;
+      }
+      
+      // verify that the proc instance label is unique
+      if( proc_find(net,pstate.proc_label,pstate.proc_label_sfx_id) != nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance label '%s:%i' has already been used.",pstate.proc_label,pstate.proc_label_sfx_id);
         goto errLabel;
       }
       
       // get the proc instance class label
       if((rc = proc_inst_cfg->pair_value()->getv("class",pstate.proc_clas_label)) != kOkRC )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. %s is missing: 'type'.",pstate.proc_label);
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. %s:%i is missing: 'type'.",pstate.proc_label,pstate.proc_label_sfx_id);
         goto errLabel;        
       }
       
@@ -1565,7 +1736,7 @@ namespace cw
                                                      "preset",   pstate.preset_labels,
                                                      "log",      pstate.log_labels )) != kOkRC )
       {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. '%s' missing: 'type'.",pstate.proc_label);
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. '%s:%i' missing: 'type'.",pstate.proc_label,pstate.proc_label_sfx_id);
         goto errLabel;        
       }
 
@@ -1577,7 +1748,7 @@ namespace cw
         // verify the arg. dict is actually a dict.
         if( !arg_dict->is_dict() )
         {
-          cwLogError(kSyntaxErrorRC,"The proc instance argument dictionary on proc instance '%s' is not a dictionary.",pstate.proc_label);
+          cwLogError(kSyntaxErrorRC,"The proc instance argument dictionary on proc instance '%s:%i' is not a dictionary.",pstate.proc_label,pstate.proc_label_sfx_id);
           goto errLabel;
         }
         
@@ -1595,7 +1766,7 @@ namespace cw
           // if an explicit arg. label was given but it was not found
           if( rptErrFl )
           {
-            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on proc instance cfg. '%s'.",pstate.arg_label,pstate.proc_label);
+            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on proc instance cfg. '%s:%i'.",pstate.arg_label,pstate.proc_label,pstate.proc_label_sfx_id);
             goto errLabel;
           }
 
@@ -1607,7 +1778,7 @@ namespace cw
 
     errLabel:
       if( rc != kOkRC )
-        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on proc instance: '%s'.", cwStringNullGuard(pstate.proc_label) );
+        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on proc instance: '%s:%i'.", cwStringNullGuard(pstate.proc_label),pstate.proc_label_sfx_id);
       
       return rc;
     }
@@ -1617,9 +1788,10 @@ namespace cw
       for(unsigned i=0; i<pstate.in_arrayN; ++i)
         _destroy_in_stmt(pstate.in_array[i]);
       mem::release(pstate.in_array);
+      mem::release(pstate.proc_label);
     }
 
-    // Count of proc proc instances which exist in the network with a given class.
+    // Count of proc inst instances which exist in the network with a given class.
     unsigned _poly_copy_count( const network_t& net, const char* proc_clas_label )
     {
       unsigned n = 0;
@@ -1639,7 +1811,7 @@ namespace cw
     {
       rc_t                    rc         = kOkRC;
       proc_inst_parse_state_t pstate     = {};
-      proc_t*             proc       = nullptr;
+      proc_t*                 proc       = nullptr;
       class_desc_t*           class_desc = nullptr;
 
       proc_ref = nullptr;
@@ -1655,11 +1827,11 @@ namespace cw
         goto errLabel;
       }
 
-      // if the poly proc instance count has been exceeded for this proc proc class ...
+      // if the poly proc instance count has been exceeded for this proc inst class ...
       if(class_desc->polyLimitN > 0 && _poly_copy_count(net,pstate.proc_clas_label) >= class_desc->polyLimitN )
       {
         // ... then silently skip this instantiation
-        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.proc_label,sfx_id);
+        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.proc_label,pstate.proc_label_sfx_id);
         goto errLabel;
       }
       
@@ -1668,7 +1840,7 @@ namespace cw
 
       proc->ctx           = p;
       proc->label         = mem::duplStr(pstate.proc_label);
-      proc->label_sfx_id  = sfx_id;
+      proc->label_sfx_id  = pstate.proc_label_sfx_id;
       proc->proc_cfg      = proc_inst_cfg->pair_value();
       proc->arg_label     = pstate.arg_label;
       proc->arg_cfg       = pstate.arg_cfg;
@@ -1678,14 +1850,14 @@ namespace cw
       // parse the in-list ,fill in pstate.in_array, and create var proc instances for var's referenced by in-list
       if((rc = _parse_in_list( net, proc, proxyVarL, pstate )) != kOkRC )
       {
-        rc = cwLogError(rc,"in-list parse failed on proc proc instance '%s:%i'.",cwStringNullGuard(proc->label),sfx_id);
+        rc = cwLogError(rc,"in-list parse failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
         goto errLabel;
       }
 
-      // create the vars that are connected to the proxy vars
+      // if this is a subnet wrapper proc then create the vars that are connected to the proxy vars
       if((rc = _create_proxied_vars( proc, proxyVarL )) != kOkRC )
       {
-        rc = cwLogError(rc,"Proxy vars create failed on proc proc instance '%s:%i'.",cwStringNullGuard(proc->label),sfx_id);
+        rc = cwLogError(rc,"Proxy vars create failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
         goto errLabel;
       }
 
@@ -1709,7 +1881,7 @@ namespace cw
       // All the class presets values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
-      // Apply the proc proc instance 'args:{}' values.
+      // Apply the proc inst instance 'args:{}' values.
       if( pstate.arg_cfg != nullptr )
       {
         if((rc = _proc_inst_args_channelize_vars( proc, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
@@ -1737,7 +1909,7 @@ namespace cw
       }
 
       
-      // Complete the instantiation of the proc proc instance by calling the custom proc instance creation function.
+      // Complete the instantiation of the proc inst instance by calling the custom proc instance creation function.
 
       // Call the custom proc instance create() function.
       if((rc = class_desc->members->create( proc )) != kOkRC )
@@ -1766,7 +1938,7 @@ namespace cw
 
       if((rc = proc_validate(proc)) != kOkRC )
       {
-        rc = cwLogError(rc,"Proc proc instance validation failed.");
+        rc = cwLogError(rc,"proc inst instance validation failed.");
         goto errLabel;
       }
       
@@ -1775,7 +1947,7 @@ namespace cw
     errLabel:
       if( rc != kOkRC )
       {
-        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.proc_label),sfx_id);
+        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.proc_label),pstate.proc_label_sfx_id);
         proc_destroy(proc);
       }
       
@@ -2074,11 +2246,14 @@ cw::rc_t cw::flow::network_create( flow_t*            p,
 
       for(unsigned k=0; k<innerN; ++k)
       {
-        unsigned sfx_id = orderId == kNetFirstPolyOrderId ? i : k;
+        unsigned sfx_id = kInvalidId;
+
+        if( polyCnt > 1 )
+          sfx_id = orderId == kNetFirstPolyOrderId ? i : k;
 
         assert(net.proc_arrayN < net.proc_arrayAllocN );
         
-        // create the proc proc instance
+        // create the proc inst instance
         if( (rc= _create_proc_instance( p, proc_cfg, sfx_id, net, proxyVarL, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
         {
           //rc = cwLogError(rc,"The instantiation at proc index %i is invalid.",net.proc_arrayN);
@@ -2145,17 +2320,17 @@ cw::rc_t cw::flow::get_variable( network_t& net, const char* proc_label, const c
   varPtrRef = nullptr;
   procPtrRef = nullptr;
 
-  // locate the proc proc instance
+  // locate the proc inst instance
   if((proc = proc_find(net,proc_label,kBaseSfxId)) == nullptr )
   {
-    rc = cwLogError(kInvalidIdRC,"Unknown proc proc instance label '%s'.", cwStringNullGuard(proc_label));
+    rc = cwLogError(kInvalidIdRC,"Unknown proc inst instance label '%s'.", cwStringNullGuard(proc_label));
     goto errLabel;
   }
 
   // locate the variable
   if((rc = var_find( proc, var_label, kBaseSfxId, chIdx, var)) != kOkRC )
   {
-    rc = cwLogError(kInvalidArgRC,"The variable '%s' could not be found on the proc proc instance '%s'.",cwStringNullGuard(var_label),cwStringNullGuard(proc_label));
+    rc = cwLogError(kInvalidArgRC,"The variable '%s' could not be found on the proc inst instance '%s'.",cwStringNullGuard(var_label),cwStringNullGuard(proc_label));
     goto errLabel;
   }
 

From 4872f9234ba408783d7ed44f16b7e211ee87d402 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 8 May 2024 10:21:21 -0400
Subject: [PATCH 062/101] cweFlowTypes : Added var_mult_count(). Added
 flow_t.isInRuntimeFl. Replaced identifier 'inst' with 'proc' throughout file.

---
 cwFlowTypes.cpp |  53 +++++++++-------
 cwFlowTypes.h   | 160 +++++++++++++++++++++++++-----------------------
 2 files changed, 113 insertions(+), 100 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 2d9e1e4..a85068b 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -688,7 +688,7 @@ namespace cw
           return kOkRC;
         }
       }
-      return cwLogError(kInvalidIdRC,"The variable matching id:%i ch:%i on procance '%s:%i' could not be found.", vid, chIdx, proc->label, proc->label_sfx_id);
+      return cwLogError(kInvalidIdRC,"The variable matching id:%i ch:%i on proc '%s:%i' could not be found.", vid, chIdx, proc->label, proc->label_sfx_id);
     }
 
     // Variable lookup: Exact match on label and chIdx
@@ -715,10 +715,10 @@ namespace cw
     rc_t _validate_var_assignment( variable_t* var, unsigned typeFl )
     {
       if( cwIsFlag(var->varDesc->flags, kSrcVarDescFl ) )
-        return cwLogError(kInvalidStateRC, "The variable '%s:%i' on procance '%s:%i' cannot be set because it is a 'src' variable.", var->label, var->label_sfx_id, var->proc->label,var->proc->label_sfx_id);
+        return cwLogError(kInvalidStateRC, "The variable '%s:%i' on proc '%s:%i' cannot be set because it is a 'src' variable.", var->label, var->label_sfx_id, var->proc->label,var->proc->label_sfx_id);
       /*
       if( !cwIsFlag(var->varDesc->type, typeFl ) )
-        return cwLogError(kTypeMismatchRC, "The variable '%s:%i' on procance '%s:%i' is not a  '%s'.", var->label, var->label_sfx_id, var->proc->label, var->proc->label_sfx_id, _typeFlagToLabel( typeFl ));
+        return cwLogError(kTypeMismatchRC, "The variable '%s:%i' on proc '%s:%i' is not a  '%s'.", var->label, var->label_sfx_id, var->proc->label, var->proc->label_sfx_id, _typeFlagToLabel( typeFl ));
       */
       
       return kOkRC;
@@ -840,12 +840,12 @@ namespace cw
       var->value           = var->local_value + next_local_value_idx;
       var->local_value_idx = next_local_value_idx;
       
-      // If the procance is fully initialized ...
+      // If the proc is fully initialized ...
       if( var->proc->varMapA != nullptr )
       {
         // ... then inform the proc. that the value changed
         // Note 1: We don't want to this call to occur if we are inside or prior to 'proc.create()' 
-        // call because calls' to 'proc.value()' will see the procance in a incomplete state)
+        // call because calls' to 'proc.value()' will see the proc in a incomplete state)
         // Note 2: If this call returns an error then the value assignment is cancelled
         // and the value does not change.
         rc = var_call_custom_value_func( var );
@@ -881,7 +881,7 @@ namespace cw
       // if this variable is fed from the output of an external proc - then it's local value cannot be set
       if(is_connected_to_source_proc(var)   )
       {
-        return cwLogError(kInvalidStateRC,"Cannot set the value on a connected variables.");
+        return cwLogError(kInvalidStateRC,"Cannot set the value on the connected variable %s:%i-%s:%i.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id);
       }
 
       // if this assignment targets a specific channel ...
@@ -949,7 +949,7 @@ namespace cw
 
       // verify that the map idx is valid
       if( idx >= proc->varMapN )
-        return cwLogError(kAssertFailRC,"The variable map positioning location %i is out of the range %i on procance '%s:%i' vid:%i ch:%i.", idx, proc->varMapN, proc->label,proc->label_sfx_id,vid,chIdx);
+        return cwLogError(kAssertFailRC,"The variable map positioning location %i is out of the range %i on proc '%s:%i' vid:%i ch:%i.", idx, proc->varMapN, proc->label,proc->label_sfx_id,vid,chIdx);
 
       idxRef = idx;
   
@@ -1043,7 +1043,7 @@ namespace cw
       // if this var already exists - it can't be created again
       if((var = _var_find_on_label_and_ch(proc,var_label, sfx_id, chIdx)) != nullptr )
       {
-        rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' ch:%i has already been created on the procance: '%s:%i'.",var_label,sfx_id,chIdx,proc->label,proc->label_sfx_id);
+        rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' ch:%i has already been created on the proc: '%s:%i'.",var_label,sfx_id,chIdx,proc->label,proc->label_sfx_id);
         goto errLabel;
       }
 
@@ -1417,13 +1417,13 @@ void cw::flow::class_dict_print( flow_t* p )
 
 void cw::flow::network_print( const network_t& net )
 {
-  // for each procance in the network
+  // for each proc in the network
   for(unsigned i=0; i<net.proc_arrayN; ++i)
   {
     proc_t* proc = net.proc_array[i];
     proc_print(proc);
 
-    // if this procance has an  internal network
+    // if this proc has an  internal network
     if( proc->internal_net != nullptr )
     {
       printf("------- Begin Nested Network: %s -------\n",cwStringNullGuard(proc->label));
@@ -1520,7 +1520,7 @@ cw::rc_t cw::flow::proc_find( network_t& net, const char* proc_label, unsigned s
   if((procPtrRef = proc_find(net,proc_label,sfx_id)) != nullptr )
     return rc;
       
-  return cwLogError(kInvalidArgRC,"The procance '%s:%i' was not found.", proc_label, sfx_id );
+  return cwLogError(kInvalidArgRC,"The proc '%s:%i' was not found.", proc_label, sfx_id );
 }
 
 cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel )
@@ -1698,7 +1698,7 @@ cw::rc_t  cw::flow::var_channelize( proc_t* proc, const char* var_label, unsigne
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on procance '%s:%i' ch:%i.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx );
+    rc = cwLogError(rc,"Channelize failed for variable '%s:%i' on proc '%s:%i' ch:%i.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx );
   
   return rc;
 }
@@ -1821,7 +1821,7 @@ cw::rc_t cw::flow::var_find( proc_t* proc, unsigned vid, unsigned chIdx, variabl
       
   varRef = nullptr;
 
-  // if the varMapA[] has not yet been formed (we are inside the procance constructor) then do a slow lookup of the variable
+  // if the varMapA[] has not yet been formed (we are inside the proc constructor) then do a slow lookup of the variable
   if( proc->varMapA == nullptr )
   {
     if((rc = _var_find_on_vid_and_ch(proc,vid,chIdx,var)) != kOkRC )
@@ -1834,7 +1834,7 @@ cw::rc_t cw::flow::var_find( proc_t* proc, unsigned vid, unsigned chIdx, variabl
       var = proc->varMapA[idx];
     else
     {
-      rc = cwLogError(kInvalidIdRC,"The index of variable vid:%i chIdx:%i on procance '%s:%i' could not be calculated and the variable value could not be retrieved.", vid, chIdx, proc->label,proc->label_sfx_id);
+      rc = cwLogError(kInvalidIdRC,"The index of variable vid:%i chIdx:%i on proc '%s:%i' could not be calculated and the variable value could not be retrieved.", vid, chIdx, proc->label,proc->label_sfx_id);
       goto errLabel;
     }
   }
@@ -1861,7 +1861,7 @@ cw::rc_t cw::flow::var_find( proc_t* proc, const char* label, unsigned sfx_id, u
     return kOkRC;
   }
 
-  return cwLogError(kInvalidIdRC,"The procance '%s:%i' does not have a variable named '%s:%i'.", proc->label, proc->label_sfx_id, label, sfx_id );  
+  return cwLogError(kInvalidIdRC,"The proc '%s:%i' does not have a variable named '%s:%i'.", proc->label, proc->label_sfx_id, label, sfx_id );  
 }
 
 cw::rc_t cw::flow::var_find( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx, const variable_t*& vRef )
@@ -1892,7 +1892,7 @@ cw::rc_t  cw::flow::var_channel_count( const variable_t* var, unsigned& chCntRef
   
   if((rc = var_find( var->proc, var->label, var->label_sfx_id, kAnyChIdx, v )) != kOkRC )
   {
-    rc = cwLogError(kInvalidStateRC,"The base channel variable procance could not be found for the variable '%s:%i.%s:%i'.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id);
+    rc = cwLogError(kInvalidStateRC,"The base channel variable proc could not be found for the variable '%s:%i.%s:%i'.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id);
     goto errLabel;
   }
 
@@ -1912,7 +1912,7 @@ cw::rc_t cw::flow::var_register( proc_t* proc, const char* var_label, unsigned s
 
   varRef = nullptr;
 
-  // TODO: check for duplicate 'vid'-'chIdx' pairs on this procance
+  // TODO: check for duplicate 'vid'-'chIdx' pairs on this proc
   // The concatenation of 'vid' and 'chIdx' should be unique 
 
   // if an exact match to label/chIdx was found
@@ -1935,11 +1935,11 @@ cw::rc_t cw::flow::var_register( proc_t* proc, const char* var_label, unsigned s
   if((var = _var_find_on_label_and_ch(proc,var_label,sfx_id,kAnyChIdx)) != nullptr )
     var->vid = vid;
   else
-    rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' procance '%s:%i' has no base channel.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx);
+    rc = cwLogError(kInvalidStateRC,"The variable '%s:%i' proc '%s:%i' has no base channel.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx);
   
  errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Registration failed on variable '%s:%i' procance '%s:%i' ch: %i.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx);
+    rc = cwLogError(rc,"Registration failed on variable '%s:%i' proc '%s:%i' ch: %i.", var_label, sfx_id, proc->label, proc->label_sfx_id, chIdx);
   
   return rc;
 }
@@ -1991,6 +1991,15 @@ void cw::flow::var_connect( variable_t* src_var, variable_t* in_var )
   
 }
 
+unsigned  cw::flow::var_mult_count( proc_t* proc, const char* var_label )
+{
+  unsigned n = 0;
+  for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+    if( textIsEqual(var->label,var_label) )
+      ++n;
+  
+  return n;
+}
 
 cw::rc_t  cw::flow::var_mult_sfx_id_array( proc_t* proc, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref )
 {
@@ -2041,7 +2050,7 @@ cw::rc_t        cw::flow::var_register_and_set( proc_t* proc, const char* var_la
   abuf_t* abuf;
   
   if((abuf = abuf_create( srate, chN, frameN )) == nullptr )
-    return cwLogError(kOpFailRC,"abuf create failed on procance:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label,sfx_id);
+    return cwLogError(kOpFailRC,"abuf create failed on proc:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label,sfx_id);
 
   if((rc = _var_register_and_set( proc, var_label, sfx_id, vid, chIdx, abuf )) != kOkRC )
     abuf_destroy(abuf);
@@ -2054,7 +2063,7 @@ cw::rc_t cw::flow::var_register_and_set( proc_t* proc, const char* var_label, un
   rc_t rc = kOkRC;
   fbuf_t* fbuf;
   if((fbuf = fbuf_create( srate, chN, maxBinN_V, binN_V, hopSmpN_V, magV, phsV, hzV )) == nullptr )
-    return cwLogError(kOpFailRC,"fbuf create failed on procance:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label,sfx_id);
+    return cwLogError(kOpFailRC,"fbuf create failed on proc:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label,sfx_id);
 
   if((rc = _var_register_and_set( proc, var_label, sfx_id, vid, chIdx, fbuf )) != kOkRC )
     fbuf_destroy(fbuf);
@@ -2068,7 +2077,7 @@ cw::rc_t        cw::flow::var_register_and_set( proc_t* proc, const char* var_la
   mbuf_t* mbuf;
   
   if((mbuf = mbuf_create(msgA,msgN)) == nullptr )
-    return cwLogError(kOpFailRC,"mbuf create failed on procance:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label, sfx_id);
+    return cwLogError(kOpFailRC,"mbuf create failed on proc:'%s:%i' variable:'%s:%i'.", proc->label, proc->label_sfx_id, var_label, sfx_id);
 
   if((rc = _var_register_and_set( proc, var_label, sfx_id, vid, chIdx, mbuf )) != kOkRC )
     mbuf_destroy(mbuf);
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 93922b4..068a256 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -197,7 +197,7 @@ namespace cw
       char*                label;        // this variables label
       unsigned             label_sfx_id; // the label suffix id of this variable or kBaseSfxId if this has no suffix
       
-      unsigned             vid;          // this variables numeric id ( cat(vid,chIdx) forms a unique variable identifier on this 'inst'      
+      unsigned             vid;          // this variables numeric id ( cat(vid,chIdx) forms a unique variable identifier on this 'proc'      
       unsigned             chIdx;        // channel index
       unsigned             flags;        // kLogVarFl
       unsigned             type;         // This is the value type as established when the var is initialized - it never changes for the life of the var.
@@ -225,14 +225,14 @@ namespace cw
 
     typedef struct network_str
     {
-      const object_t*      procsCfg;       // network proc list
-      const object_t*      presetsCfg;     // presets designed for this network
-
-      unsigned poly_cnt; // count of duplicated networks in the list
-
+      const object_t*   procsCfg;   // network proc list
+      const object_t*   presetsCfg; // presets designed for this network
+      unsigned          poly_cnt;   // count of duplicated networks in the list
+      
       struct proc_str** proc_array;
-      unsigned              proc_arrayAllocN;
-      unsigned              proc_arrayN;
+      
+      unsigned          proc_arrayAllocN;
+      unsigned          proc_arrayN;
       
     } network_t;
     
@@ -269,24 +269,25 @@ namespace cw
     {
       const object_t*      flowCfg;     // complete cfg used to create this flow 
 
+      bool                 isInRuntimeFl;        // Set when compile-time is complete
       
-      unsigned             framesPerCycle;  // sample frames per cycle (64)
-      srate_t              sample_rate;     // default sample rate (48000.0)
+      unsigned             framesPerCycle;       // sample frames per cycle (64)
+      srate_t              sample_rate;          // default sample rate (48000.0)
       bool                 multiPriPresetProbFl; // If set then probability is used to choose presets on multi-preset application
       bool                 multiSecPresetProbFl; // 
-      bool                 multiPresetInterpFl; // If set then interpolation is applied between two selectedd presets on multi-preset application
-      unsigned             cycleIndex;     // Incremented with each processing cycle      
-      unsigned             maxCycleCount;  // count of cycles to run on flow::exec() or 0 if there is no limit.
+      bool                 multiPresetInterpFl;  // If set then interpolation is applied between two selectedd presets on multi-preset application
+      unsigned             cycleIndex;           // Incremented with each processing cycle      
+      unsigned             maxCycleCount;        // count of cycles to run on flow::exec() or 0 if there is no limit.
       
-      class_desc_t*        classDescA;     // 
-      unsigned             classDescN;     //
+      class_desc_t*        classDescA;           // 
+      unsigned             classDescN;           //
 
-      class_desc_t*        subnetDescA;     // 
-      unsigned             subnetDescN;     //
+      class_desc_t*        subnetDescA;          // 
+      unsigned             subnetDescN;          //
       
 
-      external_device_t*   deviceA;        // deviceA[ deviceN ] external device description array
-      unsigned             deviceN;        //
+      external_device_t*   deviceA;              // deviceA[ deviceN ] external device description array
+      unsigned             deviceN;              //
       
       network_t net;
 
@@ -365,15 +366,15 @@ namespace cw
     void               proc_destroy( proc_t* proc );
     rc_t               proc_validate( proc_t* proc );
     
-    proc_t*            proc_find( network_t& net, const char* inst_label, unsigned sfx_id );
-    rc_t               proc_find( network_t& net, const char* inst_label, unsigned sfx_id, proc_t*& instPtrRef );
+    proc_t*            proc_find( network_t& net, const char* proc_label, unsigned sfx_id );
+    rc_t               proc_find( network_t& net, const char* proc_label, unsigned sfx_id, proc_t*& procPtrRef );
     
     external_device_t* external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel=nullptr );
 
-    void               proc_print( proc_t* inst );
+    void               proc_print( proc_t* proc );
 
-    // Count of all var instances on this proc.  This is a count of the length of inst->varL.
-    unsigned           proc_var_count( proc_t* inst );
+    // Count of all var instances on this proc.  This is a count of the length of proc->varL.
+    unsigned           proc_var_count( proc_t* proc );
 
     
     //------------------------------------------------------------------------------------------------------------------------
@@ -385,23 +386,23 @@ namespace cw
     // Notes:
     // 1) `value_cfg` is optional. Set it to NULL to ignore
     // 2) If `altTypeFl` is not set to kInvalidTFl then the var is assigned this type.
-    rc_t           var_create( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFlag, variable_t*& varRef );
+    rc_t           var_create( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, unsigned altTypeFlag, variable_t*& varRef );
     void           var_destroy( variable_t* var );
 
     // Channelizing creates a new var record with an explicit channel index to replace the
     // automatically generated variable whose channel index is set to  'all'.
-    rc_t           var_channelize( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
+    rc_t           var_channelize( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx, const object_t* value_cfg, unsigned vid, variable_t*& varRef );
 
-    // Wrapper around call to var->inst->members->value()
+    // Wrapper around call to var->proc->members->value()
     rc_t           var_call_custom_value_func( variable_t* var );
 
     // Sets and get the var->flags field
-    unsigned       var_flags(     proc_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref );
-    rc_t           var_set_flags( proc_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
-    rc_t           var_clr_flags( proc_t* inst, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
+    unsigned       var_flags(     proc_t* proc, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned& flags_ref );
+    rc_t           var_set_flags( proc_t* proc, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
+    rc_t           var_clr_flags( proc_t* proc, unsigned chIdx, const char* var_label, unsigned sfx_id, unsigned flags );
 
     // `value_cfg` is optional. Set it to NULL to ignore
-    rc_t           var_register( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
+    rc_t           var_register( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
     // Returns true if this var is connected to an source proc variable
     bool           is_connected_to_source_proc( const variable_t* var );
@@ -412,8 +413,11 @@ namespace cw
     // Connect in_var to src_var. 
     void           var_connect( variable_t* src_var, variable_t* in_var );
 
+    // Get the count of 'mult' vars associated with this var label.
+    unsigned       var_mult_count( proc_t* proc, const char* var_label );
+    
     // Get all the label-sfx-id's associated with a give var label
-    rc_t           var_mult_sfx_id_array( proc_t* inst, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
+    rc_t           var_mult_sfx_id_array( proc_t* proc, const char* var_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
     
     //-----------------
     //
@@ -423,20 +427,20 @@ namespace cw
     inline rc_t _var_reg(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
     
     template< typename T0, typename T1,  typename... ARGS >
-    rc_t _var_reg( proc_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, ARGS&&... args )
+    rc_t _var_reg( proc_t* proc, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, ARGS&&... args )
     {
       rc_t rc;
       variable_t* dummy = nullptr;
-      if((rc = var_register( inst, var_label, sfx_id, vid, chIdx, nullptr, dummy )) == kOkRC )        
-        if((rc = _var_reg( inst, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
+      if((rc = var_register( proc, var_label, sfx_id, vid, chIdx, nullptr, dummy )) == kOkRC )        
+        if((rc = _var_reg( proc, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
           return rc;
       return rc;
     }
 
     // Call var_register() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register( proc_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
-    {  return _var_reg( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
+    rc_t           var_register( proc_t* proc, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
+    {  return _var_reg( proc, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
 
@@ -448,11 +452,11 @@ namespace cw
     inline rc_t _var_register_and_get(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
 
     template< typename T>
-    rc_t var_register_and_get( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, T& valRef )
+    rc_t var_register_and_get( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, T& valRef )
     {
       rc_t rc;
       variable_t* var;
-      if((rc = var_register(inst,var_label,sfx_id,vid,chIdx,nullptr,var)) == kOkRC )
+      if((rc = var_register(proc,var_label,sfx_id,vid,chIdx,nullptr,var)) == kOkRC )
         rc = var_get(var,valRef);
       return rc;
     }
@@ -461,12 +465,12 @@ namespace cw
     inline rc_t _var_reg_and_get(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
 
     template< typename T0, typename T1, typename T2, typename... ARGS >
-    rc_t _var_reg_and_get( proc_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2& valRef, ARGS&&... args )
+    rc_t _var_reg_and_get( proc_t* proc, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2& valRef, ARGS&&... args )
     {
       rc_t rc;
 
-      if((rc = var_register_and_get( inst, var_label, sfx_id, vid, chIdx, valRef )) == kOkRC )        
-        if((rc = _var_reg_and_get( inst, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
+      if((rc = var_register_and_get( proc, var_label, sfx_id, vid, chIdx, valRef )) == kOkRC )        
+        if((rc = _var_reg_and_get( proc, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
           return rc;
       
       return rc;
@@ -474,8 +478,8 @@ namespace cw
 
     // Call var_register_and_get() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register_and_get( proc_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id,  ARGS&&... args )
-    {  return _var_reg_and_get( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
+    rc_t           var_register_and_get( proc_t* proc, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id,  ARGS&&... args )
+    {  return _var_reg_and_get( proc, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
     
@@ -487,27 +491,27 @@ namespace cw
     // var_register_and_set().  If the variable has not yet been created then it is created and assigned a value.
     // If the variable has already been created then 'vid' and the value are updated.
     // (Note that abuf and fbuf values are not changed by this function only the 'vid' is updated.)
-    rc_t           var_register_and_set( proc_t* inst, const char* label,  unsigned sfx_id,   unsigned vid, unsigned chIdx, variable_t*& varRef );
+    rc_t           var_register_and_set( proc_t* proc, const char* label,  unsigned sfx_id,   unsigned vid, unsigned chIdx, variable_t*& varRef );
     
-    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
-    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
-    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
-    rc_t           var_register_and_set( proc_t* inst, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
+    rc_t           var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned frameN );
+    rc_t           var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, midi::ch_msg_t* midiA, unsigned midiN );
+    rc_t           var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, const unsigned* maxBinN_V, const unsigned* binN_V, const unsigned* hopSmpN_V, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
+    rc_t           var_register_and_set( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, srate_t srate, unsigned chN, unsigned maxBinN, unsigned binN, unsigned hopSmpN, const fd_sample_t** magV=nullptr, const fd_sample_t** phsV=nullptr, const fd_sample_t** hzV=nullptr );
 
     inline rc_t _var_register_and_set(cw::flow::proc_t*, unsigned int ) { return kOkRC; }
 
     template< typename T0, typename T1, typename T2, typename... ARGS >
-    rc_t _var_register_and_set( proc_t* inst, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2 val, ARGS&&... args )
+    rc_t _var_register_and_set( proc_t* proc, unsigned chIdx, T0 vid, T1 var_label, unsigned sfx_id, T2 val, ARGS&&... args )
     {
       rc_t rc;
 
       variable_t* var = nullptr;
-      if((rc = var_register_and_set( inst, var_label, sfx_id, vid, chIdx, var)) == kOkRC )
+      if((rc = var_register_and_set( proc, var_label, sfx_id, vid, chIdx, var)) == kOkRC )
       {
-        if((rc = var_set( inst, vid, chIdx, val )) != kOkRC )
+        if((rc = var_set( proc, vid, chIdx, val )) != kOkRC )
           return rc;
         
-        if((rc = _var_register_and_set( inst, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
+        if((rc = _var_register_and_set( proc, chIdx, std::forward<ARGS>(args)...)) != kOkRC )
           return rc;
       }
       
@@ -516,25 +520,25 @@ namespace cw
 
     // Call var_register_and_set() on a list of variables.
     template< typename... ARGS >
-    rc_t           var_register_and_set( proc_t* inst, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
-    {  return _var_register_and_set( inst, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
+    rc_t           var_register_and_set( proc_t* proc, unsigned chIdx, unsigned vid, const char* var_label, unsigned sfx_id, ARGS&&... args )
+    {  return _var_register_and_set( proc, chIdx, vid, var_label, sfx_id, std::forward<ARGS>(args)...); }
 
 
 
     void           _var_destroy( variable_t* var );
 
-    bool           var_exists(    proc_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
-    bool           var_has_value( proc_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
-    bool           var_is_a_source( proc_t* inst, const char* label, unsigned sfx_id, unsigned chIdx );
-    bool           var_is_a_source( proc_t* inst, unsigned vid, unsigned chIdx );
+    bool           var_exists(      proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_has_value(   proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_is_a_source( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx );
+    bool           var_is_a_source( proc_t* proc, unsigned vid, unsigned chIdx );
 
-    rc_t           var_find(   proc_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx, const variable_t*& varRef );
-    rc_t           var_find(   proc_t* inst, const char* var_label, unsigned sfx_id, unsigned chIdx,       variable_t*& varRef );
-    rc_t           var_find(   proc_t* inst, unsigned vid,                           unsigned chIdx,       variable_t*& varRef );
+    rc_t           var_find(   proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx, const variable_t*& varRef );
+    rc_t           var_find(   proc_t* proc, const char* var_label, unsigned sfx_id, unsigned chIdx,       variable_t*& varRef );
+    rc_t           var_find(   proc_t* proc, unsigned vid,                           unsigned chIdx,       variable_t*& varRef );
 
     
-    // Count of numbered channels - does not count the kAnyChIdx variable instance.
-    rc_t           var_channel_count( proc_t* inst, const char* label, unsigned sfx_idx, unsigned& chCntRef );
+    // Count of numbered channels - does not count the kAnyChIdx variable procance.
+    rc_t           var_channel_count( proc_t* proc, const char* label, unsigned sfx_idx, unsigned& chCntRef );
     rc_t           var_channel_count( const variable_t* var, unsigned& chCntRef );
     
 
@@ -557,22 +561,22 @@ namespace cw
     rc_t var_get( const variable_t* var, const object_t*& valRef );
 
     template< typename T>
-    rc_t var_get( proc_t* inst, unsigned vid, unsigned chIdx, T& valRef)
+    rc_t var_get( proc_t* proc, unsigned vid, unsigned chIdx, T& valRef)
     {
       rc_t        rc  = kOkRC;
       variable_t* var = nullptr;
       
-      if((rc = var_find(inst, vid, chIdx, var )) == kOkRC )
+      if((rc = var_find(proc, vid, chIdx, var )) == kOkRC )
         rc = var_get(var,valRef);
       
       return rc;  
     }
 
     template< typename T >
-    T val_get( proc_t* inst, unsigned vid, unsigned chIdx )
+    T val_get( proc_t* proc, unsigned vid, unsigned chIdx )
     {
       T value;
-      var_get(inst,vid,chIdx,value);
+      var_get(proc,vid,chIdx,value);
       return value;
     }
 
@@ -594,16 +598,16 @@ namespace cw
     rc_t var_set( variable_t* var, mbuf_t* val );
     rc_t var_set( variable_t* var, const object_t* val );
     
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, const value_t* val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, bool val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, uint_t val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, int_t val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, float val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, double val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, const char* val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, abuf_t* val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, fbuf_t* val );
-    rc_t var_set( proc_t* inst, unsigned vid, unsigned chIdx, const object_t* val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, const value_t* val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, bool val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, uint_t val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, int_t val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, float val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, double val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, const char* val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, abuf_t* val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, fbuf_t* val );
+    rc_t var_set( proc_t* proc, unsigned vid, unsigned chIdx, const object_t* val );
 
     
   }

From 9f1339e51719c9590a5a5dd8ff33359e98a8d243 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 8 May 2024 10:24:25 -0400
Subject: [PATCH 063/101] cwFlow.cpp : maxCycleCnt=0 now means that the init
 pass should be run but not the runtime pass. Setting maxCycleCnt to
 kInvalidCnt now removed cycle count limit.

---
 cwFlow.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index ffe2c36..f1b2b90 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -675,6 +675,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   bool            printClassDictFl = false;
   bool            printNetworkFl   = false;
   variable_t*     proxyVarL        = nullptr;
+  unsigned        maxCycleCount    = kInvalidCnt;
   
   if(( rc = destroy(hRef)) != kOkRC )
     return rc;
@@ -708,11 +709,12 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
 
   p->framesPerCycle = kDefaultFramesPerCycle;
   p->sample_rate    = kDefaultSampleRate;
-
+  p->maxCycleCount  = kInvalidCnt;
+  
   // parse the optional args
   if((rc = flowCfg->getv_opt("framesPerCycle",      p->framesPerCycle,
                             "sample_rate",          p->sample_rate,
-                            "maxCycleCount",        p->maxCycleCount,
+                            "maxCycleCount",        maxCycleCount,
                             "multiPriPresetProbFl", p->multiPriPresetProbFl,
                             "multiSecPresetProbFl", p->multiSecPresetProbFl,
                             "multiPresetInterpFl",  p->multiPresetInterpFl,
@@ -723,6 +725,9 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
     goto errLabel;
   }
 
+  if( maxCycleCount != kInvalidCnt )
+    p->maxCycleCount = maxCycleCount;
+
   for(unsigned i=0; i<deviceN; ++i)
     if( deviceA[i].typeId == kAudioDevTypeId )
     {
@@ -750,6 +755,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   if( printNetworkFl )
     network_print(p->net);
 
+  p->isInRuntimeFl = true;
   hRef.set(p);
   
  errLabel:
@@ -806,24 +812,22 @@ cw::rc_t cw::flow::exec(    handle_t h )
   rc_t    rc = kOkRC;
   flow_t* p  = _handleToPtr(h);
 
-  while( true )
+  for(; (p->maxCycleCount==kInvalidCnt || (p->maxCycleCount!=kInvalidCnt && p->cycleIndex < p->maxCycleCount)) && rc == kOkRC; p->cycleIndex++ )
   {  
     rc = exec_cycle(p->net);
 
+    // kEofRC indicates that the network asked to terminate
     if( rc == kEofRC )
     {
       rc = kOkRC;
       break;
     }    
     
-    p->cycleIndex += 1;
-    if( p->maxCycleCount > 0 && p->cycleIndex >= p->maxCycleCount )
-    {
-       cwLogInfo("'maxCycleCnt' reached: %i. Shutting down flow.",p->maxCycleCount);
-      break;
-    }
   }
 
+  if( p->maxCycleCount != kInvalidCnt && p->cycleIndex >= p->maxCycleCount )
+    cwLogInfo("'maxCycleCnt' reached: %i. Shutting down flow.",p->maxCycleCount);
+
   return rc;
 }
 

From 986b842bc61cdaed7df6fc41bda979229ab36178 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 8 May 2024 10:24:38 -0400
Subject: [PATCH 064/101] flow/flow_doc.md : Updates

---
 flow/flow_doc.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 6b26c12..6c301b3 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -31,6 +31,11 @@ and audio processing networks and the application of network state data.
 <label> : { 'class':<class>, "in":{<in_stmt>*}, "preset":<class_preset_label>, "log":<log_dict> "argLabel":<arg_preset_label>, "args":<args_dict> }
 ```
 
+Proc instance and variabel labels consist of two parts a leading identifier and a
+numeric suffix.  The numeric suffix is referred to as the _label_sfx_id_.
+A proc or variable label without a numeric suffix is automatically assigned the label suffix 0.
+
+
 __args__ : This is a dictionary of named variable value records. 
 __preset__ : This string references a class preset to use for initializing this proc instance.
 __argLabel__ : This string references an `args` dictionary parameter set to be applied after the __preset__ class preset.

From f8a907f36004fa6c45a90c4ea98d880648e9d751 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 8 May 2024 10:24:48 -0400
Subject: [PATCH 065/101] README.md : Updates.

---
 README.md | 66 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 44 insertions(+), 22 deletions(-)

diff --git a/README.md b/README.md
index 94160d8..dbecb11 100644
--- a/README.md
+++ b/README.md
@@ -581,7 +581,8 @@ Syntax:
 -------
 The 'in' list has the follow syntax:
 `in: { in-stmt* }`
-`in-stmt`     -> `in-var-id`":" `src_expr`
+`in-stmt`     -> `in_expr`":" `src_expr`
+`in-expr`     -> `in-proc-id`".`in-var-id`
 `src-expr`    -> `src-proc-id`"."`src-var-id`
 `in-var-id`   -> `var-id`
 `src-proc-id` -> `var-id`
@@ -595,6 +596,20 @@ The 'in' list has the follow syntax:
 Semantics:
 ----------
 
+### `in-proc-id`
+
+- The `in-proc-id` is only used when the in-stmt
+is iterating over the in-proc sfx-id. 
+This precludes iterating over the in-var, as discussed below.
+
+In this case the only useful option is to set the 'var-id` to `_`
+as the in-proc is taken as the the proc which the
+in-stmt belongs to.
+
+The iterating source and/or var sfx-id are then set
+to the current proc sfx-id + source `pri-int`.
+
+
 ### `in-var-id`
 
 - The `label` part of the `in-var-id`  must match to a 
@@ -911,19 +926,31 @@ Add proc instance field: `log:{ var_label_0:0, var_label_1:0 } `
 Next:
 
 - Complete subnets:
-	+ subnet var desc's should be the same as non+subnet vars but also include the 'proxy' field.
+	+ Subnets should have presets written in terms of the subnet vars rather than the network vars
+	or the value application needs to follow the internal variable src_var back to the proxy var.
+
+	+ write a paragraph in the flow_doc.md about overall approach taken to subnet implementation.
+	  Subnets are implemented in the following phases:
+	  - During program initialization the subnet cfg files is scanned and the
+	  proxy vars for each subnet are used to create `class_desc_t` records for each subnet.
+	  - When the subnet is instantiated the proxy vars are instantiated first.
+	  - Then the internal network is instantiated.
+
+	+ DONE: subnet var desc's should be the same as non+subnet vars but also include the 'proxy' field.
 	In particular they should get default values.
 	If a var desc is part of a subnet then it must have a proxy.
 	The output variables of var desc's must have the 'out' attribute
 
-	+ subnets should have presets written in terms of the subnet vars rather than the network vars
 
-	+ improve the subnet creating code by using consistent naming + use proxy or wrap but not both
+	+ DONE: improve the subnet creating code by using consistent naming + use proxy or wrap but not both
 
-	+ improve code comments on subnet creation
+	+ DONE: improve code comments on subnet creation
 
-	+ write a paragraph in the flow_doc.md about overall approach taken to subnet implementation.
-	
+- Implement feedback	
+- Audio inputs should be able to be initialized with a channel count and srate without actually connecting an input.
+  This will allow feedback connections to be attached to them at a later stage of the network 
+  instantiation.
+- Implement subnet preset application.	
 - Implement the var attributes and attribute checking.
 - Implement dynamic loading of procs.
 - Implement a debug mode to aid in building networks and subnets (or is logging good enough)
@@ -936,22 +963,10 @@ Next:
   One way around this is to instantiate them with an initial set of inputs but then
   allow those inputs to be replaced by a later connection.
   
-- DONE: Fix up the coding language - change the use of `instance_t` to `proc_t` and `inst` to `proc`, change use of `ctx` in cwFlowProc
-
-
-
 
 BUGS:
 - The counter modulo mode is not working as expected.
 
-- There is no way for a proc in a poly context to use it's poly channel number to 
-select a mult variable.  For example in an osc in a poly has no way to select
-the frequency of the osc by conneting to a non-poly proc - like a list.
-Consider: 
-1. Use a difference 'in' statememt (e.g. 'poly-in' but the 
-   same syntax used for connecting 'mult' variables.)
-2. Include the proc name in the 'in' var to indicate a poly index is being iterated
-   e.g. `lfo: { class:sine_tone, in:{ osc_.dc:list.value_ } }` 
 
 
 Host Environments:
@@ -967,6 +982,13 @@ Host Environments:
 
 - DONE: Turn on variable 'broadcast'.  Why was it turned off? ... maybe multiple updates?
 
-```
-	
-```
+- DONE: There is no way for a proc in a poly context to use it's poly channel number to 
+select a mult variable.  For example in an osc in a poly has no way to select
+the frequency of the osc by conneting to a non-poly proc - like a list.
+Consider: 
+1. Use a difference 'in' statememt (e.g. 'poly-in' but the 
+   same syntax used for connecting 'mult' variables.)
+2. Include the proc name in the 'in' var to indicate a poly index is being iterated
+   e.g. `lfo: { class:sine_tone, in:{ osc_.dc:list.value_ } }` 
+
+- DONE: Fix up the coding language - change the use of `instance_t` to `proc_t` and `inst` to `proc`, change use of `ctx` in cwFlowProc

From 55279360242e3007d60c552668c4d16dd204db12 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 21:54:39 -0400
Subject: [PATCH 066/101] cwLog : Added
 outputCbArg(),outputCb(),formatCbArg(),formatCb(). cwLogPrint() now prints
 irregardless of the current level.

---
 cwLog.cpp | 27 +++++++++++++++++++++++++--
 cwLog.h   |  6 ++++++
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/cwLog.cpp b/cwLog.cpp
index 3eb8297..7fa533c 100644
--- a/cwLog.cpp
+++ b/cwLog.cpp
@@ -112,7 +112,7 @@ cw::rc_t cw::log::msg( handle_t h, unsigned level, const char* function, const c
 cw::rc_t cw::log::msg( handle_t h, unsigned level, const char* function, const char* filename, unsigned line, int systemErrorCode, rc_t returnCode, const char* fmt, ... )
 {
   rc_t rc = returnCode;
-  if( level >= _handleToPtr(h)->level )
+  if( level >= _handleToPtr(h)->level || level == kPrint_LogLevel )
   {
     va_list vl;
     va_start(vl,fmt);
@@ -146,6 +146,29 @@ unsigned cw::log::flags( handle_t h )
   return p->flags;
 }
   
+void* cw::log::outputCbArg( handle_t h )
+{
+  log_t* p = _handleToPtr(h);
+  return p->outCbArg;
+}
+
+cw::log::logOutputCbFunc_t cw::log::outputCb( handle_t h )
+{
+  log_t* p = _handleToPtr(h);
+  return p->outCbFunc;
+}
+
+void* cw::log::formatCbArg( handle_t h )
+{
+  log_t* p = _handleToPtr(h);
+  return p->fmtCbArg;
+}
+
+cw::log::logFormatCbFunc_t cw::log::formatCb( handle_t h )
+{
+  log_t* p = _handleToPtr(h);
+  return p->fmtCbFunc;  
+}
 
 void cw::log::setOutputCb( handle_t h, logOutputCbFunc_t outFunc, void* outCbArg )
 {
@@ -214,7 +237,7 @@ void cw::log::defaultFormatter( void* cbArg, logOutputCbFunc_t outFunc, void* ou
 
 
   // don't print the function,file,line when this is an 'info' msg.
-  if( level == kInfo_LogLevel )
+  if( level == kInfo_LogLevel || level == kPrint_LogLevel )
   {
     loStr = "";
     syStr = "";
diff --git a/cwLog.h b/cwLog.h
index 708a174..5ccf3a0 100644
--- a/cwLog.h
+++ b/cwLog.h
@@ -39,6 +39,12 @@ namespace cw
     void     setLevel( handle_t h, unsigned level );
     unsigned level( handle_t h );
 
+    void*             outputCbArg( handle_t h );
+    logOutputCbFunc_t outputCb( handle_t h );
+    
+    void*             formatCbArg( handle_t h );
+    logFormatCbFunc_t formatCb( handle_t h );
+    
     void setOutputCb( handle_t h, logOutputCbFunc_t outFunc, void* outCbArg );
     void setFormatCb( handle_t h, logFormatCbFunc_t fmtFunc, void* fmtCbArg );
 

From dc27ffc7b4f499823b102e29ef5abec8fb922317 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 21:55:38 -0400
Subject: [PATCH 067/101] cwFlowTest,Makefile.am : Initial commit.

---
 Makefile.am    |   4 +-
 cwFlowTest.cpp | 327 +++++++++++++++++++++++++++++++++++++++++++++++++
 cwFlowTest.h   |   9 ++
 3 files changed, 338 insertions(+), 2 deletions(-)
 create mode 100644 cwFlowTest.cpp
 create mode 100644 cwFlowTest.h

diff --git a/Makefile.am b/Makefile.am
index a94f6e6..5fbc7e0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -34,8 +34,8 @@ libcwSRC += src/libcw/cwAudioFile.cpp   src/libcw/cwMidiFile.cpp
 libcwHDR += src/libcw/cwAudioFileOps.h    src/libcw/cwAudioTransforms.h   src/libcw/cwDspTransforms.h   src/libcw/cwAudioFileProc.h    src/libcw/cwPvAudioFileProc.h
 libcwSRC += src/libcw/cwAudioFileOps.cpp  src/libcw/cwAudioTransforms.cpp src/libcw/cwDspTransforms.cpp src/libcw/cwAudioFileProc.cpp  src/libcw/cwPvAudioFileProc.cpp
 
-libcwHDR += src/libcw/cwFlow.h    src/libcw/cwFlowDecl.h src/libcw/cwFlowTypes.h     src/libcw/cwFlowNet.h   src/libcw/cwFlowProc.h     src/libcw/cwFlowCross.h
-libcwSRC += src/libcw/cwFlow.cpp                         src/libcw/cwFlowTypes.cpp   src/libcw/cwFlowNet.cpp src/libcw/cwFlowProc.cpp   src/libcw/cwFlowCross.cpp
+libcwHDR += src/libcw/cwFlow.h    src/libcw/cwFlowDecl.h src/libcw/cwFlowTypes.h     src/libcw/cwFlowNet.h   src/libcw/cwFlowProc.h     src/libcw/cwFlowCross.h     src/libcw/cwFlowTest.h
+libcwSRC += src/libcw/cwFlow.cpp                         src/libcw/cwFlowTypes.cpp   src/libcw/cwFlowNet.cpp src/libcw/cwFlowProc.cpp   src/libcw/cwFlowCross.cpp   src/libcw/cwFlowTest.cpp
 
 if cwWEBSOCK
 libcwHDR += src/libcw/cwWebSock.h   src/libcw/cwWebSockSvr.h
diff --git a/cwFlowTest.cpp b/cwFlowTest.cpp
new file mode 100644
index 0000000..2060a09
--- /dev/null
+++ b/cwFlowTest.cpp
@@ -0,0 +1,327 @@
+#include "cwCommon.h"
+#include "cwLog.h"
+#include "cwCommonImpl.h"
+#include "cwMem.h"
+#include "cwText.h"
+#include "cwNumericConvert.h"
+#include "cwObject.h"
+
+#include "cwTime.h"
+#include "cwMidiDecls.h"
+#include "cwMidi.h"
+#include "cwFlowDecl.h"
+#include "cwFlow.h"
+#include "cwFlowTest.h"
+
+
+#include "cwFile.h"
+#include "cwFileSys.h"
+
+namespace cw
+{
+  namespace flow
+  {
+    typedef struct exec_test_str
+    {
+      void*                  logCbArg;
+      log::logOutputCbFunc_t logCbFunc;
+      file::handle_t         logFileH;
+    } exec_test_t;
+
+    rc_t _compare_dirs( const char* dir0, const char* dir1 )
+    {
+      rc_t                 rc          = kOkRC;
+      rc_t                 testRC      = kOkRC;
+      unsigned             dirRefN     = 0;
+      filesys::dirEntry_t* dirRefA     = nullptr;
+      char*                testRefDir  = nullptr;
+      unsigned             testRefDirN = 0;
+      filesys::dirEntry_t* testRefDirA = nullptr;
+      unsigned             testCnt     = 0;
+      unsigned             failCnt     = 0;
+
+      // get a list of sub-directories in the ref. directory
+      if((dirRefA = filesys::dirEntries( dir0, filesys::kDirFsFl, &dirRefN )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"An error occurred while attempting to read the list of sub-directories in '%s'.",cwStringNullGuard(dir0));
+        goto errLabel;
+      }
+
+      // for each test
+      for(unsigned i=0; i<dirRefN; ++i)
+        if( dirRefA[i].name != nullptr )
+        {
+          // form the test directory
+          if(( testRefDir = filesys::makeFn( dir0, nullptr, nullptr, dirRefA[i].name, nullptr )) == nullptr )
+          {
+            rc = cwLogError(kOpFailRC,"Test directory formation failed on '%s' and '%s'.",cwStringNullGuard(dir0),cwStringNullGuard(dirRefA[i].name));
+            goto errLabel;
+          }
+
+          // get the list of files in the test directory
+          if((testRefDirA = filesys::dirEntries( testRefDir, filesys::kFileFsFl, &testRefDirN )) == nullptr )
+          {            
+            rc = cwLogError(kOpFailRC,"An error occurred while attempting to read the list of file from '%s'.",cwStringNullGuard(testRefDir));
+            goto errLabel;
+          }
+
+          testCnt += 1;
+
+          // for each file 
+          for(unsigned j=0; rc==kOkRC && j<testRefDirN; ++j)
+            if( testRefDirA[j].name != nullptr )
+            {
+              char* testRefFn = filesys::makeFn( dir0, testRefDirA[j].name, nullptr, dirRefA[i].name, nullptr ); 
+              char* testCmpFn = filesys::makeFn( dir1, testRefDirA[j].name, nullptr, dirRefA[i].name, nullptr );
+              bool  isEqualFl = false;
+
+              // compare two files
+              if((rc = file::compare( testRefFn, testCmpFn, isEqualFl)) != kOkRC )
+                rc = cwLogError(rc,"The comparison failed on '%s' == '%s'.",cwStringNullGuard(testRefFn),cwStringNullGuard(testCmpFn));
+              else
+              {
+                // if the test failed
+                if( !isEqualFl )
+                {
+                  cwLogInfo("Test failed on: '%s'",testRefFn);
+                  failCnt += 1;
+                }
+              }
+              
+              mem::release(testRefFn);
+              mem::release(testCmpFn);              
+            }
+
+          mem::release(testRefDirA);
+          mem::release(testRefDir);
+        }
+
+      mem::release(dirRefA);
+      
+    errLabel:
+
+      mem::release(testRefDirA);
+      mem::release(testRefDir);
+      mem::release(dirRefA);
+
+      cwLogInfo("Tests:%i failed:%i",testCnt,failCnt);
+      
+      return rc;
+
+    }
+    
+    
+    void _exec_test_log_cb( void* cbArg, unsigned level, const char* text )
+    {
+      rc_t rc;
+      exec_test_t* r = (exec_test_t*)cbArg;
+      
+      if((rc = file::print(r->logFileH,text)) != kOkRC )
+        cwLogError(rc,"Log file write failed for '%s'.text");
+      
+      if( r->logCbFunc != nullptr )
+        r->logCbFunc( r->logCbArg,level,text);
+    }
+
+    rc_t _exec_test(  const object_t* class_cfg,
+                      const object_t* subnet_cfg,
+                      const object_t* test_cfg,
+                      const char* proj_base_dir,
+                      const char* test_case_label  )
+    {
+      rc_t            rc        = kOkRC;
+      char*           proj_dir  = nullptr;
+      char*           log_fname = nullptr;
+      exec_test_t     test_recd;
+      handle_t        flowH;
+
+      // save the log to a 
+      test_recd.logCbArg  = log::outputCbArg( log::globalHandle() );
+      test_recd.logCbFunc = log::outputCb(    log::globalHandle() );
+      
+      // form the projectory directory name
+      if((proj_dir = filesys::makeFn(proj_base_dir,nullptr,nullptr,test_case_label,nullptr)) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"The project directory name could not be formed from '%s' and '%s'.",cwStringNullGuard(proj_base_dir),cwStringNullGuard(test_case_label));
+        goto errLabel;
+      }
+
+      // create the project directory
+      if( !filesys::isDir(proj_dir) )
+      {
+        if((rc = filesys::makeDir(proj_dir)) != kOkRC )
+        {
+          rc = cwLogError(kOpFailRC,"The project directory '%s' could not be created.",proj_dir);
+          goto errLabel;
+        }
+      }
+
+      // form the log file name
+      if((log_fname = filesys::makeFn( proj_dir, "log","txt",nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"The log file name could not be formed from the project directory.",cwStringNullGuard(proj_dir));
+        goto errLabel;
+      }
+
+      // open the log file
+      if((rc = file::open(test_recd.logFileH, log_fname,file::kWriteFl)) != kOkRC )
+      {
+        rc = cwLogError(rc,"The log file '%s' could not be created.",cwStringNullGuard(log_fname));
+        goto errLabel;
+      }
+
+      log::setOutputCb( log::globalHandle(), _exec_test_log_cb, &test_recd );
+      
+      // create the flow object
+      if((rc = create( flowH, class_cfg, test_cfg, subnet_cfg, proj_dir)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Flow object create failed.");
+        goto errLabel;
+      }
+
+      // run the network
+      if((rc = exec( flowH )) != kOkRC )
+        rc = cwLogError(rc,"Execution failed.");
+    
+
+      // destroy the flow object
+      if((rc = destroy(flowH)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Close the flow object.");
+        goto errLabel;
+      }
+
+    errLabel:
+
+      file::close(test_recd.logFileH);      
+      log::setOutputCb( log::globalHandle(), test_recd.logCbFunc, test_recd.logCbArg );
+      mem::release(log_fname);
+      mem::release(proj_dir);
+      
+      return rc;
+    }    
+  }
+} 
+
+cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
+{
+  rc_t            rc               = kOkRC;
+  const char*     proc_cfg_fname   = nullptr;
+  const char*     subnet_cfg_fname = nullptr;
+  const object_t* test_cases_cfg   = nullptr;
+  object_t*       class_cfg        = nullptr;
+  object_t*       subnet_cfg       = nullptr;
+  const object_t* test_cfg         = nullptr;
+  const char*     proj_dir         = nullptr;
+  const char*     test_ref_dir     = nullptr;
+  bool            cmp_enable_fl    = false;
+
+  if( argc < 2 || textLength(argv[1]) == 0 )
+  {
+    rc = cwLogError(kInvalidArgRC,"No 'test-case' label was given on the command line.");
+    goto errLabel;
+  }
+  
+  if((rc = cfg->getv("proc_cfg_fname",proc_cfg_fname,
+                     "test_cases",    test_cases_cfg,
+                     "project_dir",   proj_dir)) != kOkRC )
+  {
+    rc = cwLogError(rc,"The name of the flow_proc_dict file could not be parsed.");
+    goto errLabel;
+  }
+
+  // get the subnet cfg filename
+  if((rc = cfg->getv_opt("subnet_cfg_fname",subnet_cfg_fname,
+                         "cmp_enable_fl", cmp_enable_fl,
+                         "test_ref_dir",test_ref_dir)) != kOkRC )
+  {
+    rc = cwLogError(rc,"The name of the subnet file could not be parsed.");
+    goto errLabel;
+  }
+
+  // parse the proc dict. file
+  if((rc = objectFromFile(proc_cfg_fname,class_cfg)) != kOkRC )
+  {
+    rc = cwLogError(rc,"The proc dictionary could not be read from '%s'.",cwStringNullGuard(proc_cfg_fname));
+    goto errLabel;
+  }
+
+  // parse the subnet dict file
+  if((rc = objectFromFile(subnet_cfg_fname,subnet_cfg)) != kOkRC )
+  {
+    rc = cwLogError(rc,"The subnet dictionary could not be read from '%s'.",cwStringNullGuard(subnet_cfg_fname));
+    goto errLabel;
+  }
+
+  // validate the project directory
+  if( proj_dir!=nullptr && !filesys::isDir(proj_dir) )
+  {
+    if((rc = filesys::makeDir(proj_dir)) != kOkRC )
+    {
+      rc = cwLogError(rc,"The project directory '%s' could not be created.",cwStringNullGuard(proj_dir));
+    }
+  }
+
+  // for each test
+  for(unsigned i=0; i<test_cases_cfg->child_count(); ++i)
+  {
+    const object_t* test_cfg_pair       = test_cases_cfg->child_ele(i);
+    const char*     test_label          = nullptr;
+    bool            test_all_fl         = textIsEqual(argv[1],"all");
+    bool            is_test_disabled_fl = false;
+
+    // validate the test cfg pair
+    if(test_cfg_pair == nullptr || !test_cfg_pair->is_pair() || (test_label = test_cfg_pair->pair_label()) == nullptr || (test_cfg=test_cfg_pair->pair_value())==nullptr || !test_cfg->is_dict())
+    {
+      rc = cwLogError(kSyntaxErrorRC,"A syntax error was encountered on the test at index %i (%s).",i,cwStringNullGuard(test_label));
+      goto errLabel;
+    }
+
+    // get the 'disabled flag'
+    if((rc = test_cfg->getv_opt("testDisableFl",is_test_disabled_fl)) != kOkRC )
+    {
+      rc = cwLogError(kSyntaxErrorRC,"An error occurred while parsing the 'testDisableFl'.");
+      goto errLabel;
+    }
+
+    // if this test is disabled
+    if( is_test_disabled_fl )  
+    {
+      if( !test_all_fl )
+      {
+        rc = cwLogError(kInvalidArgRC,"The requested test '%s' is diabled.",test_label);
+        goto errLabel;
+      }
+      continue;
+    }
+
+    // if we are testing all test or this specific test
+    if( test_all_fl || textIsEqual(argv[1],test_label) )
+    {
+      if((rc = _exec_test(class_cfg,subnet_cfg,test_cfg,proj_dir,test_label)) != kOkRC )
+      {
+        rc = cwLogError(kOpFailRC,"Test execution failed on '%s'.",cwStringNullGuard(test_label));
+        goto errLabel;
+      }
+
+      if( !test_all_fl )
+        break;
+    }
+  }
+
+  // if comparision is enabled
+  if( test_ref_dir != nullptr && cmp_enable_fl )
+  {
+    _compare_dirs( test_ref_dir, proj_dir );
+  }
+  
+  
+ errLabel:
+  if( class_cfg != nullptr )
+    class_cfg->free();
+
+  if( subnet_cfg != nullptr )
+    subnet_cfg->free();
+  
+  return rc;
+}
diff --git a/cwFlowTest.h b/cwFlowTest.h
new file mode 100644
index 0000000..51c40bb
--- /dev/null
+++ b/cwFlowTest.h
@@ -0,0 +1,9 @@
+
+namespace cw
+{
+  namespace flow
+  {
+    
+    rc_t test(  const object_t* cfg, int argc, const char* argv[] );
+  }
+}

From e30e6f4b719f7333b88e09f13f646204a93a56d3 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 22:03:08 -0400
Subject: [PATCH 068/101] cwFlowTypes : Added 'flow_t.proj_dir'.  Added
 proc_expand_filename(). Changed network_print() from printf() to
 cwLogPrint().

---
 cwFlowTypes.cpp | 66 +++++++++++++++++++++++++++++--------------------
 cwFlowTypes.h   |  9 +++++--
 2 files changed, 46 insertions(+), 29 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index a85068b..59e6a26 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -5,6 +5,7 @@
 #include "cwMath.h"
 #include "cwText.h"
 #include "cwObject.h"
+#include "cwFileSys.h"
 #include "cwVectOps.h"
 #include "cwMtx.h"
 #include "cwDspTypes.h" // real_t, sample_t
@@ -198,35 +199,35 @@ namespace cw
         case kInvalidTFl:
           break;
           
-        case kBoolTFl:  printf("b:%s ", v->u.b ? "true" : "false" ); break;          
-        case kUIntTFl:  printf("u:%i ", v->u.u ); break;
-        case kIntTFl:   printf("i:%i ", v->u.i ); break;          
-        case kFloatTFl: printf("f:%f ", v->u.f ); break;
-        case kDoubleTFl:printf("d:%f ", v->u.d ); break;
+        case kBoolTFl:  cwLogPrint("b:%s ", v->u.b ? "true" : "false" ); break;          
+        case kUIntTFl:  cwLogPrint("u:%i ", v->u.u ); break;
+        case kIntTFl:   cwLogPrint("i:%i ", v->u.i ); break;          
+        case kFloatTFl: cwLogPrint("f:%f ", v->u.f ); break;
+        case kDoubleTFl:cwLogPrint("d:%f ", v->u.d ); break;
         case kABufTFl:
           if( v->u.abuf == nullptr )
-            printf("abuf: <null>");
+            cwLogPrint("abuf: <null>");
           else
-            printf("abuf: chN:%i frameN:%i srate:%8.1f ", v->u.abuf->chN, v->u.abuf->frameN, v->u.abuf->srate ); 
+            cwLogPrint("abuf: chN:%i frameN:%i srate:%8.1f ", v->u.abuf->chN, v->u.abuf->frameN, v->u.abuf->srate ); 
           break;
           
         case kFBufTFl:
           if( v->u.fbuf == nullptr )
-            printf("fbuf: <null>");
+            cwLogPrint("fbuf: <null>");
           else
           {
-            printf("fbuf: chN:%i srate:%8.1f ", v->u.fbuf->chN, v->u.fbuf->srate );
+            cwLogPrint("fbuf: chN:%i srate:%8.1f ", v->u.fbuf->chN, v->u.fbuf->srate );
             for(unsigned i=0; i<v->u.fbuf->chN; ++i)
-              printf("(binN:%i hopSmpN:%i) ", v->u.fbuf->binN_V[i], v->u.fbuf->hopSmpN_V[i] );
+              cwLogPrint("(binN:%i hopSmpN:%i) ", v->u.fbuf->binN_V[i], v->u.fbuf->hopSmpN_V[i] );
           }
           break;
 
         case kMBufTFl:
           if( v->u.mbuf == nullptr )
-            printf("mbuf: <null>");
+            cwLogPrint("mbuf: <null>");
           else
           {
-            printf("mbuf: cnt: %i", v->u.mbuf->msgN );
+            cwLogPrint("mbuf: cnt: %i", v->u.mbuf->msgN );
           }
           break;
           
@@ -239,7 +240,7 @@ namespace cw
           break;
           
         case kStringTFl:
-          printf("%s ", v->u.s);
+          cwLogPrint("%s ", v->u.s);
           break;
            
         case kTimeTFl:
@@ -725,13 +726,13 @@ namespace cw
     }
 
     void _var_print_addr( const char* title, const variable_t* v )
-    { printf("%s:%s:%i.%s:%i ",title,v->proc->label,v->proc->label_sfx_id,v->label,v->label_sfx_id); }
+    { cwLogPrint("%s:%s:%i.%s:%i ",title,v->proc->label,v->proc->label_sfx_id,v->label,v->label_sfx_id); }
 
     void _var_print( const variable_t* var )
     {
       const char* conn_label  = is_connected_to_source_proc(var) ? "extern" : "      ";
     
-      printf("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
+      cwLogPrint("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
     
       if( var->value == nullptr )
         _value_print( &var->local_value[0] );
@@ -739,15 +740,15 @@ namespace cw
         _value_print( var->value );
 
       if( var->src_var != nullptr )
-        printf(" src:%s:%i.%s:%i",var->src_var->proc->label,var->src_var->proc->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
+        cwLogPrint(" src:%s:%i.%s:%i",var->src_var->proc->label,var->src_var->proc->label_sfx_id,var->src_var->label,var->src_var->label_sfx_id);
 
       if( var->dst_head != nullptr )
       {
         for(variable_t* v = var->dst_head; v!=nullptr; v=v->dst_link)
-          printf(" dst:%s:%i.%s:%i",v->proc->label,v->proc->label_sfx_id,v->label,v->label_sfx_id);
+          cwLogPrint(" dst:%s:%i.%s:%i",v->proc->label,v->proc->label_sfx_id,v->label,v->label_sfx_id);
       }
 
-      printf("\n");    
+      cwLogPrint("\n");    
     }
     
     
@@ -1105,7 +1106,7 @@ namespace cw
     void _class_desc_print( const class_desc_t* cd )
     {
       const var_desc_t*   vd = cd->varDescL;
-      printf("%s\n",cwStringNullGuard(cd->label));
+      cwLogPrint("%s\n",cwStringNullGuard(cd->label));
         
       for(; vd!=nullptr; vd=vd->link)
       {
@@ -1113,7 +1114,7 @@ namespace cw
         const char* srcOptFlStr = vd->flags & kSrcOptVarDescFl ? "srcOpt"   : "      ";
         const char* plyMltFlStr = vd->flags & kMultVarDescFl   ? "mult"     : "    ";
           
-        printf("  %10s 0x%08x %s %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, plyMltFlStr, cwStringNullGuard(vd->docText) );
+        cwLogPrint("  %10s 0x%08x %s %s %s %s\n", cwStringNullGuard(vd->label), vd->type, srcFlStr, srcOptFlStr, plyMltFlStr, cwStringNullGuard(vd->docText) );
       }  
     }
     
@@ -1287,7 +1288,6 @@ cw::flow::mbuf_t* cw::flow::mbuf_duplicate( const mbuf_t* src )
   return mbuf_create(src->msgA,src->msgN);
 }
 
-
 unsigned cw::flow::value_type_label_to_flag( const char* s )
 {
   unsigned flags = labelToId(_typeLabelFlagsA,s,kInvalidTFl);
@@ -1299,8 +1299,6 @@ unsigned cw::flow::value_type_label_to_flag( const char* s )
 
 const char* cw::flow::value_type_flag_to_label( unsigned flag )
 {  return _typeFlagToLabel(flag); }
-  
-
 
 cw::flow::var_desc_t*  cw::flow::var_desc_create( const char* label, const object_t* cfg )
 {
@@ -1426,9 +1424,9 @@ void cw::flow::network_print( const network_t& net )
     // if this proc has an  internal network
     if( proc->internal_net != nullptr )
     {
-      printf("------- Begin Nested Network: %s -------\n",cwStringNullGuard(proc->label));
+      cwLogPrint("------- Begin Nested Network: %s -------\n",cwStringNullGuard(proc->label));
       network_print(*(proc->internal_net));
-      printf("------- End Nested Network: %s -------\n",cwStringNullGuard(proc->label));
+      cwLogPrint("------- End Nested Network: %s -------\n",cwStringNullGuard(proc->label));
     }
         
   }
@@ -1539,7 +1537,7 @@ cw::flow::external_device_t* cw::flow::external_device_find( flow_t* p, const ch
 
 void cw::flow::proc_print( proc_t* proc )
 {
-  printf("%s:%i\n", proc->label,proc->label_sfx_id);
+  cwLogPrint("%s:%i\n", proc->label,proc->label_sfx_id);
   for(variable_t* var = proc->varL; var!=nullptr; var=var->var_link)
     if( var->chIdx == kAnyChIdx )
       for(variable_t* v0 = var; v0!=nullptr; v0=v0->ch_link)
@@ -1558,6 +1556,20 @@ unsigned cw::flow::proc_var_count( proc_t* proc )
   return n;
 }
 
+char* cw::flow::proc_expand_filename( const proc_t* proc, const char* fname )
+{
+  bool useProjDirFl = proc->ctx->proj_dir != nullptr && textLength(fname) > 1 && fname[0] == '$';
+  char* fn0 = nullptr;
+  
+  if( useProjDirFl )
+    fn0 = filesys::makeFn(proc->ctx->proj_dir,fname+1,nullptr,nullptr);
+
+  char* fn1 = filesys::expandPath(useProjDirFl ? fn0 : fname);
+
+  mem::release(fn0);
+  
+  return fn1;
+}  
 
 
 
@@ -1711,7 +1723,7 @@ cw::rc_t cw::flow::var_call_custom_value_func( variable_t* var )
   
   if( var->flags & kLogVarFl )
   {    
-    printf("%10s:%5i", var->proc->label,var->proc->label_sfx_id);
+    cwLogPrint("%10s:%5i", var->proc->label,var->proc->label_sfx_id);
     
     if( var->chIdx == kAnyChIdx )
       _var_print(var);
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 068a256..f992397 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -285,9 +285,10 @@ namespace cw
       class_desc_t*        subnetDescA;          // 
       unsigned             subnetDescN;          //
       
-
       external_device_t*   deviceA;              // deviceA[ deviceN ] external device description array
       unsigned             deviceN;              //
+
+      const char*          proj_dir;             // default input/output directory
       
       network_t net;
 
@@ -327,7 +328,6 @@ namespace cw
     unsigned       value_type_label_to_flag( const char* type_desc );
     const char*    value_type_flag_to_label( unsigned flag );
     
-    
     //------------------------------------------------------------------------------------------------------------------------
     //
     // Class and Variable Description
@@ -376,6 +376,11 @@ namespace cw
     // Count of all var instances on this proc.  This is a count of the length of proc->varL.
     unsigned           proc_var_count( proc_t* proc );
 
+    // If fname has a '$' prefix then the system project directory is prepended to it.
+    // If fname has a '~' then the users home directory is prepended to it.
+    // The returned string must be release with a call to mem::free().
+    char*              proc_expand_filename( const proc_t* proc, const char* fname );
+
     
     //------------------------------------------------------------------------------------------------------------------------
     //

From 4e0a6df98a98016fd21aec54f3f9555e30f1d050 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 22:05:22 -0400
Subject: [PATCH 069/101] cwFlow : create() now takes a 'proj_dir'. test()
 moved to cwFlowTest.

---
 cwFlow.cpp | 84 ++----------------------------------------------------
 cwFlow.h   |  4 +--
 2 files changed, 4 insertions(+), 84 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index f1b2b90..47cf7fa 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -644,7 +644,6 @@ namespace cw
       return rc;
     }
 
-    
   }
 }
 
@@ -667,6 +666,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
                            const object_t*    classCfg,
                            const object_t*    flowCfg,
                            const object_t*    subnetCfg,
+                           const char*        proj_dir,
                            external_device_t* deviceA,
                            unsigned           deviceN )
 {
@@ -710,6 +710,7 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   p->framesPerCycle = kDefaultFramesPerCycle;
   p->sample_rate    = kDefaultSampleRate;
   p->maxCycleCount  = kInvalidCnt;
+  p->proj_dir       = proj_dir;
   
   // parse the optional args
   if((rc = flowCfg->getv_opt("framesPerCycle",      p->framesPerCycle,
@@ -900,87 +901,6 @@ void cw::flow::print_network( handle_t h )
 }
 
 
-cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
-{
-  rc_t rc = kOkRC;
-  handle_t flowH;
-
-  const char*     proc_cfg_fname   = nullptr;
-  const char*     subnet_cfg_fname = nullptr;
-  const object_t* test_cases_cfg   = nullptr;
-  object_t*       class_cfg        = nullptr;
-  object_t*       subnet_cfg       = nullptr;
-  const object_t* test_cfg         = nullptr;
-
-  if( argc < 2 || textLength(argv[1]) == 0 )
-  {
-    rc = cwLogError(kInvalidArgRC,"No 'test-case' label was given on the command line.");
-    goto errLabel;
-  }
-  
-  if((rc = cfg->getv("proc_cfg_fname",proc_cfg_fname,
-                     "test_cases",     test_cases_cfg)) != kOkRC )
-  {
-    rc = cwLogError(rc,"The name of the flow_proc_dict file could not be parsed.");
-    goto errLabel;
-  }
-
-  // get the subnet cfg filename
-  if((rc = cfg->getv_opt("subnet_cfg_fname",subnet_cfg_fname)) != kOkRC )
-  {
-    rc = cwLogError(rc,"The name of the subnet file could not be parsed.");
-    goto errLabel;
-  }
-
-  // find the user requested test case
-  if((test_cfg = test_cases_cfg->find_child(argv[1])) == nullptr )
-  {
-    rc = cwLogError(kInvalidArgRC,"The test case named '%s' was not found.",argv[1]);
-    goto errLabel;
-  }  
-
-  // parse the proc dict. file
-  if((rc = objectFromFile(proc_cfg_fname,class_cfg)) != kOkRC )
-  {
-    rc = cwLogError(rc,"The proc dictionary could not be read from '%s'.",cwStringNullGuard(proc_cfg_fname));
-    goto errLabel;
-  }
-
-  // parse the subnet dict file
-  if((rc = objectFromFile(subnet_cfg_fname,subnet_cfg)) != kOkRC )
-  {
-    rc = cwLogError(rc,"The subnet dictionary could not be read from '%s'.",cwStringNullGuard(subnet_cfg_fname));
-    goto errLabel;
-  }
-  
-  // create the flow object
-  if((rc = create( flowH, class_cfg, test_cfg, subnet_cfg)) != kOkRC )
-  {
-    rc = cwLogError(rc,"Flow object create failed.");
-    goto errLabel;
-  }
-
-  // run the network
-  if((rc = exec( flowH )) != kOkRC )
-    rc = cwLogError(rc,"Execution failed.");
-    
-
-  // destroy the flow object
-  if((rc = destroy(flowH)) != kOkRC )
-  {
-    rc = cwLogError(rc,"Close the flow object.");
-    goto errLabel;
-  }
-  
- errLabel:
-  if( class_cfg != nullptr )
-    class_cfg->free();
-
-  if( subnet_cfg != nullptr )
-    subnet_cfg->free();
-  
-  return rc;
-}
 
 
 
diff --git a/cwFlow.h b/cwFlow.h
index 17fc29b..1105163 100644
--- a/cwFlow.h
+++ b/cwFlow.h
@@ -17,7 +17,8 @@ namespace cw
     rc_t create( handle_t&          hRef,
                  const object_t*    classCfg,
                  const object_t*    networkCfg,
-                 const object_t*    subnetCfg = nullptr,   
+                 const object_t*    subnetCfg = nullptr,
+                 const char*        projDir   = nullptr,
                  external_device_t* deviceA   = nullptr,
                  unsigned           deviceN   = 0);
 
@@ -51,7 +52,6 @@ namespace cw
     void print_class_list( handle_t h );
     void print_network( handle_t h );
 
-    rc_t test( const object_t* cfg, int argc, const char* argv[] );
 
     
     

From a4dc668640022a879e094a3a6a2ea0636ceb10c7 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 22:06:54 -0400
Subject: [PATCH 070/101] cwFlowCross.cpp : Added null 'proj_dir' in call to
 flow::create().

---
 cwFlowCross.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwFlowCross.cpp b/cwFlowCross.cpp
index 330ebed..4589c94 100644
--- a/cwFlowCross.cpp
+++ b/cwFlowCross.cpp
@@ -146,7 +146,7 @@ namespace cw
       net->stateId = net_idx == 0 ? kActiveStateId : kInactiveStateId;
       net->net_idx = net_idx;
       
-      if((rc = flow::create( net->flowH, &classCfg, &networkCfg, nullptr, net->deviceA, deviceN )) == kOkRC )
+      if((rc = flow::create( net->flowH, &classCfg, &networkCfg, nullptr, nullptr, net->deviceA, deviceN )) == kOkRC )
         net->deviceN = deviceN;
       else
       {

From 04e85138c110e0b6057bc4c4fb2bd4a2ce07e844 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 22:07:53 -0400
Subject: [PATCH 071/101] cwFlowProc : 'audio_file_in' and 'audio_file_out' now
 use proc_expand_filename().

---
 cwFlowProc.cpp | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index b5066bc..a93c8f0 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -846,7 +846,7 @@ namespace cw
       {
         audiofile::handle_t afH;
         bool                eofFl;
-        const char*         filename;
+        char*               filename;
       } inst_t;
       
       rc_t create( proc_t* proc )
@@ -854,6 +854,7 @@ namespace cw
         rc_t rc = kOkRC;
         audiofile::info_t info;
         ftime_t seekSecs;
+        const char* fname = nullptr;
         inst_t* inst = mem::allocZ<inst_t>();
         proc->userPtr = inst;
 
@@ -864,13 +865,20 @@ namespace cw
 
         // Register variable and get their current value
         if((rc = var_register_and_get( proc, kAnyChIdx,
-                                       kFnamePId,    "fname",    kBaseSfxId, inst->filename,
+                                       kFnamePId,    "fname",    kBaseSfxId, fname,
                                        kSeekSecsPId, "seekSecs", kBaseSfxId, seekSecs,
                                        kEofFlPId,    "eofFl",    kBaseSfxId, inst->eofFl )) != kOkRC )
         {
           goto errLabel;
         }
 
+        if((inst->filename = proc_expand_filename(proc,fname)) == nullptr )
+        {
+          rc = cwLogError(kInvalidArgRC,"The audio output filename could not be formed.");
+          goto errLabel;
+        }
+        
+
         // open the audio file
         if((rc = audiofile::open(inst->afH,inst->filename,&info)) != kOkRC )
         {
@@ -905,6 +913,7 @@ namespace cw
           rc = cwLogError(kOpFailRC,"The close failed on the audio file '%s'.", cwStringNullGuard(inst->filename) );
         }
 
+        mem::release(inst->filename);
         mem::release(inst);
         
         return rc;
@@ -1000,7 +1009,7 @@ namespace cw
       typedef struct
       {
         audiofile::handle_t afH;
-        const char*         filename;
+        char*               filename;
         unsigned            durSmpN;
       } inst_t;
       
@@ -1010,17 +1019,26 @@ namespace cw
         unsigned      audioFileBits = 0;                     // set audio file sample format to 'float32'.
         inst_t*       inst          = mem::allocZ<inst_t>(); //
         const abuf_t* src_abuf      = nullptr;
+        const char*   fname         = nullptr;
+        
         proc->userPtr = inst;
 
         // Register variables and get their current value
         if((rc = var_register_and_get( proc, kAnyChIdx,
-                                       kFnamePId, "fname", kBaseSfxId, inst->filename,
+                                       kFnamePId, "fname", kBaseSfxId, fname,
                                        kBitsPId,  "bits",  kBaseSfxId, audioFileBits,
                                        kInPId,    "in",    kBaseSfxId, src_abuf )) != kOkRC )
         {
           goto errLabel;
         }
 
+        
+        if((inst->filename = proc_expand_filename(proc,fname)) == nullptr )
+        {
+          rc = cwLogError(kInvalidArgRC,"The audio output filename could not be formed.");
+          goto errLabel;
+        }
+          
         // create the audio file with the same channel count as the incoming signal
         if((rc = audiofile::create( inst->afH, inst->filename, src_abuf->srate, audioFileBits, src_abuf->chN)) != kOkRC )
         {
@@ -1044,6 +1062,7 @@ namespace cw
           goto errLabel;
         }
 
+        mem::release(inst->filename);
         mem::release(inst);
 
       errLabel:

From 20475974b1d7661a1b450ad971ce195288f148e2 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 22:10:39 -0400
Subject: [PATCH 072/101] flow/flow_doc.md : Updates.

---
 flow/flow_doc.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 6c301b3..2dfb03b 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -19,7 +19,7 @@ and audio processing networks and the application of network state data.
 ```
 ```
 
-
+Use `$` prefix to a filename. Use proc_expand_filename() to prepend `proj_dir` to a file prefixed with `$`.
 
 ### Polyphonic Network.
 

From db73373cc033e3e762313cbbd98e53f6c6bff66d Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 9 May 2024 22:10:51 -0400
Subject: [PATCH 073/101] README.md : Updates

---
 README.md | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 72 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index dbecb11..c200725 100644
--- a/README.md
+++ b/README.md
@@ -723,7 +723,7 @@ given then the first sfx-id defaults to 0.
 	  as in (1) above.
 
 
-	+ If `sec-int` is given
+	+ If `sec-int` is not given
 	  then the `sec-int` defaults to the count of
 	  available source vars with the given `label` 
 	  following the source var `pri-int`.
@@ -757,6 +757,72 @@ more than one literal iter counts are given.
 	+ connect multiple inputs to multiple vars on one proc
 	+ connect multiple inputs to one var on one proc
 
+
+### in-stmt Examples:
+
+`in:sproc.svar`   Connect the local variable `in` to the source variable `sproc.svar`.
+
+`in0:sproc.svar`  Create variables `in0` and connect to `sproc.svar`.
+
+`in_2:sproc.svar` Create variables `in0` and `in1` and connect both new variables to `sproc.svar`.
+
+`in_:sproc.svar0_2` Create variables `in0` and `in1` and connect them to `sproc.svar0` and `sproc.svar1`.
+
+`in3_3:sproc.svar` Create variables `in3`,`in4` and `in5` and connect them all to `sproc.svar`.
+
+`in_:sproc.svar1_2` Create variables `in0`,`in1` and connect them to `sproc.svar1` and `sproc.svar2`.
+
+`in1_2:sproc.svar3_` Create variables `in1`,`in2` and connect them to `sproc.svar3` and `sproc.svar4`.
+
+`in_:sproc.svar_` Create vars `in0 ... n-1` where `n` is count of vars on `sproc` with the label `svar`.
+`n` is called the 'mult-count' of `svar`.  The new variables `in0 ... n-1` are also connected to `sproc.svar0 ... n-1`.
+
+`in_:sproc_.svar` Create vars `in0 ... n` where `n` is determineed by the count of procs named `sproc`.
+`n` is called the 'poly-count' of `sproc`. The new variables `in0 ... n-1` are also connected to `sproc.svar0 ... n-1`
+
+If an underscore precedes the in-var then this implies that the connection is being
+made from a poly context. 
+
+`foo : { ... in:{ _.in:sproc.svar_ } ... } ` This example shows an excerpt from the network 
+definition of proc `foo` which is assumed to be a poly proc (there are multiple procs named 'foo' in this network).
+This connection iterates across the procs  `foo:0 ... foo:n-1` connecting the 
+the local variable 'in' to `sproc.svar0 ... n-1`. Where `n` is the poly count of `foo`.
+
+`foo : { ... in:{ 1_3.in:sproc.svar_ } ... }` Connect `foo:1-in:0` to `sproc:svar0` and `foo:2-in:0` to `sproc:svar1`.
+
+`foo : { ... in:{ 1_3.in:sproc_.svar } ... }` Connect `foo:1-in:0` to `sproc0:svar0` and `foo:2-in:0` to `sproc1:svar`.
+
+#### in-stmt Anti-Examples
+
+`in_:sproc_.svar_` This is illegal because there is no way to determine how many `in` variables should be created.
+
+`in:sproc.svar_` This is illegal because it suggests that multiple sources should be connected to a single input variable.
+
+`in:sproc_.svar` This is illegal because it suggests that multiple sources should be connected to a single input variable.
+
+`_.in_:sproc.svar` This is illegal because it suggests simultaneously iterating across both the local proc and var.
+This would be possible if there was a way to separate how the two separate iterations should be distributed 
+to the source. To make this legal would require an additional special character to show how to apply the poly
+iteration and/or var iteration to the source. (e.g. `_.in_:sproc*.svar_`) 
+
+### out-stmt Examples:
+
+`out:iproc.ivar` Connect the local source variable `out` to the input variable `iproc:ivar`.
+
+`out:iproc.ivar_` Connect the local source variable `out` to the input variables `iproc:ivar0` and `iproc:ivar1`.
+
+`out_:iproc.ivar_` Connect the local souce variables `out0 ... out n-1` to the input variables `iproc:ivar0 ... iproc:ivar n-1`
+where `n` is the mult count of the `out`.
+
+`out_:iproc_.ivar` Connect the local souce variables `out0 ... out n-1` to the input variables `iproc0:ivar ... iproc n-1:ivar`
+where `n` is the mult count of the `out`.
+
+
+`_.out:iproc.ivar_` Connect the local source variables `foo0:out`, `foo n-1:out` to the input variables `iproc:ivar0`, `iproc:ivar n-1`.
+where `n` is the poly count of `foo`.
+
+
+
 Var Updates and Preset Application
 ==================================
 
@@ -950,6 +1016,7 @@ Next:
 - Audio inputs should be able to be initialized with a channel count and srate without actually connecting an input.
   This will allow feedback connections to be attached to them at a later stage of the network 
   instantiation.
+- Remove the multiple 'args' thing and and 'argsLabe'.  'args' should be a simple set of arg's.  
 - Implement subnet preset application.	
 - Implement the var attributes and attribute checking.
 - Implement dynamic loading of procs.
@@ -962,6 +1029,10 @@ Next:
   later proc's then they will not have all of their inputs when they are instantiated.
   One way around this is to instantiate them with an initial set of inputs but then
   allow those inputs to be replaced by a later connection.
+- Look more closely at the way of identify an in-stmt src-net or a out-stmt in-net.
+It's not clear there is a difference between specifying  `_` and the default behaviour.
+Is there a way to tell it to search the entire network from the root? Isn't that 
+what '_' is supposed to do.
   
 
 BUGS:

From af9d9bdc572945290f4d91dc04b03ca13e118e5c Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 10 May 2024 15:52:37 -0400
Subject: [PATCH 074/101] cwFlowTypes : Added var_disconnect()

---
 cwFlowTypes.cpp | 49 +++++++++++++++++++++++++++++++------------------
 cwFlowTypes.h   | 18 +++++++++++-------
 2 files changed, 42 insertions(+), 25 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 59e6a26..8597ac7 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -730,7 +730,7 @@ namespace cw
 
     void _var_print( const variable_t* var )
     {
-      const char* conn_label  = is_connected_to_source_proc(var) ? "extern" : "      ";
+      const char* conn_label  = is_connected_to_source(var) ? "extern" : "      ";
     
       cwLogPrint("  %20s:%5i id:%4i ch:%3i : %s  : ", var->label, var->label_sfx_id, var->vid, var->chIdx, conn_label );
     
@@ -880,7 +880,7 @@ namespace cw
       rc_t rc;
 
       // if this variable is fed from the output of an external proc - then it's local value cannot be set
-      if(is_connected_to_source_proc(var)   )
+      if(is_connected_to_source(var)   )
       {
         return cwLogError(kInvalidStateRC,"Cannot set the value on the connected variable %s:%i-%s:%i.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id);
       }
@@ -1483,7 +1483,7 @@ cw::rc_t cw::flow::proc_validate( proc_t* proc )
     }
 
     // if var is using a local value (not connected to a source variable) then the type of the value must be valid with the variable class
-    if( !is_connected_to_source_proc(var) && !(var->varDesc->type & var->value->tflag) )
+    if( !is_connected_to_source(var) && !(var->varDesc->type & var->value->tflag) )
     {
       rc = cwLogError(kInvalidStateRC, "The value type flag '%s' (0x%x) of '%s:%i-%s:%i' is not found in the variable class type flags: '%s' (0x%x)",
                       _typeFlagToLabel(var->value->tflag),var->value->tflag,
@@ -1633,7 +1633,7 @@ cw::rc_t  cw::flow::var_channelize( proc_t* proc, const char* var_label, unsigne
     if( value_cfg == nullptr )
     {
       // if the base-var is connected to a source ...
-      if( is_connected_to_source_proc(base_var) )
+      if( is_connected_to_source(base_var) )
       {
         // ... then connect the new var to a source also
         
@@ -1860,8 +1860,6 @@ cw::rc_t cw::flow::var_find( proc_t* proc, unsigned vid, unsigned chIdx, variabl
   return rc;
 }
 
-
-
 cw::rc_t cw::flow::var_find( proc_t* proc, const char* label, unsigned sfx_id, unsigned chIdx, variable_t*& vRef )
 {
   variable_t* var;
@@ -1956,7 +1954,7 @@ cw::rc_t cw::flow::var_register( proc_t* proc, const char* var_label, unsigned s
   return rc;
 }
 
-bool cw::flow::is_connected_to_source_proc( const variable_t* var )
+bool cw::flow::is_connected_to_source( const variable_t* var )
 {
   // if this var does not have a 'src_ptr' then it can't be connected to an external proc
   if( var->src_var == nullptr || var->value == nullptr )
@@ -1987,20 +1985,35 @@ void cw::flow::var_connect( variable_t* src_var, variable_t* in_var )
   src_var->dst_tail = in_var;
   
   in_var->value    = src_var->value;
-  in_var->src_var = src_var;
+  in_var->src_var = src_var;  
+}
 
-  //printf("Connect: ");
-  //_var_print_addr("src",src_var);
-  //_var_print_addr("dst",in_var);
-  //_var_print_addr("HEAD",src_var->dst_head);
+void cw::flow::var_disconnect( variable_t* in_var )
+{
+  if( in_var->src_var != nullptr )
+  {
+    // remote the in_var from the src var's output list
+    variable_t* v0 = nullptr;
+    variable_t* v = in_var->src_var->dst_head;
+    for(; v!=nullptr; v=v->dst_link)
+    {
+      if( v == in_var )
+      {
+        if( v0 == nullptr )
+          in_var->src_var->dst_head = v->dst_link;
+        else
+          v0->dst_link = v->dst_link;
+        break;
+      }
 
-  //if( src_var->dst_head->dst_link != nullptr )
-  //  _var_print_addr("LINK",src_var->dst_head->dst_link);
-  
-  //_var_print_addr("TAIL",src_var->dst_tail);
-  //printf("\n");
+      v0 = v;
+    }
+    
+    // the in_var is always in the src-var's output list
+    assert(v == in_var );
 
-  
+    in_var->src_var = nullptr;
+  }
 }
 
 unsigned  cw::flow::var_mult_count( proc_t* proc, const char* var_label )
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index f992397..9b79bd2 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -173,11 +173,11 @@ namespace cw
     
     typedef struct class_desc_str
     {
-      const object_t*   cfg;       // class cfg 
-      const char*       label;     // class label;      
-      var_desc_t*       varDescL;  // varDescL variable description linked on var_desc_t.link
-      preset_t*         presetL;   // presetA[ presetN ]
-      class_members_t*  members;   // member functions for this class
+      const object_t*   cfg;        // class cfg 
+      const char*       label;      // class label;      
+      var_desc_t*       varDescL;   // varDescL variable description linked on var_desc_t.link
+      preset_t*         presetL;    // presetA[ presetN ]
+      class_members_t*  members;    // member functions for this class
       unsigned          polyLimitN; // max. poly copies of this class per network_t or 0 if no limit
     } class_desc_t;
 
@@ -409,8 +409,8 @@ namespace cw
     // `value_cfg` is optional. Set it to NULL to ignore
     rc_t           var_register( proc_t* proc, const char* var_label, unsigned sfx_id, unsigned vid, unsigned chIdx, const object_t* value_cfg, variable_t*& varRef );
 
-    // Returns true if this var is connected to an source proc variable
-    bool           is_connected_to_source_proc( const variable_t* var );
+    // Returns true if this var is connected to a source proc variable
+    bool           is_connected_to_source( const variable_t* var );
 
     // Return true if this var is acting as a source for another var.
     bool           is_a_source_var( const variable_t* var );
@@ -418,6 +418,10 @@ namespace cw
     // Connect in_var to src_var. 
     void           var_connect( variable_t* src_var, variable_t* in_var );
 
+    // Disconnect an in_var from it's source
+    void           var_disconnect( variable_t* in_var );
+
+
     // Get the count of 'mult' vars associated with this var label.
     unsigned       var_mult_count( proc_t* proc, const char* var_label );
     

From bcb2fdfcad2d9a6754d28ed81c0465caf5faa9ab Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 10 May 2024 15:53:07 -0400
Subject: [PATCH 075/101] cwFlowProc.cpp : Added 'store' variable to number
 proc.

---
 cwFlowProc.cpp | 85 +++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 80 insertions(+), 5 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index a93c8f0..8c53fbc 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -4071,6 +4071,80 @@ namespace cw
     {
       enum {
         kValuePId,
+        kStorePId,
+      };
+
+      typedef struct
+      {
+        bool store_fl;
+      } inst_t;
+
+      rc_t _create( proc_t* proc, inst_t* p )
+      {
+        rc_t rc = kOkRC;
+        
+        if((rc = var_register(proc,kAnyChIdx,
+                              kValuePId,"value",kBaseSfxId,
+                              kStorePId,"store",kBaseSfxId)) != kOkRC )
+        {
+          goto errLabel;
+        }
+        
+      errLabel:
+        return rc;
+      }
+
+      rc_t _destroy( proc_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
+      {
+        // skip the 'stored' value sent through prior to runtime.
+        if( var->vid == kStorePId && proc->ctx->isInRuntimeFl)
+          p->store_fl = true;
+        
+        return kOkRC;
+      }
+
+      rc_t _exec( proc_t* proc, inst_t* p )
+      {
+        rc_t rc = kOkRC;
+
+        if( p->store_fl )
+        {
+          variable_t*  var = nullptr;
+          // Set 'value' from 'store'.
+          // Note that we set the 'value' directly from var->value so that
+          // no extra type converersion is applied. In this case the value
+          // 'store'  will be coerced to the type of 'value'
+          if((rc = var_find(proc, kStorePId, kAnyChIdx, var )) == kOkRC && var->value != nullptr )
+            rc = var_set(proc,kValuePId,kAnyChIdx,var->value);
+
+          p->store_fl = false;
+        }
+        
+        return rc;
+      }
+
+      rc_t _report( proc_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      class_members_t members = {
+        .create  = std_create<inst_t>,
+        .destroy = std_destroy<inst_t>,
+        .value   = std_value<inst_t>,
+        .exec    = std_exec<inst_t>,
+        .report  = std_report<inst_t>
+      };
+      
+    }    
+
+    /*
+    namespace number
+    {
+      enum {
+        kValuePId,
+        kStorePId,
       };
       
 
@@ -4078,10 +4152,10 @@ namespace cw
       rc_t create( proc_t* proc )
       {
         rc_t        rc    = kOkRC;        
-        double      value = 0;
-
-        if((rc  = var_register_and_get(proc,kAnyChIdx,
-                                       kValuePId,"value",kBaseSfxId,value)) != kOkRC )
+        
+        if((rc  = var_register(proc,kAnyChIdx,
+                               kValuePId,"value",kBaseSfxId,
+                               kStorePId,"store",kBaseSfxId)) != kOkRC )
         {
           goto errLabel;
         }
@@ -4117,7 +4191,8 @@ namespace cw
       };
       
     }    
-
+    */
+    
     //------------------------------------------------------------------------------------------------------------------
     //
     // Timer

From 05abad17fa666a9d79797bc545289555d3d22184 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 10 May 2024 15:53:29 -0400
Subject: [PATCH 076/101] cwFlowTest.cpp : Fixed typo.

---
 cwFlowTest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwFlowTest.cpp b/cwFlowTest.cpp
index 2060a09..1e0dcaa 100644
--- a/cwFlowTest.cpp
+++ b/cwFlowTest.cpp
@@ -289,7 +289,7 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     {
       if( !test_all_fl )
       {
-        rc = cwLogError(kInvalidArgRC,"The requested test '%s' is diabled.",test_label);
+        rc = cwLogError(kInvalidArgRC,"The requested test '%s' is disabled.",test_label);
         goto errLabel;
       }
       continue;

From e806115a4a3035526d3ce25e618375118b936182 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 10 May 2024 15:54:21 -0400
Subject: [PATCH 077/101] cwFlowNet.cpp : Initial implementation the 'out'
 statement. Combined implementation of 'in' statement and 'out' statement
 processing.

---
 cwFlowNet.cpp | 3100 ++++++++++++++++++++++++++-----------------------
 1 file changed, 1647 insertions(+), 1453 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index d6809f2..4eb3a47 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -37,158 +37,6 @@ namespace cw
       return rc;
     }
 
-    rc_t  _var_map_id_to_index(  proc_t* proc, unsigned vid, unsigned chIdx, unsigned& idxRef );
-
-    rc_t _create_proc_var_map( proc_t* proc )
-    {
-      rc_t        rc        = kOkRC;
-      unsigned    max_vid   = kInvalidId;
-      unsigned    max_chIdx = 0;
-      variable_t* var       = proc->varL;
-      //variable_t* v0        = nullptr;
-      
-      // determine the max variable vid and max channel index value among all variables
-      for(; var!=nullptr; var = var->var_link )
-      {
-        if( var->vid != kInvalidId )
-        {
-          if( max_vid == kInvalidId || var->vid > max_vid )
-            max_vid = var->vid;
-
-          if( var->chIdx != kAnyChIdx && (var->chIdx+1) > max_chIdx )
-            max_chIdx = (var->chIdx + 1);
-
-        }
-      }
-
-      // If there are any variables
-      if( max_vid != kInvalidId )
-      {
-        // create the variable map array
-        proc->varMapChN = max_chIdx + 1;
-        proc->varMapIdN = max_vid + 1;
-        proc->varMapN   = proc->varMapIdN * proc->varMapChN;
-        proc->varMapA   = mem::allocZ<variable_t*>( proc->varMapN );
-
-        // assign each variable to a location in the map
-        for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
-          if( var->vid != kInvalidId )
-          {
-            unsigned idx = kInvalidIdx;
-
-            if((rc = _var_map_id_to_index( proc, var->vid, var->chIdx, idx )) != kOkRC )
-              goto errLabel;
-
-          
-            // verify that there are not multiple variables per map position          
-            if( proc->varMapA[ idx ] != nullptr )
-            {
-              variable_t* v0 = proc->varMapA[idx];
-              rc = cwLogError(kInvalidStateRC,"The variable '%s' id:%i ch:%i and '%s' id:%i ch:%i share the same variable map position on proc instance: %s. This is usually cased by duplicate variable id's.",
-                              v0->label,v0->vid,v0->chIdx, var->label,var->vid,var->chIdx,proc->label);
-
-              goto errLabel;
-            }
-
-            // assign this variable to a map position
-            proc->varMapA[ idx ] = var;
-
-            if( var->chIdx != kAnyChIdx && var->value == nullptr )
-            {
-              rc = cwLogError(kInvalidStateRC,"The value of the variable '%s' ch:%i on proc instance:'%s' has not been set.",var->label,var->chIdx,proc->label);
-              goto errLabel;
-            }
-
-          }
-        
-      }
-
-    errLabel:
-      return rc;
-      
-    }
-
-    /*
-    void _complete_input_connections( proc_t* proc )
-    {
-      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
-        if(var->chIdx == kAnyChIdx && is_connected_to_source_proc(var) )
-        {
-
-          variable_t* base_src_var = var->src_var;
-
-          // since 'var' is on the 'any' channel the 'src' var must also be on the 'any' channel
-          assert( base_src_var->chIdx == kAnyChIdx );
-          
-          //printf("%s %s\n",proc->label,var->label);
-          
-          // for each var channel in the input var
-          for(variable_t* in_var = var->ch_link; in_var != nullptr; in_var=in_var->ch_link)
-          {
-            // locate the matching channel on the 'src' var
-            variable_t* svar = base_src_var;
-            for(; svar!=nullptr; svar=svar->ch_link)
-              if( svar->chIdx == in_var->chIdx )
-                break;
-
-            // connect the src->input var
-            _connect_vars( svar==nullptr ? base_src_var : svar, in_var);
-          }
-        }
-    }
-    */
-    
-    rc_t _set_log_flags(proc_t* proc, const object_t* log_labels)
-    {
-      rc_t rc = kOkRC;
-      
-      if( log_labels == nullptr )
-        return rc;
-
-      if( !log_labels->is_dict() )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The log spec on '%s:%i' is not a dictionary.",cwStringNullGuard(proc->label),proc->label_sfx_id);
-        goto errLabel;
-      }
-
-      for(unsigned i=0; i<log_labels->child_count(); ++i)
-      {
-        const object_t* pair;
-        unsigned sfx_id;
-        
-        if((pair = log_labels->child_ele(i)) == nullptr || pair->pair_label()==nullptr || pair->pair_value()==nullptr || (rc=pair->pair_value()->value(sfx_id))!=kOkRC )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"Syntax error on log var identifier.");
-          goto errLabel;
-        }
-
-        if((rc = var_set_flags( proc, kAnyChIdx, pair->pair_label(), sfx_id, kLogVarFl )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to set var flags on '%s:%i' var:'%s:%i'.",cwStringNullGuard(proc->label),proc->label_sfx_id,pair->pair_label(),sfx_id);
-          goto errLabel;          
-        }
-      }
-
-    errLabel:
-      return rc;
-    }
-
-    rc_t _call_value_func_on_all_variables( proc_t* proc )
-    {
-      rc_t rc  = kOkRC;
-      rc_t rc1 = kOkRC;
-      
-      for(unsigned i=0; i<proc->varMapN; ++i)
-        if( proc->varMapA[i] != nullptr && proc->varMapA[i]->vid != kInvalidId )
-        {
-          variable_t* var = proc->varMapA[i];
-
-          if((rc = var_call_custom_value_func( var )) != kOkRC )
-            rc1 = cwLogError(rc,"The proc inst instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->proc->label, var->proc->label_sfx_id, var->label, var->chIdx );
-        }
-      
-      return rc1;
-    }
 
     rc_t _var_channelize( proc_t* proc, const char* preset_label,  const char* type_src_label, const char* var_label, const object_t* value )
     {
@@ -662,1306 +510,6 @@ namespace cw
       return rc;
     }
                                
-                                 
-    
-
-    rc_t _proc_inst_args_channelize_vars( proc_t* proc, const char* arg_label, const object_t* arg_cfg )
-    {
-      rc_t rc = kOkRC;
-      
-      if( arg_cfg == nullptr )
-        return rc;
-
-      return _preset_channelize_vars( proc, "proc instance", arg_label, arg_cfg );
-      
-    }
-
-
-    //=======================================================================================================
-    //
-    // network creation
-    //
-    
-    enum {
-      kInProcTypeId  = 0x01,
-      kInVarTypeId   = 0x02,
-      kSrcProcTypeId = 0x04,
-      kSrcVarTypeId  = 0x08
-    };
-    
-    typedef struct in_ele_str
-    {
-      unsigned typeId;          // See k???_InFl above
-      char*    label;           // label of in or src id
-      unsigned base_sfx_id;     // literal base_sfx_id or kInvalidId if the base_sfx_id was not given or 'is_iter_fl' is false
-      unsigned sfx_id_count;    // literal sfx_id_count or kInvalidCnt if not given
-      unsigned is_iter_fl;      // this id included an '_'
-    } in_ele_t;
-    
-    typedef struct in_stmt_str
-    {
-      in_ele_t    in_proc_ele;      // in-proc element
-      in_ele_t    in_var_ele;       // in-var element
-      char*       src_net_label;    // src-net label  (null=in-var net, '_'=root net, string=named net)
-      network_t*  src_net;          // network containing the src-proc
-      in_ele_t    src_proc_ele;     // src-proc element
-      in_ele_t    src_var_ele;      // src-var element
-      var_desc_t* in_var_desc;      // Pointer to the in-var var_desc.
-      bool        in_proc_iter_fl;  // Is the 'in' proc iterating (this is a poly iteration rather than a var iterator)
-      bool        create_in_fl;     // True if the in_var needs to be created with an sfx_id, false create the var by the default process (w/o sfx_id)
-      in_ele_t*   iter_cnt_ctl_ele; // Pointer to the ele which is controlling the iteration count (or null if in-var is non-iterating)
-      unsigned    iter_cnt;         // Count of iterations or 0 if in-var is non-iterating.
-    } in_stmt_t;
-
-    typedef struct proc_inst_parse_statestr
-    {
-      char*           proc_label;       //
-      unsigned        proc_label_sfx_id;//
-      const char*     proc_clas_label;  //
-      const char*     arg_label;        //
-      const object_t* preset_labels;    //
-      const object_t* arg_cfg;          //
-      const object_t* log_labels;       // 
-      const object_t* in_dict;          // cfg. node to the in-list
-      in_stmt_t*      in_array;         // in_array[ in_arrayN ] in-stmt array
-      unsigned        in_arrayN;        // count of in-stmt's in the in-list.
-    } proc_inst_parse_state_t;
-
-    bool _is_non_null_pair( const object_t* cfg )
-    { return cfg != nullptr && cfg->is_pair() && cfg->pair_label()!=nullptr && cfg->pair_value()!=nullptr; }
-
-    unsigned _digit_suffix_char_count( const char* s )
-    {
-      unsigned digitN = 0;
-      unsigned sn = textLength(s);
-      if( sn==0 )
-        return 0;
-      
-      const char* s0 = s + (textLength(s)-1);
-      
-      // go backward from the last char until the begin-of-string or a non-digit is found
-      for(; s0>=s; --s0)
-      {
-        if(!isdigit(*s0) )
-          break;
-        ++digitN;
-      }
-
-      return digitN;      
-    }
-    
-    rc_t _parse_in_ele( const char* id_str, in_ele_t& r, bool inProcFl=false  )
-    {
-      rc_t rc = kOkRC;
-      unsigned bufN;
-
-      r.base_sfx_id  = kInvalidId;
-      r.sfx_id_count = kInvalidCnt;
-      
-      if((bufN = textLength(id_str)) == 0 )
-      {
-        if( !inProcFl )         
-          rc = cwLogError(kSyntaxErrorRC,"A blank connection id string was encountered.");
-        goto errLabel;
-      }
-      else
-      {
-        char* underscore = nullptr;
-        char* digit      = nullptr;
-        int   offs       = inProcFl ? 1 : 0; 
-        char  buf[ bufN+(1+offs) ];
-
-        // in-proc's don't have a leading label - add one here to please the parser
-        if(inProcFl)
-          buf[0] = 'x';
-
-        // copy the id string into a non-const scratch buffer 
-        textCopy(buf+offs,bufN+1,id_str);
-
-        // locate the last underscore
-        if((underscore = lastMatchChar(buf,'_')) != nullptr )
-        {
-          *underscore  = 0;   // terminate the string prior to the underscore
-          
-          for(digit  = underscore + 1; *digit; digit++)
-            if( !isdigit(*digit) )
-              break;
-
-          // if the underscore was followed by a number
-          // or if the underscore was the last char
-          // in the string - then digit will point to
-          // the terminating zero - otherwise the
-          // underscore did not indicate an iterating id
-          if( *digit != 0 )
-          {
-            *underscore = '_';  // replace the underscore - its part of the label
-            underscore = nullptr;
-          }
-          else
-          {
-            r.is_iter_fl = true;
-
-            // if there is a number following the underscore then this is the secInt
-            if( textLength(underscore + 1) )
-            {
-              // a literal iteration count was given - parse it into an integer
-              if((rc = string_to_number(underscore + 1,r.sfx_id_count)) != kOkRC )
-              {
-                rc = cwLogError(rc,"Unable to parse the secondary integer in the connection label '%s'.",cwStringNullGuard(id_str));
-                goto errLabel;
-              }
-            }              
-          }
-        }
-
-        // verify that some content remains in the id string
-        if( textLength(buf) == 0 )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"Unable to parse the connection id string '%s'.",cwStringNullGuard(id_str));
-          goto errLabel;
-        }
-
-        // go backward from the last char until the begin-of-string or a non-digit is found
-        for(digit=buf + textLength(buf)-1; digit>buf; --digit)
-          if(!isdigit(*digit) )
-          {
-            ++digit; // advance to the first digit in the number
-            break;
-          }
-
-        // if a digit was found then this is the 'priInt'
-        if( digit>buf && textLength(digit) )
-        {
-          assert( buf <= digit-1 && digit-1 <= buf + bufN );
-          
-          // a literal base-sfx-id was given - parse it into an integer
-          if((rc = string_to_number(digit,r.base_sfx_id)) != kOkRC )
-          {
-            rc = cwLogError(rc,"Unable to parse the primary integer in the connection label '%s'.",cwStringNullGuard(id_str));
-            goto errLabel;            
-          }
-
-          *digit = 0; // zero terminate the label
-
-        }
-
-        // verify that some content remains in the id string
-        if( textLength(buf) == 0 )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"Unexpected invalid connection id string '%s'.",cwStringNullGuard(id_str));
-          goto errLabel;
-
-        }
-        else
-        {
-          // store the label
-          if( !inProcFl )
-            r.label = mem::duplStr(buf);
-        }
-      }
-      
-
-    errLabel:
-      return rc;
-    }
-
-    rc_t _calc_src_proc_ele_count(network_t& net, in_ele_t& src_proc_ele, unsigned& cnt_ref)
-    {
-      rc_t rc = kOkRC;
-      cnt_ref = 0;
-      
-      // if a literal proc sfx_id was given then use it otherwise use the default base-sfx-id (0)
-      unsigned sfx_id = src_proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_proc_ele.base_sfx_id;
-      unsigned n;
-      for(n=0; proc_find(net, src_proc_ele.label, sfx_id ) != nullptr; ++n )
-        sfx_id += 1;
-
-      if( n == 0 )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The src-proc '%s:%i' was not found.",cwStringNullGuard(src_proc_ele.label),sfx_id);
-        goto errLabel;        
-      }
-
-      cnt_ref = n;
-    errLabel:
-      return rc;
-    }
-    
-    rc_t _calc_src_var_ele_count(network_t& net, const in_ele_t& src_proc_ele, const in_ele_t& src_var_ele, unsigned& cnt_ref)
-    {
-      rc_t              rc          = kOkRC;
-      proc_t*       src_proc    = nullptr;
-      unsigned          proc_sfx_id = src_proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_proc_ele.base_sfx_id;
-
-      cnt_ref = 0;
-
-      // locate the parent proc of this var
-      if((src_proc = proc_find(net,src_proc_ele.label,proc_sfx_id)) == nullptr )
-      {
-        cwLogError(kSyntaxErrorRC,"The src-proc inst instance '%s:%i' could not be found.",cwStringNullGuard(src_proc_ele.label),proc_sfx_id);
-        goto errLabel;
-      }
-      else
-      {
-        // if a starting var sfx_id was given by the id then use it otherwise use the default base-sfx-id (0)
-        unsigned sfx_id = src_var_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : src_var_ele.base_sfx_id;
-        unsigned n;
-        for(n=0; var_exists(src_proc,src_var_ele.label, sfx_id, kAnyChIdx ); ++n )
-          sfx_id += 1;
-
-
-        if( n == 0 )
-        {
-          cwLogError(kSyntaxErrorRC,"The src-var '%s:%i' was not found.",cwStringNullGuard(src_var_ele.label),sfx_id);
-          goto errLabel;
-        }
-
-        cnt_ref = n;
-
-      }
-
-    errLabel:
-      return rc;
-    }
-
-    // If the in-var is iterating then the count of iterations must be controlled by exactly one
-    // of the 3 parts of the in-stmt: in-var,src_proc, or src_var.  This function determines
-    // which element is used to determine the iteration count.
-    rc_t _determine_in_stmt_iter_count_ctl_ele(network_t& net, proc_t* proc, in_stmt_t& in_stmt )
-    {
-      assert( in_stmt.in_var_ele.is_iter_fl );
-      rc_t rc = kOkRC;
-
-      in_ele_t* iter_cnt_ctl_ele = nullptr;
-
-      // if the in-var gives a literal count - then it determines the count
-      if( in_stmt.in_var_ele.sfx_id_count != kInvalidCnt )
-      {
-        // if the in-var gives a literal count then the src-proc cannot give one
-        if( in_stmt.src_proc_ele.sfx_id_count != kInvalidCnt )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"The in-var provided a literal iteration count therefore the src-proc cannot.");
-          goto errLabel;
-        }
-          
-        // if the in-var gives a literal count then the src-var cannot give one
-        if( in_stmt.src_var_ele.sfx_id_count != kInvalidCnt )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"The in-var provided a literal iteration count therefore the src-var cannot.");
-          goto errLabel;
-        }
-
-        iter_cnt_ctl_ele = &in_stmt.in_var_ele;
-          
-      }
-      else // the src-proc or src-var must control the iter count
-      {
-        // if the src-proc gives a literal count - then it determines th count
-        if( in_stmt.src_proc_ele.sfx_id_count != kInvalidCnt )
-        {
-          // then the src-var cannot give a literal count
-          if( in_stmt.src_var_ele.sfx_id_count != kInvalidCnt )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The src-proc provided a literal iteration count therefore the src-var cannot.");
-            goto errLabel;
-          }
-
-          iter_cnt_ctl_ele = &in_stmt.src_proc_ele;
-            
-        }
-        else
-        {
-          // if the src-var gives a literal count - then it determines the count
-          if( in_stmt.src_var_ele.sfx_id_count != kInvalidCnt )
-          {
-            iter_cnt_ctl_ele = &in_stmt.src_var_ele;
-          }
-          else // no literal count was given - we need to get the implied count
-          {
-            // if the src-proc is iterating then it will provide the count
-            if( in_stmt.src_proc_ele.is_iter_fl )
-            {
-              // the src-var cannot be iterating if the src-proc is iterating
-              if( in_stmt.src_var_ele.is_iter_fl )
-              {
-                rc = cwLogError(kSyntaxErrorRC,"The src-proc is iterating therefore the src-var cannot.");
-                goto errLabel;
-              }
-                
-              iter_cnt_ctl_ele = &in_stmt.src_proc_ele;
-            }
-            else // the src-proc isn't iterating check the src-var
-            {
-              if( in_stmt.src_var_ele.is_iter_fl )
-              {
-                iter_cnt_ctl_ele = &in_stmt.src_var_ele;
-              }
-              else // no iteration count control was found
-              {
-                rc = cwLogError(kSyntaxErrorRC,"No iteration count control was specified.");
-                goto errLabel;                  
-              }
-            }
-          }
-        }
-      }               
-      
-    errLabel:
-      
-      if( rc == kOkRC )
-        in_stmt.iter_cnt_ctl_ele = iter_cnt_ctl_ele;
-      
-      return rc;
-    }
-    
-    rc_t _determine_in_stmt_iter_count( network_t& net,proc_t* proc, in_stmt_t& in_stmt )
-    {
-      rc_t rc = kOkRC;
-
-      // it has already been determined that this an iterating in-stmt
-      // and a iteration count control element has been identified.
-      assert( in_stmt.in_var_ele.is_iter_fl );
-      assert( in_stmt.iter_cnt_ctl_ele != nullptr );
-
-      switch( in_stmt.iter_cnt_ctl_ele->typeId )
-      {
-        case kInVarTypeId:
-            
-          assert( in_stmt.iter_cnt_ctl_ele->sfx_id_count != kInvalidCnt );
-            
-          if((in_stmt.iter_cnt = in_stmt.iter_cnt_ctl_ele->sfx_id_count) == 0 )
-            rc = cwLogError(rc,"The literal in-var iteration count on '%s:%i' must be greater than zero.", cwStringNullGuard(in_stmt.iter_cnt_ctl_ele->label),in_stmt.iter_cnt_ctl_ele->base_sfx_id);            
-          break;
-            
-        case kSrcProcTypeId:
-          if((rc = _calc_src_proc_ele_count( *in_stmt.src_net, in_stmt.src_proc_ele, in_stmt.iter_cnt )) != kOkRC )
-            rc = cwLogError(rc,"Unable to determine the in-stmt iteration count based on the iteration control src-proc '%s'.",cwStringNullGuard(in_stmt.src_proc_ele.label));
-          break;
-            
-        case kSrcVarTypeId:
-          if((rc = _calc_src_var_ele_count( *in_stmt.src_net, in_stmt.src_proc_ele, in_stmt.src_var_ele, in_stmt.iter_cnt )) != kOkRC )
-            rc = cwLogError(rc,"Unable to determine the in-stmt iteration count based on the iteration control src-var '%s'.",cwStringNullGuard(in_stmt.src_var_ele.label));
-
-          break;
-            
-        default:
-          rc = cwLogError(kInvalidStateRC,"An unknown in-stmt element type was encountered.");
-      }
-      
-      return rc;
-    }
-    
-    void _destroy_in_stmt( in_stmt_t& s )
-    {
-      mem::release(s.in_var_ele.label);
-      mem::release(s.src_net_label);
-      mem::release(s.src_proc_ele.label);
-      mem::release(s.src_var_ele.label);
-    }
-
-    rc_t _parse_in_stmt_in_proc_var_string( char* str, const char*& in_proc_label, const char*& in_var_label )
-    {
-      rc_t  rc     = kOkRC;
-      char* period = nullptr;
-
-      if((period = firstMatchChar(str,'.')) == nullptr )
-      {
-        in_proc_label = nullptr;
-        in_var_label = str;
-      }
-      else
-      {
-        *period = '\0';
-        in_proc_label = str;
-        in_var_label = period + 1;
-      }
-      
-      return rc;
-    }
-
-    rc_t _parse_in_stmt_src_net_proc_var_string( char* str, char*& src_net_label, const char*& src_proc_label, const char*& src_var_label )
-    {
-      rc_t rc = kOkRC;
-      char* period0 = nullptr;
-      char* period1 = nullptr;
-      
-      // locate the separator period on the src proc/var id
-      if((period0 = firstMatchChar(str,'.')) == nullptr )
-      {
-        cwLogError(kSyntaxErrorRC,"No period separator was found in the src net/proc/var for the src specifier:%s.",str);
-        goto errLabel;
-      }
-
-      *period0 = 0;
-      
-      if((period1 = firstMatchChar(period0+1,'.')) != nullptr )
-      {
-        *period1 = 0;
-        src_var_label = period1 + 1;  // Set a pointer to the src var label
-        src_proc_label = period0 + 1;
-        src_net_label = mem::duplStr(str);
-      }
-      else
-      {
-        src_var_label = period0 + 1;
-        src_proc_label = str;
-        src_net_label = nullptr;
-      }
-
-      if( textLength(src_var_label) == 0 )
-        rc = cwLogError(kSyntaxErrorRC,"The 'src-var' label has length 0.");
-
-      if( textLength(src_proc_label) == 0 )
-        rc = cwLogError(kSyntaxErrorRC,"The 'src-proc' label has length 0.");
-
-
-    errLabel:
-      return rc;
-    }
-
-
-    // Recursively search the tree of networks rooted on 'net' for the
-    // network named 'net_proc_label'.
-    network_t*  _find_labeled_network( network_t& net, const char* net_proc_label )
-    {
-      network_t* labeled_net = nullptr;
-
-      // for each proc instance in the network
-      for(unsigned i=0; i<net.proc_arrayN && labeled_net==nullptr; ++i)
-      {
-        proc_t* proc =  net.proc_array[i];
-          
-        // if this proc instance has an  internal network
-        if( proc->internal_net != nullptr )
-        {
-          // if the name of the network matches the key ...
-          if( textIsEqual(proc->label,net_proc_label) )            
-            labeled_net = proc->internal_net; // .. we are done
-          else
-          {
-            // ... otherwise recurse
-            labeled_net = _find_labeled_network(*proc->internal_net,net_proc_label);
-          }
-        }
-        
-      }
-      return labeled_net;
-    }
-
-    // Set  'in_stmt.src_net' based on 'in_stmt.src_net_label'
-    rc_t _locate_src_net(network_t& net,proc_t* proc, in_stmt_t& in_stmt)
-    {
-      rc_t rc = kOkRC;
-      network_t* src_net = nullptr;
-
-      in_stmt.src_net = nullptr;
-      
-      if( in_stmt.src_net_label == nullptr )
-        src_net = &net;
-      else
-      {        
-        if( textIsEqual(in_stmt.src_net_label,"_") )
-          src_net = &proc->ctx->net;
-        else
-        {
-          if((src_net = _find_labeled_network(proc->ctx->net,in_stmt.src_net_label)) == nullptr )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The source net '%s' was not found.",cwStringNullGuard(in_stmt.src_net_label));
-            goto errLabel;
-          }
-        } 
-      }
-    errLabel:
-      in_stmt.src_net = src_net;
-
-      if( in_stmt.src_net == nullptr )
-        rc = cwLogError(kSyntaxErrorRC,"No source net was found.");
-      
-      return rc;
-    }
-
-
-    rc_t _create_in_stmt( network_t& net, proc_t* proc, in_stmt_t& in_stmt, const char* in_proc_var_str, const char* src_proc_var_str )
-    {
-      rc_t     rc           = kOkRC;
-      unsigned src_char_cnt = 0;
-      unsigned in_char_cnt  = 0;
-
-      in_stmt.in_proc_ele.typeId  = kInProcTypeId;
-      in_stmt.in_var_ele.typeId   = kInVarTypeId;
-      in_stmt.src_proc_ele.typeId = kSrcProcTypeId;
-      in_stmt.src_var_ele.typeId  = kSrcVarTypeId;
-      
-      // Both the src and in strings must exist to form an in:src pair.
-      if( (src_char_cnt = textLength(src_proc_var_str)) == 0 || (in_char_cnt = textLength(in_proc_var_str))==0)
-      {
-        cwLogError(kSyntaxErrorRC,"No source variable was found for the input variable '%s'.",cwStringNullGuard(in_proc_var_str));
-        goto errLabel;
-      }
-      else
-      {
-        const char* in_proc_label  = nullptr;
-        const char* in_var_label   = nullptr;
-        const char* src_proc_label = nullptr;
-        const char* src_var_label  = nullptr;
-        unsigned    str_char_cnt   = std::max( src_char_cnt, in_char_cnt );
-        
-        char  str[ str_char_cnt+1 ];
-
-
-        //
-        //  Parse the src net/proc/var 
-        //
-        
-        // put the src proc/var string into a non-const scratch buffer
-        textCopy(str,src_char_cnt+1,src_proc_var_str);
-
-        // parse the src part into it's 3 parts
-        if((rc = _parse_in_stmt_src_net_proc_var_string(str, in_stmt.src_net_label, src_proc_label, src_var_label )) != kOkRC )          
-        {
-          cwLogError(rc,"Unable to parse the 'src' part of an 'in-stmt'.");
-          goto errLabel;
-        }
-
-        // parse the src-proc
-        if((rc = _parse_in_ele( src_proc_label, in_stmt.src_proc_ele  )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_proc_var_str));
-          goto errLabel;
-        }
-
-        // parse the src-var
-        if((rc = _parse_in_ele( src_var_label, in_stmt.src_var_ele )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_proc_var_str));
-          goto errLabel;
-        }
-
-        //
-        // Parse the in proc/var
-        //
-        
-        textCopy(str, in_char_cnt+1, in_proc_var_str );
-
-        // parse the 'in' part into it's 2 parts
-        if((rc = _parse_in_stmt_in_proc_var_string(str, in_proc_label, in_var_label )) != kOkRC )          
-        {
-          cwLogError(rc,"Unable to parse the 'in' part of an 'in-stmt'.");
-          goto errLabel;
-        }
-
-        // parse the in-proc
-        if((rc = _parse_in_ele( in_proc_label, in_stmt.in_proc_ele, true  )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to parse the in-proc from '%s'.",cwStringNullGuard(in_proc_label));
-          goto errLabel;
-        }
-        
-        // parse the in-var
-        if((rc = _parse_in_ele( in_var_label, in_stmt.in_var_ele  )) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to parse the in-var from '%s'.",cwStringNullGuard(in_var_label));
-          goto errLabel;
-        }
-
-
-        
-        // get the var class desc. for the in-var
-        if(( in_stmt.in_var_desc = var_desc_find(proc->class_desc,in_stmt.in_var_ele.label)) == nullptr )
-        {
-          rc = cwLogError(kEleNotFoundRC,"Unable to locate the var class desc for the in-var from '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label));
-          goto errLabel;
-        }
-
-        // get the src net
-        if((rc = _locate_src_net(net,proc,in_stmt)) != kOkRC )
-        {
-          rc = cwLogError(rc,"Unable to locate the src-net '%s'.",cwStringNullGuard(in_stmt.src_net_label));
-          goto errLabel;
-        }
-
-        // verify that both the in-proc and in-var are not iterating
-        if( in_stmt.in_proc_ele.is_iter_fl && in_stmt.in_var_ele.is_iter_fl )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"Both the 'in' proc and 'in' var cannot be iterating. See:'%s'",cwStringNullGuard(in_proc_var_str));
-          goto errLabel;
-        }
-
-        // if the in-var has an sfx_id, or is iterating, then the var needs to be created (the dflt creation process assumes an sfx-id of 0)
-        if( in_stmt.in_var_ele.base_sfx_id != kInvalidId || in_stmt.in_var_ele.is_iter_fl )
-        {
-          in_stmt.create_in_fl = true;
-          if( in_stmt.in_var_ele.base_sfx_id == kInvalidId )
-            in_stmt.in_var_ele.base_sfx_id = kBaseSfxId;
-        }
-
-        // if the src-proc is not iterating and the src-proc was not given a literal sfx-id ...
-        if( in_stmt.src_proc_ele.is_iter_fl==false && in_stmt.src_proc_ele.base_sfx_id==kInvalidId && in_stmt.src_net==&net)
-          in_stmt.src_proc_ele.base_sfx_id = proc->label_sfx_id; // ... then the src proc takes this proc's sfx id
-        // (This results in poly proc's selecting other poly procs with the same sfx-id as sources by default).
-
-        // if this is not an iterating in-stmt ... 
-        if( !in_stmt.in_var_ele.is_iter_fl )
-        {
-          in_stmt.iter_cnt = 1;  // ... then it must be a simple 1:1 connection (Note if in-proc is iterating then it this must also be true)
-        }
-        else
-        {
-          // if the in-stmt is iterating then determine the in-stmt element which controls the iteration count
-          if((rc = _determine_in_stmt_iter_count_ctl_ele(net,proc,in_stmt)) != kOkRC || in_stmt.iter_cnt_ctl_ele==nullptr)
-          {
-            rc = cwLogError(rc,"Unable to determine the iter count control ele.");
-            goto errLabel;
-          }
-
-          // if the in-stmt is iterating then determine the iteration count
-          if((rc = _determine_in_stmt_iter_count(net,proc,in_stmt)) != kOkRC )
-          {
-            cwLogError(rc,"Unable to determine the in-stmt iteration count.");
-            goto errLabel;
-          }
-        }
-      }
-      
-    errLabel:
-      if( rc != kOkRC )
-        _destroy_in_stmt(in_stmt);
-      
-      return rc;      
-    }
-
-    // Find the proxy var associated with the proxied var 'procLabel:varLabel'
-    const variable_t* _find_proxy_var( const char* procLabel, const char* varLabel, const variable_t* proxyVarL )
-    {
-      for(const variable_t* proxyVar=proxyVarL; proxyVar!=nullptr; proxyVar=proxyVar->var_link)
-        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
-          return proxyVar;
-      return nullptr;
-    }
-    
-    rc_t _parse_in_list( network_t& net, proc_t* proc, variable_t* proxyVarL, proc_inst_parse_state_t& pstate )
-    {
-      rc_t rc = kOkRC;
-      
-      if( pstate.in_dict == nullptr )
-        goto errLabel;
-      
-      if( !pstate.in_dict->is_dict() )
-      {
-        cwLogError(kSyntaxErrorRC,"The 'in' dict in proc instance '%s' is not a valid dictionary.",proc->label);
-        goto errLabel;
-      }
-
-      if( pstate.in_dict->child_count() == 0 )
-        goto errLabel;
-
-      pstate.in_arrayN = pstate.in_dict->child_count();
-      pstate.in_array  = mem::allocZ<in_stmt_t>(pstate.in_arrayN);
-
-      // for each input variable in the 'in' set
-      for(unsigned i=0; i<pstate.in_arrayN; ++i)
-      {
-        in_stmt_t&      in_stmt          = pstate.in_array[i];
-        const object_t* in_pair          = pstate.in_dict->child_ele(i); // in:src pair
-        const char*     in_var_str       = nullptr;
-        const char*     src_proc_var_str = nullptr;
-
-        // validate the basic syntax
-        if( in_pair == nullptr || (in_var_str = in_pair->pair_label()) == nullptr || in_pair->pair_value()==nullptr )
-        {
-          cwLogError(rc,"Malformed dictionary encountered in 'in' statement.");
-          goto errLabel;
-        }
-
-        // get the src net/proc/var string
-        if((rc = in_pair->pair_value()->value(src_proc_var_str)) != kOkRC )
-        {
-          cwLogError(rc,"Unable to access the source proc/var string for the input var '%s'.",cwStringNullGuard(in_var_str));
-          goto errLabel;
-        }
-
-        // 
-        if((rc= _create_in_stmt(net, proc, in_stmt, in_var_str, src_proc_var_str )) != kOkRC )
-        {
-          cwLogError(rc,"Parse failed on the in-connection '%s:%s'.",cwStringNullGuard(in_var_str),cwStringNullGuard(src_proc_var_str));
-          goto errLabel;
-        }
-
-        // create the var
-        if( in_stmt.create_in_fl )
-        {
-          const variable_t* proxy_var;
-          
-          // a variable cannot be in the 'in' list if it is a proxied variable - because it will
-          // be connected to a proxy var.
-          if((proxy_var = _find_proxy_var(proc->label, in_stmt.in_var_ele.label, proxyVarL)) != nullptr )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The variable:'%s' cannot be used as the in-var of an 'in' statement if it is a subnet variable: '%s'.",cwStringNullGuard(in_stmt.in_var_ele.label),cwStringNullGuard(proxy_var->label));
-            goto errLabel;
-          }
-
-          
-          for(unsigned i=0; i<in_stmt.iter_cnt; ++i)
-          {
-            variable_t* dum = nullptr;        
-
-            if((rc = var_create( proc,
-                                 in_stmt.in_var_desc->label,
-                                 in_stmt.in_var_ele.base_sfx_id + i,
-                                 kInvalidId,
-                                 kAnyChIdx,
-                                 in_stmt.in_var_desc->val_cfg,
-                                 kInvalidTFl,
-                                 dum )) != kOkRC )
-            {
-              rc = cwLogError(rc,"in-stmt var create failed on '%s:%s'.",cwStringNullGuard(in_var_str),cwStringNullGuard(src_proc_var_str));
-              goto errLabel;
-            }
-          }
-        }        
-      }
-
-    errLabel:
-      
-      return rc;      
-    }
-
-    // This function is used to create the variables on subnet procs
-    // which are represented by interface variables on the subnet proxy (wrapper) proc.
-    // 'proc' is a proc on the subnet's internal proc list
-    // 'wrap_varL' is a list of all the variables on the wrapper proc.
-    // These wrapper variables mirror variables on the internal subnet proc's.
-    // This function finds the variables in wrap_varL that mirror
-    // variables in 'proc' and instantiates them.  
-    rc_t  _create_proxied_vars( proc_t* proc, variable_t* wrap_varL )
-    {
-      rc_t rc = kOkRC;
-
-      // for each proxy var
-      for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link )
-      {
-        // if this proxy var is on this internal proc (proc->label)
-        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,proc->label) )
-        {
-          
-          variable_t* var;
-          
-          // create the proxied var
-          if((rc = var_create( proc, wrap_var->varDesc->proxyVarLabel, wrap_var->label_sfx_id, kInvalidId, wrap_var->chIdx, nullptr, kInvalidTFl, var )) != kOkRC )
-          {
-            rc = cwLogError(rc,"Subnet variable creation failed for %s:%s on wrapper variable:%s:%s.",cwStringNullGuard(wrap_var->varDesc->proxyProcLabel),cwStringNullGuard(wrap_var->varDesc->proxyVarLabel),cwStringNullGuard(wrap_var->proc->label),cwStringNullGuard(wrap_var->label));
-            goto errLabel;
-          }
-
-          //printf("Proxy matched: %s %s %s : flags:%i.\n",proc->label, wrap_var->varDesc->proxyVarLabel, wrap_var->label,wrap_var->varDesc->flags );
-
-          var->flags |= kProxiedVarFl;
-          
-          if( cwIsFlag(wrap_var->varDesc->flags,kSubnetOutVarDescFl) )
-            var->flags |= kProxiedOutVarFl;
-        }
-      }
-
-    errLabel:
-      return rc;
-    }
-
-    variable_t* _find_proxy_var( variable_t* wrap_varL, variable_t* var )
-    {
-      for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link)
-        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,var->proc->label) && textIsEqual(wrap_var->varDesc->proxyVarLabel,var->label) && (wrap_var->label_sfx_id==var->label_sfx_id) )
-          return wrap_var;
-        
-      return nullptr;
-    }
-    
-    rc_t _connect_proxy_vars( proc_t* proc, variable_t* wrap_varL )
-    {
-      rc_t rc = kOkRC;
-      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
-      {
-        if( cwIsFlag(var->flags,kProxiedVarFl) )
-        {
-          variable_t* wrap_var;
-          if((wrap_var = _find_proxy_var(wrap_varL,var)) == nullptr )
-          {
-            rc = cwLogError(kEleNotFoundRC,"The wrapped variable '%s:%i' not found on '%s:%i'.",var->label,var->label_sfx_id,proc->label,proc->label_sfx_id);
-            goto errLabel;
-          }
-          
-          if( cwIsFlag(var->flags,kProxiedOutVarFl) )
-          {
-            //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
-            //       var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id,
-            //       wrap_var->proc->label,wrap_var->proc->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id );
-            
-            var_connect(var,wrap_var);
-          }
-          else
-          {
-            //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
-            //       wrap_var->proc->label,wrap_var->proc->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id,
-            //       var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id );
-            
-            var_connect(wrap_var,var);
-          }          
-        }
-      }
-
-      errLabel:
-        return rc;
-    }
-
-    // Check if the var named 'label' already exists in 'proc->varL'.
-    bool _is_var_proc_already_created( proc_t* proc, const char* var_label, const proc_inst_parse_state_t& pstate )
-    {
-      for(unsigned i=0; i<pstate.in_arrayN; ++i)
-        if( textIsEqual(pstate.in_array[i].in_var_ele.label,var_label) && pstate.in_array[i].create_in_fl )
-          return true;
-
-      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
-        if( textIsEqual(var->label,var_label) )
-          return true;
-      
-      return false;
-    }
-
-    rc_t _connect_in_vars(network_t& net, proc_t* proc, const proc_inst_parse_state_t& pstate)
-    {
-      rc_t rc = kOkRC;
-
-      // for each in-stmt
-      for(unsigned i=0; i<pstate.in_arrayN; ++i)
-      {
-        in_stmt_t& in_stmt = pstate.in_array[i];
-
-        // all in-stmts are iterating (but most only iterate once)
-        for(unsigned j=0; j<in_stmt.iter_cnt; ++j)
-        {
-          variable_t* in_var   = nullptr;
-          network_t*  src_net  = in_stmt.src_net;
-          proc_t*     src_proc = nullptr;
-          variable_t* src_var  = nullptr;
-
-          const char* in_proc_label  = in_stmt.in_proc_ele.label;
-          const char* in_var_label   = in_stmt.in_var_ele.label;
-          const char* src_proc_label = in_stmt.src_proc_ele.label;
-          const char* src_var_label  = in_stmt.src_var_ele.label;
-
-          unsigned in_var_sfx_id   = kInvalidId; //(in_stmt.in_var_ele.base_sfx_id == kInvalidId ? kBaseSfxId : in_stmt.in_var_ele.base_sfx_id) + j;
-          unsigned src_proc_sfx_id = kInvalidId;
-          unsigned src_var_sfx_id  = kInvalidId;
-
-          // if a literal in-var sfx id was not given ...
-          if( in_stmt.in_var_ele.base_sfx_id == kInvalidId )
-            in_var_sfx_id = kBaseSfxId; // ... then use the default sfx-id
-          else
-            in_var_sfx_id = in_stmt.in_var_ele.base_sfx_id; 
-
-          // if a literal src-proc sfx id was not given ...
-          if( in_stmt.src_proc_ele.base_sfx_id == kInvalidId )
-            src_proc_sfx_id = kBaseSfxId; // ... then use the sfx_id of the in-var proc
-          else
-            src_proc_sfx_id = in_stmt.src_proc_ele.base_sfx_id; // ... otherwise use the given literal
-
-          // if a literal src-var sfx id was not given ...
-          if( in_stmt.src_var_ele.base_sfx_id == kInvalidId )
-            src_var_sfx_id = kBaseSfxId; // ... then use the base-sfx-id
-          else
-            src_var_sfx_id = in_stmt.src_var_ele.base_sfx_id; // ... otherwise use the given literal
-
-          // When the in-proc is iterating then we incr by the in-proc sfx-id (in this case j will never exceed 0)
-          // otherwise increment by j - the current iteration count
-          unsigned iter_incr = in_stmt.in_proc_ele.is_iter_fl ? proc->label_sfx_id : j;
-
-          // both in-var and in-proc cannot be iterating
-          assert( !(in_stmt.in_var_ele.is_iter_fl && in_stmt.in_proc_ele.is_iter_fl) );
-
-          // if the in-var is iterating then incr. the in-var sfx-id
-          if( in_stmt.in_var_ele.is_iter_fl )
-            in_var_sfx_id += iter_incr;
-
-          // if this is an iterating src-proc then iter the src-proc-sfx-id
-          if( in_stmt.src_proc_ele.is_iter_fl ) 
-            src_proc_sfx_id += iter_incr;
-
-          // if this is an iterating src-var then iter the src-var-sfx-id
-          if( in_stmt.src_var_ele.is_iter_fl )  
-            src_var_sfx_id += iter_incr;
-                    
-          // locate input value
-          if((rc = var_find( proc, in_var_label, in_var_sfx_id, kAnyChIdx, in_var )) != kOkRC )
-          {
-            rc = cwLogError(rc,"The in-var '%s:%i' was not found.", in_stmt.in_var_ele.label, in_stmt.in_var_ele.base_sfx_id + j);
-            goto errLabel;        
-          }
-          
-          // locate source proc instance 
-          if((src_proc = proc_find(*src_net, src_proc_label, src_proc_sfx_id )) == nullptr )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The src-proc '%s:%i' was not found.", in_stmt.src_proc_ele.label, src_proc_sfx_id );
-            goto errLabel;
-          }
-
-          // locate source variable
-          if((rc = var_find( src_proc, src_var_label, src_var_sfx_id, kAnyChIdx, src_var)) != kOkRC )
-          {
-            rc = cwLogError(rc,"The src-var '%s:i' was not found.", in_stmt.src_var_ele.label, src_var_sfx_id);
-            goto errLabel;
-          }
-
-          // verify that the src_value type is included in the in_value type flags
-          if( cwIsNotFlag(in_var->varDesc->type, src_var->varDesc->type) )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The type flags don't match on input:%s:%i source:%s:%i.%s:%i .", in_var_label, in_var_sfx_id, src_proc_label, src_proc_sfx_id, src_var_label, src_var_sfx_id);        
-            goto errLabel;                
-          }
-
-          // verify that the source exists
-          if( src_var->value == nullptr )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The source value is null on the connection input::%s:%i source:%s:%i.%s:%i .", in_var_label, in_var_sfx_id, src_proc_label, src_proc_sfx_id, src_var_label, src_var_sfx_id);        
-            goto errLabel;
-          }
-
-          //
-          var_connect( src_var, in_var );
-        }                
-      }
-
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(rc,"Connection failed on proc '%s:%i'.",proc->label,proc->label_sfx_id);
-      return rc;
-    }
-
-    // Set pstate.proc_label and pstate.label_sfx_id
-    rc_t  _parse_proc_inst_label( const char* proc_label_str, unsigned system_sfx_id, proc_inst_parse_state_t& pstate )
-    {
-      rc_t     rc         = kOkRC;
-      unsigned digitCharN = 0;
-      unsigned sfx_id     = kInvalidId;
-      unsigned sN         = textLength(proc_label_str);
-      char     s[sN+1];
-
-      if( sN == 0 )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"A blank proc-instance label was encountered.");
-        goto errLabel;
-      }
-      
-      textCopy(s,sN+1,proc_label_str,sN);
-
-      // if this label has no digit suffix
-      if((digitCharN = _digit_suffix_char_count( s )) > 0)
-      {
-        if( digitCharN == sN )
-        {
-          rc = cwLogError(kSyntaxErrorRC,"A proc-instance label ('%s') was encountered that appears to be a number rather than  identifier.",s);
-          goto errLabel;
-        }
-        else
-        {
-          if( string_to_number(s + sN-digitCharN,sfx_id) != kOkRC )
-          {
-            rc = cwLogError(kOpFailRC,"A proc-instance numeric suffix (%s) could not be converted into an integer.",s);
-            goto errLabel;
-          }
-          
-          s[sN-digitCharN] = '\0';
-        }
-      }
-
-      // if the parsed sfx-id did not exist 
-      if( sfx_id == kInvalidId )
-      {
-        sfx_id = system_sfx_id==kInvalidId ? kBaseSfxId : system_sfx_id;
-      }
-      
-      // be sure the parsed sfx-id does not conflict with the system provided sfx-id
-      if( system_sfx_id != kInvalidId && sfx_id != system_sfx_id )
-      {
-        rc = cwLogError(kInvalidStateRC,"The proc instance '%s' numeric suffix id (%i) conflicts with the system provided sfx id (%i).",cwStringNullGuard(proc_label_str),pstate.proc_label_sfx_id,system_sfx_id);
-        goto errLabel;
-      }
-
-      pstate.proc_label        = mem::duplStr(s);
-      pstate.proc_label_sfx_id = sfx_id;
-
-    errLabel:
-      return rc;
-      
-    }
-    
-    rc_t _parse_proc_inst_cfg( network_t& net, const object_t* proc_inst_cfg, unsigned system_sfx_id, proc_inst_parse_state_t& pstate )
-    {
-      rc_t            rc       = kOkRC;
-      const object_t* arg_dict = nullptr;
-      unsigned sfx_id;
-      
-      // validate the syntax of the proc_inst_cfg pair
-      if( !_is_non_null_pair(proc_inst_cfg))
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. is not a valid pair.");
-        goto errLabel;
-      }
-
-      pstate.proc_label_sfx_id = kInvalidId;
-      
-      // extract the proc instance label and (sfx-id suffix)
-      if((rc = _parse_proc_inst_label( proc_inst_cfg->pair_label(), system_sfx_id, pstate )) != kOkRC )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"Parsing failed on the label and sfx-id for '%s'.",cwStringNullGuard(proc_inst_cfg->pair_label()));
-        goto errLabel;
-      }
-      
-      // verify that the proc instance label is unique
-      if( proc_find(net,pstate.proc_label,pstate.proc_label_sfx_id) != nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance label '%s:%i' has already been used.",pstate.proc_label,pstate.proc_label_sfx_id);
-        goto errLabel;
-      }
-      
-      // get the proc instance class label
-      if((rc = proc_inst_cfg->pair_value()->getv("class",pstate.proc_clas_label)) != kOkRC )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. %s:%i is missing: 'type'.",pstate.proc_label,pstate.proc_label_sfx_id);
-        goto errLabel;        
-      }
-      
-      // parse the optional args
-      if((rc = proc_inst_cfg->pair_value()->getv_opt("args",     arg_dict,
-                                                     "in",       pstate.in_dict,
-                                                     "argLabel", pstate.arg_label,
-                                                     "preset",   pstate.preset_labels,
-                                                     "log",      pstate.log_labels )) != kOkRC )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. '%s:%i' missing: 'type'.",pstate.proc_label,pstate.proc_label_sfx_id);
-        goto errLabel;        
-      }
-
-      // if an argument dict was given in the proc instance cfg
-      if( arg_dict != nullptr  )
-      {
-        bool rptErrFl = true;
-
-        // verify the arg. dict is actually a dict.
-        if( !arg_dict->is_dict() )
-        {
-          cwLogError(kSyntaxErrorRC,"The proc instance argument dictionary on proc instance '%s:%i' is not a dictionary.",pstate.proc_label,pstate.proc_label_sfx_id);
-          goto errLabel;
-        }
-        
-        // if no label was given then try 'default'
-        if( pstate.arg_label == nullptr)
-        {
-          pstate.arg_label = "default";
-          rptErrFl = false;
-        }
-
-        // locate the specified argument record
-        if((pstate.arg_cfg = arg_dict->find_child(pstate.arg_label)) == nullptr )
-        {
-
-          // if an explicit arg. label was given but it was not found
-          if( rptErrFl )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on proc instance cfg. '%s:%i'.",pstate.arg_label,pstate.proc_label,pstate.proc_label_sfx_id);
-            goto errLabel;
-          }
-
-          // no explicit arg. label was given - make arg_dict the proc instance arg cfg.
-          pstate.arg_cfg = arg_dict;
-          pstate.arg_label = nullptr;
-        }        
-      }
-
-    errLabel:
-      if( rc != kOkRC )
-        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on proc instance: '%s:%i'.", cwStringNullGuard(pstate.proc_label),pstate.proc_label_sfx_id);
-      
-      return rc;
-    }
-
-    void _destroy_pstate( proc_inst_parse_state_t pstate )
-    {
-      for(unsigned i=0; i<pstate.in_arrayN; ++i)
-        _destroy_in_stmt(pstate.in_array[i]);
-      mem::release(pstate.in_array);
-      mem::release(pstate.proc_label);
-    }
-
-    // Count of proc inst instances which exist in the network with a given class.
-    unsigned _poly_copy_count( const network_t& net, const char* proc_clas_label )
-    {
-      unsigned n = 0;
-      
-      for(unsigned i=0; i<net.proc_arrayN; ++i)
-        if( textIsEqual(net.proc_array[i]->class_desc->label,proc_clas_label) )
-          ++n;
-      return n;
-    }
-
-    rc_t _create_proc_instance( flow_t*         p,
-                                const object_t* proc_inst_cfg,
-                                unsigned        sfx_id,
-                                network_t&      net,
-                                variable_t*     proxyVarL,
-                                proc_t*&    proc_ref )
-    {
-      rc_t                    rc         = kOkRC;
-      proc_inst_parse_state_t pstate     = {};
-      proc_t*                 proc       = nullptr;
-      class_desc_t*           class_desc = nullptr;
-
-      proc_ref = nullptr;
-
-      // parse the proc instance configuration 
-      if((rc = _parse_proc_inst_cfg( net, proc_inst_cfg, sfx_id, pstate )) != kOkRC )
-        goto errLabel;
-      
-      // locate the proc class desc
-      if(( class_desc = class_desc_find(p,pstate.proc_clas_label)) == nullptr )
-      {
-        rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pstate.proc_clas_label));
-        goto errLabel;
-      }
-
-      // if the poly proc instance count has been exceeded for this proc inst class ...
-      if(class_desc->polyLimitN > 0 && _poly_copy_count(net,pstate.proc_clas_label) >= class_desc->polyLimitN )
-      {
-        // ... then silently skip this instantiation
-        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.proc_label,pstate.proc_label_sfx_id);
-        goto errLabel;
-      }
-      
-      // instantiate the proc instance
-      proc = mem::allocZ<proc_t>();
-
-      proc->ctx           = p;
-      proc->label         = mem::duplStr(pstate.proc_label);
-      proc->label_sfx_id  = pstate.proc_label_sfx_id;
-      proc->proc_cfg      = proc_inst_cfg->pair_value();
-      proc->arg_label     = pstate.arg_label;
-      proc->arg_cfg       = pstate.arg_cfg;
-      proc->class_desc    = class_desc;
-      proc->net           = &net;
-
-      // parse the in-list ,fill in pstate.in_array, and create var proc instances for var's referenced by in-list
-      if((rc = _parse_in_list( net, proc, proxyVarL, pstate )) != kOkRC )
-      {
-        rc = cwLogError(rc,"in-list parse failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
-        goto errLabel;
-      }
-
-      // if this is a subnet wrapper proc then create the vars that are connected to the proxy vars
-      if((rc = _create_proxied_vars( proc, proxyVarL )) != kOkRC )
-      {
-        rc = cwLogError(rc,"Proxy vars create failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
-        goto errLabel;
-      }
-
-      // Instantiate all the variables in the class description - that were not already created in _parse_in_list()
-      for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
-        if( !_is_var_proc_already_created( proc, vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
-        {
-          variable_t* var = nullptr;        
-          if((rc = var_create( proc, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, kInvalidTFl, var )) != kOkRC )
-            goto errLabel;
-        }
-
-      // All the variables that can be used by this proc instance have now been created
-      // and the chIdx of each variable is set to 'any'.
-      
-      // If a 'preset' field was included in the class cfg then apply the specified class preset
-      if( pstate.preset_labels != nullptr )      
-        if((rc = _class_apply_presets(proc, pstate.preset_labels )) != kOkRC )
-          goto errLabel;
-
-      // All the class presets values have now been set and those variables
-      // that were expressed with a list have numeric channel indexes assigned.
-
-      // Apply the proc inst instance 'args:{}' values.
-      if( pstate.arg_cfg != nullptr )
-      {
-        if((rc = _proc_inst_args_channelize_vars( proc, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
-          goto errLabel;
-      }
-      
-      // All the proc instance arg values have now been set and those variables
-      // that were expressed with a list have numeric channel indexes assigned.
-
-
-      // TODO: Should the 'all' variable be removed for variables that have numeric channel indexes?
-
-      // Connect the in-list variables to their sources.
-      if((rc = _connect_in_vars(net, proc, pstate)) != kOkRC )
-      {
-        rc = cwLogError(rc,"Input connection processing failed.");
-        goto errLabel;
-      }
-
-      // Connect the proxied vars in this subnet proc
-      if((rc = _connect_proxy_vars( proc, proxyVarL )) != kOkRC )
-      {
-        rc = cwLogError(rc,"Proxy connection processing failed.");
-        goto errLabel;
-      }
-
-      
-      // Complete the instantiation of the proc inst instance by calling the custom proc instance creation function.
-
-      // Call the custom proc instance create() function.
-      if((rc = class_desc->members->create( proc )) != kOkRC )
-      {
-        rc = cwLogError(kInvalidArgRC,"Custom instantiation failed." );
-        goto errLabel;
-      }
-
-      // Create the proc instance->varMap[] lookup array
-      if((rc =_create_proc_var_map( proc )) != kOkRC )
-      {
-        rc = cwLogError(rc,"Variable map creation failed.");
-        goto errLabel;
-      }
-
-      // the custom creation function may have added channels to in-list vars fix up those connections here.
-      //_complete_input_connections(proc);
-
-      // set the log flags again so that vars created by the proc instance can be included in the log output
-      if((rc = _set_log_flags(proc,pstate.log_labels)) != kOkRC )
-        goto errLabel;
-      
-      // call the 'value()' function to inform the proc instance of the current value of all of it's variables.
-      if((rc = _call_value_func_on_all_variables( proc )) != kOkRC )
-        goto errLabel;
-
-      if((rc = proc_validate(proc)) != kOkRC )
-      {
-        rc = cwLogError(rc,"proc inst instance validation failed.");
-        goto errLabel;
-      }
-      
-      proc_ref = proc;
-      
-    errLabel:
-      if( rc != kOkRC )
-      {
-        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.proc_label),pstate.proc_label_sfx_id);
-        proc_destroy(proc);
-      }
-      
-      _destroy_pstate(pstate);
-      
-      return rc;      
-    }
-
-    //=======================================================================================================
-    //
-    // Apply presets
-    //
-
-    
     unsigned _select_ranked_ele_by_rank_prob( const preset_order_t* presetA, const bool* selV , unsigned presetN )
     {
 
@@ -2197,6 +745,1652 @@ namespace cw
       return rc;
     }
 
+                                 
+    
+    //=======================================================================================================
+    //
+    // network creation
+    //
+    
+    typedef enum {
+      kLocalProcTypeId  = 0x01,
+      kLocalVarTypeId   = 0x02,
+      kRemoteProcTypeId = 0x04,
+      kRemoteVarTypeId  = 0x08
+    } io_ele_type_id_t;
+    
+    typedef struct io_ele_str
+    {
+      io_ele_type_id_t typeId;       // See k???TypeId above
+      char*            label;        // label of in or src id
+      unsigned         base_sfx_id;  // Literal base_sfx_id or kInvalidId if the base_sfx_id was not given or 'is_iter_fl' is false
+      unsigned         sfx_id;       // 'sfx_id' is only used by _io_stmt_connect_vars()
+      unsigned         sfx_id_count; // Literal sfx_id_count or kInvalidCnt if not given
+      unsigned         is_iter_fl;   // This id included an '_' (underscore)
+    } io_ele_t;
+
+
+    typedef struct io_stmt_str
+    {
+      io_ele_t    in_proc_ele;      // in-proc element
+      io_ele_t    in_var_ele;       // in-var element
+      io_ele_t    src_proc_ele;     // src-proc element
+      io_ele_t    src_var_ele;      // src-var element
+
+      io_ele_t*   local_proc_ele;
+      io_ele_t*   local_var_ele;
+
+      char*       remote_net_label;
+      network_t*  remote_net;
+      io_ele_t*   remote_proc_ele;
+      io_ele_t*   remote_var_ele;
+
+      bool        local_proc_iter_fl;  // Is the local proc iterating (this is a poly iteration rather than a var iterator)      
+      
+      const io_ele_t* iter_cnt_ctl_ele; // Pointer to the ele which is controlling the iteration count (or null if in-var is non-iterating)
+      unsigned        iter_cnt;         // Count of iterations or 0 if in-var is non-iterating.
+
+
+      // in_stmt only fields
+      var_desc_t* local_var_desc;   // Pointer to the in-var var_desc.
+      bool        in_create_fl;     // True if the in_var needs to be created with an sfx_id, false create the var by the default process (w/o sfx_id)
+
+      
+    } io_stmt_t;
+    
+    typedef struct proc_inst_parse_statestr
+    {
+      char*           proc_label;        //
+      unsigned        proc_label_sfx_id; //
+      const char*     proc_clas_label;   //
+      const char*     arg_label;         //
+      const object_t* preset_labels;     //
+      const object_t* arg_cfg;           //
+      const object_t* log_labels;        //
+      
+      const object_t* in_dict_cfg;  // cfg. node to the in-list
+      io_stmt_t*      iStmtA;
+      unsigned        iStmtN;
+
+      const object_t* out_dict_cfg; // cfg. node to the out-list
+      io_stmt_t*      oStmtA;
+      unsigned        oStmtN;      
+      
+    } proc_inst_parse_state_t;
+
+    bool _is_non_null_pair( const object_t* cfg )
+    { return cfg != nullptr && cfg->is_pair() && cfg->pair_label()!=nullptr && cfg->pair_value()!=nullptr; }
+
+    // Get the count of digits at the end of a string.
+    unsigned _digit_suffix_char_count( const char* s )
+    {
+      unsigned digitN = 0;
+      unsigned sn = textLength(s);
+      if( sn==0 )
+        return 0;
+      
+      const char* s0 = s + (textLength(s)-1);
+      
+      // go backward from the last char until the begin-of-string or a non-digit is found
+      for(; s0>=s; --s0)
+      {
+        if(!isdigit(*s0) )
+          break;
+        ++digitN;
+      }
+
+      return digitN;      
+    }
+
+    rc_t _io_stmt_parse_proc_var_string( char* str, const char*& in_proc_label, const char*& in_var_label )
+    {
+      rc_t  rc     = kOkRC;
+      char* period = nullptr;
+
+      if((period = firstMatchChar(str,'.')) == nullptr )
+      {
+        in_proc_label = nullptr;
+        in_var_label = str;
+      }
+      else
+      {
+        *period = '\0';
+        in_proc_label = str;
+        in_var_label = period + 1;
+      }
+      
+      return rc;
+    }
+
+    rc_t _io_stmt_parse_net_proc_var_string( char* str, char*& src_net_label, const char*& src_proc_label, const char*& src_var_label )
+    {
+      rc_t rc = kOkRC;
+      char* period0 = nullptr;
+      char* period1 = nullptr;
+      
+      // locate the separator period on the src proc/var id
+      if((period0 = firstMatchChar(str,'.')) == nullptr )
+      {
+        cwLogError(kSyntaxErrorRC,"No period separator was found in the src net/proc/var for the src specifier:%s.",str);
+        goto errLabel;
+      }
+
+      *period0 = 0;
+      
+      if((period1 = firstMatchChar(period0+1,'.')) != nullptr )
+      {
+        *period1 = 0;
+        src_var_label = period1 + 1;  // Set a pointer to the src var label
+        src_proc_label = period0 + 1;
+        src_net_label = mem::duplStr(str);
+      }
+      else
+      {
+        src_var_label = period0 + 1;
+        src_proc_label = str;
+        src_net_label = nullptr;
+      }
+
+      if( textLength(src_var_label) == 0 )
+        rc = cwLogError(kSyntaxErrorRC,"The 'src-var' label has length 0.");
+
+      if( textLength(src_proc_label) == 0 )
+        rc = cwLogError(kSyntaxErrorRC,"The 'src-proc' label has length 0.");
+
+
+    errLabel:
+      return rc;
+    }
+
+    
+    rc_t _io_stmt_parse_ele( const char* id_str, io_ele_t& r, bool inProcFl=false  )
+    {
+      rc_t rc = kOkRC;
+      unsigned bufN;
+
+      r.base_sfx_id  = kInvalidId;
+      r.sfx_id_count = kInvalidCnt;
+      
+      if((bufN = textLength(id_str)) == 0 )
+      {
+        if( !inProcFl )         
+          rc = cwLogError(kSyntaxErrorRC,"A blank connection id string was encountered.");
+        goto errLabel;
+      }
+      else
+      {
+        char* underscore = nullptr;
+        char* digit      = nullptr;
+        int   offs       = inProcFl ? 1 : 0; 
+        char  buf[ bufN+(1+offs) ];
+
+        // in-proc's don't have a leading label - add one here to please the parser
+        if(inProcFl)
+          buf[0] = 'x';
+
+        // copy the id string into a non-const scratch buffer 
+        textCopy(buf+offs,bufN+1,id_str);
+
+        // locate the last underscore
+        if((underscore = lastMatchChar(buf,'_')) != nullptr )
+        {
+          *underscore  = 0;   // terminate the string prior to the underscore
+          
+          for(digit  = underscore + 1; *digit; digit++)
+            if( !isdigit(*digit) )
+              break;
+
+          // if the underscore was followed by a number
+          // or if the underscore was the last char
+          // in the string - then digit will point to
+          // the terminating zero - otherwise the
+          // underscore did not indicate an iterating id
+          if( *digit != 0 )
+          {
+            *underscore = '_';  // replace the underscore - its part of the label
+            underscore = nullptr;
+          }
+          else
+          {
+            r.is_iter_fl = true;
+
+            // if there is a number following the underscore then this is the secInt
+            if( textLength(underscore + 1) )
+            {
+              // a literal iteration count was given - parse it into an integer
+              if((rc = string_to_number(underscore + 1,r.sfx_id_count)) != kOkRC )
+              {
+                rc = cwLogError(rc,"Unable to parse the secondary integer in the connection label '%s'.",cwStringNullGuard(id_str));
+                goto errLabel;
+              }
+            }              
+          }
+        }
+
+        // verify that some content remains in the id string
+        if( textLength(buf) == 0 )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Unable to parse the connection id string '%s'.",cwStringNullGuard(id_str));
+          goto errLabel;
+        }
+
+        // go backward from the last char until the begin-of-string or a non-digit is found
+        for(digit=buf + textLength(buf)-1; digit>buf; --digit)
+          if(!isdigit(*digit) )
+          {
+            ++digit; // advance to the first digit in the number
+            break;
+          }
+
+        // if a digit was found then this is the 'priInt'
+        if( digit>buf && textLength(digit) )
+        {
+          assert( buf <= digit-1 && digit-1 <= buf + bufN );
+          
+          // a literal base-sfx-id was given - parse it into an integer
+          if((rc = string_to_number(digit,r.base_sfx_id)) != kOkRC )
+          {
+            rc = cwLogError(rc,"Unable to parse the primary integer in the connection label '%s'.",cwStringNullGuard(id_str));
+            goto errLabel;            
+          }
+
+          *digit = 0; // zero terminate the label
+
+        }
+
+        // verify that some content remains in the id string
+        if( textLength(buf) == 0 )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Unexpected invalid connection id string '%s'.",cwStringNullGuard(id_str));
+          goto errLabel;
+
+        }
+        else
+        {
+          // store the label
+          if( !inProcFl )
+            r.label = mem::duplStr(buf);
+        }
+      }
+      
+
+    errLabel:
+      return rc;
+    }
+
+
+    // Recursively search the tree of networks rooted on 'net' for the
+    // network named 'net_proc_label'.
+    network_t*  _io_stmt_find_labeled_network( network_t& net, const char* net_proc_label )
+    {
+      network_t* labeled_net = nullptr;
+
+      // for each proc instance in the network
+      for(unsigned i=0; i<net.proc_arrayN && labeled_net==nullptr; ++i)
+      {
+        proc_t* proc =  net.proc_array[i];
+          
+        // if this proc instance has an  internal network
+        if( proc->internal_net != nullptr )
+        {
+          // if the name of the network matches the key ...
+          if( textIsEqual(proc->label,net_proc_label) )            
+            labeled_net = proc->internal_net; // .. we are done
+          else
+          {
+            // ... otherwise recurse
+            labeled_net = _io_stmt_find_labeled_network(*proc->internal_net,net_proc_label);
+          }
+        }
+        
+      }
+      return labeled_net;
+    }
+
+
+
+    // If the local-var is iterating then the count of iterations must be controlled by exactly one
+    // of the 3 parts of the io-stmt: local-var,remote_proc, or remote_var.  This function determines
+    // which element is used to determine the iteration count.
+    rc_t _io_stmt_determine_iter_count_ctl_ele(network_t& net,
+                                               proc_t* proc,
+                                               const io_ele_t& localVar,
+                                               const io_ele_t& remoteProc,
+                                               const io_ele_t& remoteVar,
+                                               const char* localLabel,
+                                               const char* remoteLabel,
+                                               const io_ele_t*& result_ref )
+    {
+      assert( localVar.is_iter_fl );
+      rc_t rc = kOkRC;
+
+      result_ref = nullptr;
+      
+      const io_ele_t* iter_cnt_ctl_ele = nullptr;
+
+      // if the local-var gives a literal count - then it determines the count
+      if( localVar.sfx_id_count != kInvalidCnt )
+      {
+        // if the local-var gives a literal count then the remote-proc cannot give one
+        if( remoteProc.sfx_id_count != kInvalidCnt )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The %s-var provided a literal iteration count therefore the %s-proc cannot.",localLabel,remoteLabel);
+          goto errLabel;
+        }
+          
+        // if the local-var gives a literal count then the remote-var cannot give one
+        if( remoteVar.sfx_id_count != kInvalidCnt )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The %s-var provided a literal iteration count therefore the %s-var cannot.",localLabel,remoteLabel);
+          goto errLabel;
+        }
+
+        iter_cnt_ctl_ele = &localVar;
+          
+      }
+      else // the remote-proc or remote-var must control the iter count
+      {
+        // if the remote-proc gives a literal count - then it determines the count
+        if( remoteProc.sfx_id_count != kInvalidCnt )
+        {
+          // then the remote-var cannot give a literal count
+          if( remoteVar.sfx_id_count != kInvalidCnt )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The %s-proc provided a literal iteration count therefore the %s-var cannot.",remoteLabel,remoteLabel);
+            goto errLabel;
+          }
+
+          iter_cnt_ctl_ele = &remoteProc;
+            
+        }
+        else
+        {
+          // if the remote-var gives a literal count - then it determines the count
+          if( remoteVar.sfx_id_count != kInvalidCnt )
+          {
+            iter_cnt_ctl_ele = &remoteVar;
+          }
+          else // no literal count was given - we need to get the implied count
+          {
+            // if the remote-proc is iterating then it will provide the count
+            if( remoteProc.is_iter_fl )
+            {
+              // the remote-var cannot be iterating if the remote-proc is iterating
+              if( remoteVar.is_iter_fl )
+              {
+                rc = cwLogError(kSyntaxErrorRC,"The %s-proc is iterating therefore the %s-var cannot.",remoteLabel,remoteLabel);
+                goto errLabel;
+              }
+                
+              iter_cnt_ctl_ele = &remoteProc;
+            }
+            else // the remote-proc isn't iterating check the remote-var
+            {
+              if( remoteVar.is_iter_fl )
+              {
+                iter_cnt_ctl_ele = &remoteVar;
+              }
+              else // no iteration count control was found
+              {
+                rc = cwLogError(kSyntaxErrorRC,"No iteration count control was specified.");
+                goto errLabel;                  
+              }
+            }
+          }
+        }
+      }               
+      
+    errLabel:
+      
+      if( rc == kOkRC )
+        result_ref = iter_cnt_ctl_ele;
+      
+      return rc;
+    }
+
+    rc_t _io_stmt_calc_proc_ele_count(network_t& net, const io_ele_t& proc_ele, const char* in_or_src_label,  unsigned& cnt_ref)
+    {
+      rc_t rc = kOkRC;
+      cnt_ref = 0;
+      
+      // if a literal proc sfx_id was given then use it otherwise use the default base-sfx-id (0)
+      unsigned sfx_id = proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : proc_ele.base_sfx_id;
+      unsigned n;
+      for(n=0; proc_find(net, proc_ele.label, sfx_id ) != nullptr; ++n )
+        sfx_id += 1;
+
+      if( n == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The %s-proc '%s:%i' was not found.",in_or_src_label,cwStringNullGuard(proc_ele.label),sfx_id);
+        goto errLabel;        
+      }
+
+      cnt_ref = n;
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _io_stmt_calc_var_ele_count(network_t& net, const io_ele_t& proc_ele, const io_ele_t& var_ele, const char* in_or_src_label, unsigned& cnt_ref)
+    {
+      rc_t     rc          = kOkRC;
+      proc_t*  proc        = nullptr;
+      unsigned proc_sfx_id = proc_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : proc_ele.base_sfx_id;
+
+      cnt_ref = 0;
+
+      // locate the proc which owns this var
+      if((proc = proc_find(net,proc_ele.label,proc_sfx_id)) == nullptr )
+      {
+        cwLogError(kSyntaxErrorRC,"The %s-proc inst instance '%s:%i' could not be found.",in_or_src_label,cwStringNullGuard(proc_ele.label),proc_sfx_id);
+        goto errLabel;
+      }
+      else
+      {
+        // if a starting var sfx_id was given by the id then use it otherwise use the default base-sfx-id (0)
+        unsigned sfx_id = var_ele.base_sfx_id==kInvalidCnt ? kBaseSfxId : var_ele.base_sfx_id;
+        unsigned n;
+        for(n=0; var_exists(proc,var_ele.label, sfx_id, kAnyChIdx ); ++n )
+          sfx_id += 1;
+
+
+        if( n == 0 )
+        {
+          cwLogError(kSyntaxErrorRC,"The %s-var '%s:%i' was not found.",in_or_src_label,cwStringNullGuard(var_ele.label),sfx_id);
+          goto errLabel;
+        }
+
+        cnt_ref = n;
+
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _io_stmt_determine_iter_count( network_t& net,proc_t* proc, const char* local_label, const char* remote_label, io_stmt_t& io_stmt )
+    {
+      rc_t rc = kOkRC;
+
+      // it has already been determined that this an iterating io-stmt
+      // and a iteration count control element has been identified.
+      assert( io_stmt.local_var_ele->is_iter_fl );
+      assert( io_stmt.iter_cnt_ctl_ele != nullptr );
+
+      switch( io_stmt.iter_cnt_ctl_ele->typeId )
+      {
+        case kLocalVarTypeId:
+            
+          assert( io_stmt.iter_cnt_ctl_ele->sfx_id_count != kInvalidCnt );
+            
+          if((io_stmt.iter_cnt = io_stmt.iter_cnt_ctl_ele->sfx_id_count) == 0 )
+            rc = cwLogError(rc,"The literal %s-var iteration count on '%s:%i' must be greater than zero.", local_label, cwStringNullGuard(io_stmt.iter_cnt_ctl_ele->label),io_stmt.iter_cnt_ctl_ele->base_sfx_id);            
+          break;
+            
+        case kRemoteProcTypeId:
+          if((rc = _io_stmt_calc_proc_ele_count( *io_stmt.remote_net, *io_stmt.remote_proc_ele, remote_label, io_stmt.iter_cnt )) != kOkRC )
+            rc = cwLogError(rc,"Unable to determine the %s-stmt iteration count based on the iteration control %s-proc '%s'.",local_label,remote_label,cwStringNullGuard(io_stmt.remote_proc_ele->label));
+          break;
+            
+        case kRemoteVarTypeId:
+          if((rc = _io_stmt_calc_var_ele_count( *io_stmt.remote_net, *io_stmt.remote_proc_ele, *io_stmt.remote_var_ele, remote_label, io_stmt.iter_cnt )) != kOkRC )
+            rc = cwLogError(rc,"Unable to determine the %s-stmt iteration count based on the iteration control %s-var '%s'.",local_label,remote_label,cwStringNullGuard(io_stmt.remote_var_ele->label));
+
+          break;
+            
+        default:
+          rc = cwLogError(kInvalidStateRC,"An unknown %s-stmt element type was encountered.",local_label);
+      }
+      
+      return rc;
+    }
+    
+    void _io_stmt_destroy( io_stmt_t& s )
+    {
+      if( s.local_proc_ele != nullptr )
+        mem::release(s.local_proc_ele->label);
+
+      if( s.local_var_ele != nullptr )
+        mem::release(s.local_var_ele->label);
+
+      mem::release(s.remote_net_label);
+
+      if( s.remote_proc_ele )
+        mem::release(s.remote_proc_ele->label);
+
+      if( s.remote_var_ele )
+        mem::release(s.remote_var_ele->label);
+    }
+    
+    void _io_stmt_array_destroy( io_stmt_t*& io_stmtA, unsigned io_stmtN )
+    {
+      if( io_stmtA != nullptr )
+      {  
+        for(unsigned i=0; i<io_stmtN; ++i)
+          _io_stmt_destroy(io_stmtA[i] );
+
+        mem::release(io_stmtA);
+      }
+    }
+
+    rc_t _io_stmt_array_parse( network_t& net, proc_t* proc, const char* io_label, const object_t* io_dict_cfg, io_stmt_t*& ioArray_Ref, unsigned& ioArrayN_Ref )
+    {
+      rc_t       rc         = kOkRC;
+      unsigned   stmtAllocN = 0;
+      unsigned   stmtN      = 0;
+      io_stmt_t* stmtA      = nullptr;
+
+      ioArray_Ref = nullptr;
+      ioArrayN_Ref = 0;
+
+      // if there is no io-dict-cfg 
+      if( io_dict_cfg == nullptr )
+        goto errLabel;
+
+      // validate the out-dict 
+      if( !io_dict_cfg->is_dict() )
+      {
+        cwLogError(kSyntaxErrorRC,"The '%s' dict in proc instance '%s' is not a valid dictionary.",io_label,proc->label);
+        goto errLabel;
+      }
+   
+      if( io_dict_cfg->child_count() == 0 )
+        goto errLabel;
+
+      stmtAllocN = io_dict_cfg->child_count();
+      stmtA      = mem::allocZ<io_stmt_t>(stmtAllocN);
+
+      // for each input variable in the 'in' set
+      for(unsigned i=0; i<stmtAllocN; ++i)
+      {
+        const object_t* io_stmt_pair = io_dict_cfg->child_ele(i);
+        const char* s = nullptr;
+          
+        // validate the stmt pair syntax
+          if( io_stmt_pair==nullptr 
+            || !io_stmt_pair->is_pair()
+            || textLength(io_stmt_pair->pair_label())==0
+            || io_stmt_pair->pair_value()==nullptr
+            || !io_stmt_pair->pair_value()->is_string()
+            || (io_stmt_pair->pair_value()->value(s)) != kOkRC
+            || textLength(s)==0 )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"A syntax error was encoutered while attempting to parse the %s-stmt on the proc %s:%i.",io_label,cwStringNullGuard(proc->label),proc->label_sfx_id);
+          goto errLabel;
+        }
+
+        stmtN += 1;
+      }
+
+      ioArray_Ref  = stmtA;
+      ioArrayN_Ref = stmtN;
+      
+    errLabel:
+      if( rc != kOkRC )
+        _io_stmt_array_destroy(stmtA,stmtN);
+      
+      return rc;
+      
+    }
+
+    // Set  'in_stmt.src_net' based on 'in_stmt.src_net_label'
+    rc_t _io_stmt_locate_remote_net(network_t& net,proc_t* proc, io_stmt_t& io_stmt)
+    {
+      rc_t       rc      = kOkRC;
+      network_t* remote_net = nullptr;
+
+      io_stmt.remote_net = nullptr;
+      
+      if( io_stmt.remote_net_label == nullptr )
+        remote_net = &net;
+      else
+      {        
+        if( textIsEqual(io_stmt.remote_net_label,"_") )
+          remote_net = &proc->ctx->net;
+        else
+        {
+          if((remote_net = _io_stmt_find_labeled_network(proc->ctx->net,io_stmt.remote_net_label)) == nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The source net '%s' was not found.",cwStringNullGuard(io_stmt.remote_net_label));
+            goto errLabel;
+          }
+        } 
+      }
+    errLabel:
+      io_stmt.remote_net = remote_net;
+
+      if( io_stmt.remote_net == nullptr )
+        rc = cwLogError(kSyntaxErrorRC,"No remote net was found.");
+      
+      return rc;
+    }
+    
+
+    rc_t _io_stmt_create( network_t& net,
+                          proc_t*     proc,
+                          io_stmt_t&  io_stmt,
+                          const char* local_proc_var_str,
+                          const char* remote_net_proc_var_str,
+                          const char* local_label,
+                          const char* remote_label)
+    {
+      rc_t rc = kOkRC;
+      
+      unsigned local_char_cnt  = textLength(local_proc_var_str);
+      unsigned remote_char_cnt = textLength(remote_net_proc_var_str);      
+      unsigned str_char_cnt    = std::max( local_char_cnt, remote_char_cnt );
+      
+      const char* remote_net_label  = nullptr;
+      const char* remote_proc_label = nullptr;
+      const char* remote_var_label  = nullptr;
+      const char* local_proc_label  = nullptr;
+      const char* local_var_label   = nullptr;
+        
+      char  str[ str_char_cnt+1 ];
+
+      io_stmt.remote_proc_ele->typeId = kRemoteProcTypeId;
+      io_stmt.remote_var_ele->typeId  = kRemoteVarTypeId;
+      io_stmt.local_proc_ele->typeId  = kLocalProcTypeId;
+      io_stmt.local_var_ele->typeId   = kLocalVarTypeId;
+      
+      //
+      //  Parse the remote net/proc/var 
+      //
+      
+      // put the remote net/proc/var string into a non-const scratch buffer
+      textCopy(str, remote_char_cnt+1, remote_net_proc_var_str );
+
+      // parse the src part into it's 3 parts
+      if((rc = _io_stmt_parse_net_proc_var_string(str, io_stmt.remote_net_label, remote_proc_label, remote_var_label )) != kOkRC )          
+      {
+        cwLogError(rc,"Unable to parse the '%s' part of an 'io-stmt'.",remote_label);
+        goto errLabel;
+      }
+      
+      // parse the rem-proc
+      if((rc = _io_stmt_parse_ele( remote_proc_label, *io_stmt.remote_proc_ele  )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Unable to parse the %s-proc from '%s'.",remote_label,cwStringNullGuard(str));
+        goto errLabel;
+        }
+      
+      // parse the remote-var
+      if((rc = _io_stmt_parse_ele( remote_var_label, *io_stmt.remote_var_ele )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Unable to parse the %s-var from '%s'.",remote_label,cwStringNullGuard(str));
+        goto errLabel;
+      }
+
+
+        //
+        // Parse the local proc/var
+        //
+        
+        textCopy(str, local_char_cnt+1, local_proc_var_str );
+
+        // parse the 'local' part into it's 2 parts
+        if((rc = _io_stmt_parse_proc_var_string(str, local_proc_label, local_var_label )) != kOkRC )          
+        {
+          cwLogError(rc,"Unable to parse the '%s' part of an 'io-stmt'.",local_label);
+          goto errLabel;
+        }
+
+        // parse the local-proc
+        if((rc = _io_stmt_parse_ele( local_proc_label, *io_stmt.local_proc_ele, true  )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the %s-proc from '%s'.",local_label,cwStringNullGuard(str));
+          goto errLabel;
+        }
+        
+        // parse the local-var
+        if((rc = _io_stmt_parse_ele( local_var_label, *io_stmt.local_var_ele  )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to parse the %s-var from '%s'.",local_label,cwStringNullGuard(str));
+          goto errLabel;
+        }
+
+
+        // get the var class desc. for the local-var (only used by in-stmt)
+        if(( io_stmt.local_var_desc = var_desc_find(proc->class_desc,io_stmt.local_var_ele->label)) == nullptr )
+        {
+          rc = cwLogError(kEleNotFoundRC,"Unable to locate the var class desc for the %s-var from '%s'.",local_label,cwStringNullGuard(io_stmt.local_var_ele->label));
+          goto errLabel;
+        }
+        
+        // get the remote net
+        if((rc = _io_stmt_locate_remote_net(net,proc,io_stmt)) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to locate the %s-net '%s'.",remote_label, cwStringNullGuard(io_stmt.remote_net_label));
+          goto errLabel;
+        }
+
+        
+        // verify that both the local-proc and local-var are not iterating
+        if( io_stmt.local_proc_ele->is_iter_fl && io_stmt.local_var_ele->is_iter_fl )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Both the '%s' proc and '%s' var cannot be iterating. See:'%s'",local_label,local_label,cwStringNullGuard(local_proc_var_str));
+          goto errLabel;
+        }
+
+        // if the in-var has an sfx_id, or is iterating, then the var needs to be created (the dflt creation process assumes an sfx-id of 0)
+        if( io_stmt.local_var_ele->base_sfx_id != kInvalidId || io_stmt.local_var_ele->is_iter_fl )
+        {
+          io_stmt.in_create_fl = true;
+          if( io_stmt.local_var_ele->base_sfx_id == kInvalidId )
+            io_stmt.local_var_ele->base_sfx_id = kBaseSfxId;
+        }
+
+        // if the remote-proc is not iterating and the remote-proc was not given a literal sfx-id and the remote is on the same net as the proc ...
+        if( io_stmt.remote_proc_ele->is_iter_fl==false && io_stmt.remote_proc_ele->base_sfx_id==kInvalidId && io_stmt.remote_net==&net)
+          io_stmt.remote_proc_ele->base_sfx_id = proc->label_sfx_id; // ... then the remote proc takes this proc's sfx id
+        // (This results in poly proc's connecting to other poly procs with the same sfx-id by default).
+
+        // if this is not an iterating in-stmt ... 
+        if( !io_stmt.local_var_ele->is_iter_fl )
+        {
+          io_stmt.iter_cnt = 1;  // ... then it must be a simple 1:1 connection (Note if in-proc is iterating then it this must also be true)
+        }
+        else
+        {
+          // if the in-stmt is iterating then determine the in-stmt element which controls the iteration count
+          if((rc = _io_stmt_determine_iter_count_ctl_ele(net,proc,
+                                                         *io_stmt.local_var_ele,
+                                                         *io_stmt.remote_proc_ele,
+                                                         *io_stmt.remote_var_ele,
+                                                         local_label,remote_label,
+                                                         io_stmt.iter_cnt_ctl_ele)) != kOkRC )
+          {
+            rc = cwLogError(rc,"Unable to determine the iter count control ele.");
+            goto errLabel;
+          }
+
+          // if the local-stmt is iterating then determine the iteration count
+          if((rc = _io_stmt_determine_iter_count(net,proc,local_label,remote_label,io_stmt)) != kOkRC )
+          {
+            cwLogError(rc,"Unable to determine the %s-stmt iteration count.",local_label);
+            goto errLabel;
+          }
+        }
+      
+      
+    errLabel:
+        if( rc != kOkRC )
+          _io_stmt_destroy(io_stmt);
+      
+      return rc;
+      
+    }
+    
+    rc_t _io_stmt_connect_vars(network_t&       net,
+                               proc_t*          proc,
+                               const char*      local_label,
+                               const char*      remote_label,
+                               const io_stmt_t* ioStmtA,
+                               unsigned         ioStmtN)
+    {
+      rc_t rc = kOkRC;
+
+      // for each io-stmt
+      for(unsigned i=0; i<ioStmtN; ++i)
+      {
+        const io_stmt_t& io_stmt = ioStmtA[i];
+
+        // all local-stmts are iterating (but most only iterate once)
+        for(unsigned j=0; j<io_stmt.iter_cnt; ++j)
+        {
+          variable_t* local_var   = nullptr;
+          network_t*  remote_net  = io_stmt.remote_net;
+          proc_t*     remote_proc = nullptr;
+          variable_t* remote_var  = nullptr;
+
+          const char* local_proc_label  = io_stmt.local_proc_ele->label;
+          const char* local_var_label   = io_stmt.local_var_ele->label;
+          const char* remote_proc_label = io_stmt.remote_proc_ele->label;
+          const char* remote_var_label  = io_stmt.remote_var_ele->label;
+
+          unsigned local_var_sfx_id   = kInvalidId; 
+          unsigned remote_proc_sfx_id = kInvalidId;
+          unsigned remote_var_sfx_id  = kInvalidId;
+
+          // if a literal in-var sfx id was not given ...
+          if( io_stmt.local_var_ele->base_sfx_id == kInvalidId )
+            local_var_sfx_id = kBaseSfxId; // ... then use the default sfx-id
+          else
+            local_var_sfx_id = io_stmt.local_var_ele->base_sfx_id; 
+
+          // if a literal src-proc sfx id was not given ...
+          if( io_stmt.remote_proc_ele->base_sfx_id == kInvalidId )
+            remote_proc_sfx_id = kBaseSfxId; // ... then use the sfx_id of the in-var proc
+          else
+            remote_proc_sfx_id = io_stmt.remote_proc_ele->base_sfx_id; // ... otherwise use the given literal
+
+          // if a literal src-var sfx id was not given ...
+          if( io_stmt.remote_var_ele->base_sfx_id == kInvalidId )
+            remote_var_sfx_id = kBaseSfxId; // ... then use the base-sfx-id
+          else
+            remote_var_sfx_id = io_stmt.remote_var_ele->base_sfx_id; // ... otherwise use the given literal
+
+          // When the in-proc is iterating then we incr by the in-proc sfx-id (in this case j will never exceed 0)
+          // otherwise increment by j - the current iteration count
+          unsigned iter_incr = io_stmt.local_proc_ele->is_iter_fl ? proc->label_sfx_id : j;
+
+          // both in-var and in-proc cannot be iterating
+          assert( !(io_stmt.local_var_ele->is_iter_fl && io_stmt.local_proc_ele->is_iter_fl) );
+
+          // if the in-var is iterating then incr. the in-var sfx-id
+          if( io_stmt.local_var_ele->is_iter_fl )
+            local_var_sfx_id += iter_incr;
+
+          // if this is an iterating src-proc then iter the src-proc-sfx-id
+          if( io_stmt.remote_proc_ele->is_iter_fl ) 
+            remote_proc_sfx_id += iter_incr;
+
+          // if this is an iterating src-var then iter the src-var-sfx-id
+          if( io_stmt.remote_var_ele->is_iter_fl )  
+            remote_var_sfx_id += iter_incr;
+                    
+          // locate local var
+          if((rc = var_find( proc, local_var_label, local_var_sfx_id, kAnyChIdx, local_var )) != kOkRC )
+          {
+            rc = cwLogError(rc,"The %s-var '%s:%i' was not found.", local_label, io_stmt.local_var_ele->label, io_stmt.local_var_ele->base_sfx_id + j);
+            goto errLabel;        
+          }
+          
+          // locate remote proc instance 
+          if((remote_proc = proc_find(*remote_net, remote_proc_label, remote_proc_sfx_id )) == nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The %s-proc '%s:%i' was not found.", remote_label, io_stmt.remote_proc_ele->label, remote_proc_sfx_id );
+            goto errLabel;
+          }
+
+          // locate remote variable
+          if((rc = var_find( remote_proc, remote_var_label, remote_var_sfx_id, kAnyChIdx, remote_var)) != kOkRC )
+          {
+            rc = cwLogError(rc,"The %s-var '%s:i' was not found.", remote_label, io_stmt.remote_var_ele->label, remote_var_sfx_id);
+            goto errLabel;
+          }
+
+          // verify that the remote_value type is included in the local_value type flags
+          if( cwIsNotFlag(local_var->varDesc->type, remote_var->varDesc->type) )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The type flags don't match on %s:%s:%i %s:%s:%i.%s:%i .", local_label,local_var_label, local_var_sfx_id, remote_label, remote_proc_label, remote_proc_sfx_id, remote_var_label, remote_var_sfx_id);        
+            goto errLabel;                
+          }
+
+          // verify that the source exists
+          if( remote_var->value == nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The %s value is null on the connection %s::%s:%i %s:%s:%i.%s:%i .", remote_label, local_label, local_var_label, local_var_sfx_id, remote_label, remote_proc_label, remote_proc_sfx_id, remote_var_label, remote_var_sfx_id);        
+            goto errLabel;
+          }
+
+          // if this is an 'in-stmt' ...
+          if( io_stmt.local_proc_ele == &io_stmt.in_proc_ele )
+            var_connect( remote_var, local_var );
+          else
+          {
+            // Disconnect any source that was previously connected to the 'in' var
+            // (we do this for feedback connections (out-stmts), but not for in-stmts)
+            var_disconnect( remote_var ); 
+            var_connect( local_var, remote_var ); // ... otherwise it is an out-stmt
+          }
+        }                
+      }
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(rc,"Connection failed on proc '%s:%i'.",proc->label,proc->label_sfx_id);
+      return rc;
+    }
+
+
+    // Find the proxy var associated with the proxied var 'procLabel:varLabel'
+    const variable_t* _in_stmt_find_proxy_var( const char* procLabel, const char* varLabel, const variable_t* proxyVarL )
+    {
+      for(const variable_t* proxyVar=proxyVarL; proxyVar!=nullptr; proxyVar=proxyVar->var_link)
+        if( textIsEqual(proxyVar->varDesc->proxyProcLabel,procLabel) && textIsEqual(proxyVar->varDesc->proxyVarLabel,varLabel) )
+          return proxyVar;
+      return nullptr;
+    }
+    
+    rc_t _in_stmt_parse_in_list( network_t& net, proc_t* proc, variable_t* proxyVarL, proc_inst_parse_state_t& pstate )
+    {
+      rc_t        rc           = kOkRC;
+      const char* local_label  = "in";
+      const char* remote_label = "src";
+
+      if((rc = _io_stmt_array_parse( net, proc, "in", pstate.in_dict_cfg, pstate.iStmtA, pstate.iStmtN)) != kOkRC )
+        goto errLabel;
+
+
+      for(unsigned i=0; i<pstate.iStmtN; ++i)
+      {
+        io_stmt_t* in_stmt = pstate.iStmtA + i;
+
+        const char* src_net_proc_var_str = nullptr;
+        const char* in_proc_var_str      = pstate.in_dict_cfg->child_ele(i)->pair_label();
+        
+        in_stmt->local_proc_ele  = &in_stmt->in_proc_ele;
+        in_stmt->local_var_ele   = &in_stmt->in_var_ele;
+        in_stmt->remote_proc_ele = &in_stmt->src_proc_ele;
+        in_stmt->remote_var_ele  = &in_stmt->src_var_ele;
+
+
+        // The validity of all the data elements in this statement was confirmed previously in _io_stmt_array_parse()
+        pstate.in_dict_cfg->child_ele(i)->pair_value()->value(src_net_proc_var_str);
+
+        assert( src_net_proc_var_str != nullptr );
+
+        // create the io_stmt record
+        if((rc = _io_stmt_create( net, proc, *in_stmt, in_proc_var_str, src_net_proc_var_str, local_label, remote_label )) != kOkRC )
+        {
+          rc = cwLogError(rc,"in-stmt create failed on '%s':%s on proc %s:%i", in_proc_var_str, src_net_proc_var_str, proc->label, proc->label_sfx_id );
+          goto errLabel;
+        }
+        
+        // if the in-var has an sfx_id, or is iterating, then the var needs to be created (the dflt creation process assumes an sfx-id of 0)
+        if( in_stmt->in_var_ele.base_sfx_id != kInvalidId || in_stmt->in_var_ele.is_iter_fl )
+        {
+          in_stmt->in_create_fl = true;
+          if( in_stmt->in_var_ele.base_sfx_id == kInvalidId )
+            in_stmt->in_var_ele.base_sfx_id = kBaseSfxId;
+        }
+
+        // create the var
+        if( in_stmt->in_create_fl )
+        {
+          const variable_t* proxy_var;
+          
+          // a variable cannot be in the 'in' list if it is a proxied variable - because it will
+          // be connected to a proxy var.
+          if((proxy_var = _in_stmt_find_proxy_var(proc->label, in_stmt->in_var_ele.label, proxyVarL)) != nullptr )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The variable:'%s' cannot be used as the in-var of an 'in' statement if it is a subnet variable: '%s'.",cwStringNullGuard(in_stmt->in_var_ele.label),cwStringNullGuard(proxy_var->label));
+            goto errLabel;
+          }
+
+          
+          for(unsigned i=0; i<in_stmt->iter_cnt; ++i)
+          {
+            variable_t* dum = nullptr;        
+
+            if((rc = var_create( proc,
+                                 in_stmt->local_var_desc->label,
+                                 in_stmt->in_var_ele.base_sfx_id + i,
+                                 kInvalidId,
+                                 kAnyChIdx,
+                                 in_stmt->local_var_desc->val_cfg,
+                                 kInvalidTFl,
+                                 dum )) != kOkRC )
+            {
+              rc = cwLogError(rc,"in-stmt var create failed on '%s:%s'.",cwStringNullGuard(in_proc_var_str),cwStringNullGuard(src_net_proc_var_str));
+              goto errLabel;
+            }
+          }
+        }        
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _out_stmt_processing(network_t& net, proc_t* proc, proc_inst_parse_state_t& pstate)
+    {
+      rc_t rc = kOkRC;
+
+      const char* local_label  = "src";
+      const char* remote_label = "in";
+
+      // parse the out-stmt list
+      if((rc = _io_stmt_array_parse( net, proc, "out", pstate.out_dict_cfg, pstate.oStmtA, pstate.oStmtN)) != kOkRC )
+        goto errLabel;
+
+      // for each out-stmt
+      for(unsigned i=0;  i<pstate.oStmtN; ++i)
+      {
+        io_stmt_t*  out_stmt            = pstate.oStmtA + i;
+        const char* in_net_proc_var_str = nullptr;
+        const char* src_proc_var_str    = pstate.out_dict_cfg->child_ele(i)->pair_label();
+        
+        out_stmt->local_proc_ele  = &out_stmt->src_proc_ele;
+        out_stmt->local_var_ele   = &out_stmt->src_var_ele;
+        out_stmt->remote_proc_ele = &out_stmt->in_proc_ele;
+        out_stmt->remote_var_ele  = &out_stmt->in_var_ele;
+
+        // The validity of all the data elements in this statement was confirmed previously in _io_stmt_array_parse()
+        pstate.out_dict_cfg->child_ele(i)->pair_value()->value(in_net_proc_var_str);
+
+        assert( in_net_proc_var_str != nullptr );
+
+        // create the io_stmt record
+        if((rc = _io_stmt_create( net, proc, *out_stmt, src_proc_var_str, in_net_proc_var_str, local_label, remote_label )) != kOkRC )
+        {
+          rc = cwLogError(rc,"out-stmt create failed on '%s':%s on proc %s:%i", src_proc_var_str, in_net_proc_var_str, proc->label, proc->label_sfx_id );
+          goto errLabel;
+        }
+      }
+
+      // create the connections 
+      if((rc = _io_stmt_connect_vars(net, proc, local_label, remote_label, pstate.oStmtA, pstate.oStmtN)) != kOkRC )
+        goto errLabel;
+
+    errLabel:
+      return rc;
+        
+    }
+    
+
+    // This function is used to create the variables on subnet procs
+    // which are represented by interface variables on the subnet proxy (wrapper) proc.
+    // 'proc' is a proc on the subnet's internal proc list
+    // 'wrap_varL' is a list of all the variables on the wrapper proc.
+    // These wrapper variables mirror variables on the internal subnet proc's.
+    // This function finds the variables in wrap_varL that mirror
+    // variables in 'proc' and instantiates them.  
+    rc_t  _subnet_create_proxied_vars( proc_t* proc, variable_t* wrap_varL )
+    {
+      rc_t rc = kOkRC;
+
+      // for each proxy var
+      for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link )
+      {
+        // if this proxy var is on this internal proc (proc->label)
+        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,proc->label) )
+        {
+          
+          variable_t* var;
+          
+          // create the proxied var
+          if((rc = var_create( proc, wrap_var->varDesc->proxyVarLabel, wrap_var->label_sfx_id, kInvalidId, wrap_var->chIdx, nullptr, kInvalidTFl, var )) != kOkRC )
+          {
+            rc = cwLogError(rc,"Subnet variable creation failed for %s:%s on wrapper variable:%s:%s.",cwStringNullGuard(wrap_var->varDesc->proxyProcLabel),cwStringNullGuard(wrap_var->varDesc->proxyVarLabel),cwStringNullGuard(wrap_var->proc->label),cwStringNullGuard(wrap_var->label));
+            goto errLabel;
+          }
+
+          //printf("Proxy matched: %s %s %s : flags:%i.\n",proc->label, wrap_var->varDesc->proxyVarLabel, wrap_var->label,wrap_var->varDesc->flags );
+
+          var->flags |= kProxiedVarFl;
+          
+          if( cwIsFlag(wrap_var->varDesc->flags,kSubnetOutVarDescFl) )
+            var->flags |= kProxiedOutVarFl;
+        }
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    variable_t* _subnet_find_proxy_var( variable_t* wrap_varL, variable_t* var )
+    {
+      for(variable_t* wrap_var=wrap_varL; wrap_var!=nullptr; wrap_var=wrap_var->var_link)
+        if( textIsEqual(wrap_var->varDesc->proxyProcLabel,var->proc->label) && textIsEqual(wrap_var->varDesc->proxyVarLabel,var->label) && (wrap_var->label_sfx_id==var->label_sfx_id) )
+          return wrap_var;
+        
+      return nullptr;
+    }
+    
+    rc_t _subnet_connect_proxy_vars( proc_t* proc, variable_t* wrap_varL )
+    {
+      rc_t rc = kOkRC;
+      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+      {
+        if( cwIsFlag(var->flags,kProxiedVarFl) )
+        {
+          variable_t* wrap_var;
+          if((wrap_var = _subnet_find_proxy_var(wrap_varL,var)) == nullptr )
+          {
+            rc = cwLogError(kEleNotFoundRC,"The wrapped variable '%s:%i' not found on '%s:%i'.",var->label,var->label_sfx_id,proc->label,proc->label_sfx_id);
+            goto errLabel;
+          }
+          
+          if( cwIsFlag(var->flags,kProxiedOutVarFl) )
+          {
+            //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
+            //       var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id,
+            //       wrap_var->proc->label,wrap_var->proc->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id );
+            
+            var_connect(var,wrap_var);
+          }
+          else
+          {
+            //printf("Proxy connection: %i %s:%i-%s:%i -> %s:%i-%s:%i\n",var->flags,
+            //       wrap_var->proc->label,wrap_var->proc->label_sfx_id,wrap_var->label,wrap_var->label_sfx_id,
+            //       var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id );
+            
+            var_connect(wrap_var,var);
+          }          
+        }
+      }
+
+      errLabel:
+        return rc;
+    }
+
+    // Check if the var named 'label' already exists in 'proc->varL'.
+    bool _is_var_proc_already_created( proc_t* proc, const char* var_label, const proc_inst_parse_state_t& pstate )
+    {
+      for(unsigned i=0; i<pstate.iStmtN; ++i)
+        if( textIsEqual(pstate.iStmtA[i].in_var_ele.label,var_label) && pstate.iStmtA[i].in_create_fl )
+          return true;
+
+      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+        if( textIsEqual(var->label,var_label) )
+          return true;
+      
+      return false;
+    }
+    
+    rc_t _proc_inst_args_channelize_vars( proc_t* proc, const char* arg_label, const object_t* arg_cfg )
+    {
+      rc_t rc = kOkRC;
+      
+      if( arg_cfg == nullptr )
+        return rc;
+
+      return _preset_channelize_vars( proc, "proc instance", arg_label, arg_cfg );
+      
+    }
+
+    
+    rc_t  _var_map_id_to_index(  proc_t* proc, unsigned vid, unsigned chIdx, unsigned& idxRef );
+
+    rc_t _proc_create_var_map( proc_t* proc )
+    {
+      rc_t        rc        = kOkRC;
+      unsigned    max_vid   = kInvalidId;
+      unsigned    max_chIdx = 0;
+      variable_t* var       = proc->varL;
+      //variable_t* v0        = nullptr;
+      
+      // determine the max variable vid and max channel index value among all variables
+      for(; var!=nullptr; var = var->var_link )
+      {
+        if( var->vid != kInvalidId )
+        {
+          if( max_vid == kInvalidId || var->vid > max_vid )
+            max_vid = var->vid;
+
+          if( var->chIdx != kAnyChIdx && (var->chIdx+1) > max_chIdx )
+            max_chIdx = (var->chIdx + 1);
+
+        }
+      }
+
+      // If there are any variables
+      if( max_vid != kInvalidId )
+      {
+        // create the variable map array
+        proc->varMapChN = max_chIdx + 1;
+        proc->varMapIdN = max_vid + 1;
+        proc->varMapN   = proc->varMapIdN * proc->varMapChN;
+        proc->varMapA   = mem::allocZ<variable_t*>( proc->varMapN );
+
+        // assign each variable to a location in the map
+        for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+          if( var->vid != kInvalidId )
+          {
+            unsigned idx = kInvalidIdx;
+
+            if((rc = _var_map_id_to_index( proc, var->vid, var->chIdx, idx )) != kOkRC )
+              goto errLabel;
+
+          
+            // verify that there are not multiple variables per map position          
+            if( proc->varMapA[ idx ] != nullptr )
+            {
+              variable_t* v0 = proc->varMapA[idx];
+              rc = cwLogError(kInvalidStateRC,"The variable '%s' id:%i ch:%i and '%s' id:%i ch:%i share the same variable map position on proc instance: %s. This is usually cased by duplicate variable id's.",
+                              v0->label,v0->vid,v0->chIdx, var->label,var->vid,var->chIdx,proc->label);
+
+              goto errLabel;
+            }
+
+            // assign this variable to a map position
+            proc->varMapA[ idx ] = var;
+
+            if( var->chIdx != kAnyChIdx && var->value == nullptr )
+            {
+              rc = cwLogError(kInvalidStateRC,"The value of the variable '%s' ch:%i on proc instance:'%s' has not been set.",var->label,var->chIdx,proc->label);
+              goto errLabel;
+            }
+
+          }
+        
+      }
+
+    errLabel:
+      return rc;
+      
+    }
+
+    /*
+    void _complete_input_connections( proc_t* proc )
+    {
+      for(variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+        if(var->chIdx == kAnyChIdx && is_connected_to_source_proc(var) )
+        {
+
+          variable_t* base_src_var = var->src_var;
+
+          // since 'var' is on the 'any' channel the 'src' var must also be on the 'any' channel
+          assert( base_src_var->chIdx == kAnyChIdx );
+          
+          //printf("%s %s\n",proc->label,var->label);
+          
+          // for each var channel in the input var
+          for(variable_t* in_var = var->ch_link; in_var != nullptr; in_var=in_var->ch_link)
+          {
+            // locate the matching channel on the 'src' var
+            variable_t* svar = base_src_var;
+            for(; svar!=nullptr; svar=svar->ch_link)
+              if( svar->chIdx == in_var->chIdx )
+                break;
+
+            // connect the src->input var
+            _connect_vars( svar==nullptr ? base_src_var : svar, in_var);
+          }
+        }
+    }
+    */
+
+    
+    
+    rc_t _proc_set_log_flags(proc_t* proc, const object_t* log_labels)
+    {
+      rc_t rc = kOkRC;
+      
+      if( log_labels == nullptr )
+        return rc;
+
+      if( !log_labels->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The log spec on '%s:%i' is not a dictionary.",cwStringNullGuard(proc->label),proc->label_sfx_id);
+        goto errLabel;
+      }
+
+      for(unsigned i=0; i<log_labels->child_count(); ++i)
+      {
+        const object_t* pair;
+        unsigned sfx_id;
+        
+        if((pair = log_labels->child_ele(i)) == nullptr || pair->pair_label()==nullptr || pair->pair_value()==nullptr || (rc=pair->pair_value()->value(sfx_id))!=kOkRC )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Syntax error on log var identifier.");
+          goto errLabel;
+        }
+
+        if((rc = var_set_flags( proc, kAnyChIdx, pair->pair_label(), sfx_id, kLogVarFl )) != kOkRC )
+        {
+          rc = cwLogError(rc,"Unable to set var flags on '%s:%i' var:'%s:%i'.",cwStringNullGuard(proc->label),proc->label_sfx_id,pair->pair_label(),sfx_id);
+          goto errLabel;          
+        }
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _proc_call_value_func_on_all_variables( proc_t* proc )
+    {
+      rc_t rc  = kOkRC;
+      rc_t rc1 = kOkRC;
+      
+      for(unsigned i=0; i<proc->varMapN; ++i)
+        if( proc->varMapA[i] != nullptr && proc->varMapA[i]->vid != kInvalidId )
+        {
+          variable_t* var = proc->varMapA[i];
+
+          if((rc = var_call_custom_value_func( var )) != kOkRC )
+            rc1 = cwLogError(rc,"The proc inst instance '%s:%i' reported an invalid valid on variable:%s chIdx:%i.", var->proc->label, var->proc->label_sfx_id, var->label, var->chIdx );
+        }
+      
+      return rc1;
+    }
+    
+    // Set pstate.proc_label and pstate.label_sfx_id
+    rc_t  _proc_parse_inst_label( const char* proc_label_str, unsigned system_sfx_id, proc_inst_parse_state_t& pstate )
+    {
+      rc_t     rc         = kOkRC;
+      unsigned digitCharN = 0;
+      unsigned sfx_id     = kInvalidId;
+      unsigned sN         = textLength(proc_label_str);
+      char     s[sN+1];
+
+      if( sN == 0 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"A blank proc-instance label was encountered.");
+        goto errLabel;
+      }
+      
+      textCopy(s,sN+1,proc_label_str,sN);
+
+      // if this label has no digit suffix
+      if((digitCharN = _digit_suffix_char_count( s )) > 0)
+      {
+        if( digitCharN == sN )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"A proc-instance label ('%s') was encountered that appears to be a number rather than  identifier.",s);
+          goto errLabel;
+        }
+        else
+        {
+          if( string_to_number(s + sN-digitCharN,sfx_id) != kOkRC )
+          {
+            rc = cwLogError(kOpFailRC,"A proc-instance numeric suffix (%s) could not be converted into an integer.",s);
+            goto errLabel;
+          }
+          
+          s[sN-digitCharN] = '\0';
+        }
+      }
+
+      // if the parsed sfx-id did not exist 
+      if( sfx_id == kInvalidId )
+      {
+        sfx_id = system_sfx_id==kInvalidId ? kBaseSfxId : system_sfx_id;
+      }
+      
+      // be sure the parsed sfx-id does not conflict with the system provided sfx-id
+      if( system_sfx_id != kInvalidId && sfx_id != system_sfx_id )
+      {
+        rc = cwLogError(kInvalidStateRC,"The proc instance '%s' numeric suffix id (%i) conflicts with the system provided sfx id (%i).",cwStringNullGuard(proc_label_str),pstate.proc_label_sfx_id,system_sfx_id);
+        goto errLabel;
+      }
+
+      pstate.proc_label        = mem::duplStr(s);
+      pstate.proc_label_sfx_id = sfx_id;
+
+    errLabel:
+      return rc;
+      
+    }
+    
+    rc_t _proc_parse_cfg( network_t& net, const object_t* proc_inst_cfg, unsigned system_sfx_id, proc_inst_parse_state_t& pstate )
+    {
+      rc_t            rc       = kOkRC;
+      const object_t* arg_dict = nullptr;
+      unsigned sfx_id;
+      
+      // validate the syntax of the proc_inst_cfg pair
+      if( !_is_non_null_pair(proc_inst_cfg))
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. is not a valid pair.");
+        goto errLabel;
+      }
+
+      pstate.proc_label_sfx_id = kInvalidId;
+      
+      // extract the proc instance label and (sfx-id suffix)
+      if((rc = _proc_parse_inst_label( proc_inst_cfg->pair_label(), system_sfx_id, pstate )) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"Parsing failed on the label and sfx-id for '%s'.",cwStringNullGuard(proc_inst_cfg->pair_label()));
+        goto errLabel;
+      }
+      
+      // verify that the proc instance label is unique
+      if( proc_find(net,pstate.proc_label,pstate.proc_label_sfx_id) != nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance label '%s:%i' has already been used.",pstate.proc_label,pstate.proc_label_sfx_id);
+        goto errLabel;
+      }
+      
+      // get the proc instance class label
+      if((rc = proc_inst_cfg->pair_value()->getv("class",pstate.proc_clas_label)) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. %s:%i is missing: 'type'.",pstate.proc_label,pstate.proc_label_sfx_id);
+        goto errLabel;        
+      }
+      
+      // parse the optional args
+      if((rc = proc_inst_cfg->pair_value()->getv_opt("args",     arg_dict,
+                                                     "in",       pstate.in_dict_cfg,
+                                                     "out",      pstate.out_dict_cfg,
+                                                     "argLabel", pstate.arg_label,
+                                                     "preset",   pstate.preset_labels,
+                                                     "log",      pstate.log_labels )) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc instance cfg. '%s:%i' missing: 'type'.",pstate.proc_label,pstate.proc_label_sfx_id);
+        goto errLabel;        
+      }
+
+      // if an argument dict was given in the proc instance cfg
+      if( arg_dict != nullptr  )
+      {
+        bool rptErrFl = true;
+
+        // verify the arg. dict is actually a dict.
+        if( !arg_dict->is_dict() )
+        {
+          cwLogError(kSyntaxErrorRC,"The proc instance argument dictionary on proc instance '%s:%i' is not a dictionary.",pstate.proc_label,pstate.proc_label_sfx_id);
+          goto errLabel;
+        }
+        
+        // if no label was given then try 'default'
+        if( pstate.arg_label == nullptr)
+        {
+          pstate.arg_label = "default";
+          rptErrFl = false;
+        }
+
+        // locate the specified argument record
+        if((pstate.arg_cfg = arg_dict->find_child(pstate.arg_label)) == nullptr )
+        {
+
+          // if an explicit arg. label was given but it was not found
+          if( rptErrFl )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on proc instance cfg. '%s:%i'.",pstate.arg_label,pstate.proc_label,pstate.proc_label_sfx_id);
+            goto errLabel;
+          }
+
+          // no explicit arg. label was given - make arg_dict the proc instance arg cfg.
+          pstate.arg_cfg = arg_dict;
+          pstate.arg_label = nullptr;
+        }        
+      }
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(kSyntaxErrorRC,"Configuration parsing failed on proc instance: '%s:%i'.", cwStringNullGuard(pstate.proc_label),pstate.proc_label_sfx_id);
+      
+      return rc;
+    }
+
+
+    
+    void _pstate_destroy( proc_inst_parse_state_t pstate )
+    {
+      _io_stmt_array_destroy(pstate.iStmtA,pstate.iStmtN);
+      _io_stmt_array_destroy(pstate.oStmtA,pstate.oStmtN);
+
+      /*
+      for(unsigned i=0; i<pstate.in_arrayN; ++i)
+        _in_stmt_destroy(pstate.in_array[i]);
+      mem::release(pstate.in_array);
+
+      for(unsigned i=0; i<pstate.out_arrayN; ++i)
+        _out_stmt_destroy(pstate.out_array[i]);
+      mem::release(pstate.out_array);
+      */
+      
+      mem::release(pstate.proc_label);
+    }
+
+    // Count of proc inst instances which exist in the network with a given class.
+    unsigned _poly_copy_count( const network_t& net, const char* proc_clas_label )
+    {
+      unsigned n = 0;
+      
+      for(unsigned i=0; i<net.proc_arrayN; ++i)
+        if( textIsEqual(net.proc_array[i]->class_desc->label,proc_clas_label) )
+          ++n;
+      return n;
+    }
+
+    rc_t _proc_create( flow_t*         p,
+                       const object_t* proc_inst_cfg,
+                       unsigned        sfx_id,
+                       network_t&      net,
+                       variable_t*     proxyVarL,
+                       proc_t*&    proc_ref )
+    {
+      rc_t                    rc         = kOkRC;
+      proc_inst_parse_state_t pstate     = {};
+      proc_t*                 proc       = nullptr;
+      class_desc_t*           class_desc = nullptr;
+
+      proc_ref = nullptr;
+
+      // parse the proc instance configuration 
+      if((rc = _proc_parse_cfg( net, proc_inst_cfg, sfx_id, pstate )) != kOkRC )
+        goto errLabel;
+      
+      // locate the proc class desc
+      if(( class_desc = class_desc_find(p,pstate.proc_clas_label)) == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The flow class '%s' was not found.",cwStringNullGuard(pstate.proc_clas_label));
+        goto errLabel;
+      }
+
+      // if the poly proc instance count has been exceeded for this proc inst class ...
+      if(class_desc->polyLimitN > 0 && _poly_copy_count(net,pstate.proc_clas_label) >= class_desc->polyLimitN )
+      {
+        // ... then silently skip this instantiation
+        cwLogDebug("The poly class copy count has been exceeded for '%s' - skipping instantiation of sfx_id:%i.",pstate.proc_label,pstate.proc_label_sfx_id);
+        goto errLabel;
+      }
+      
+      // instantiate the proc instance
+      proc = mem::allocZ<proc_t>();
+
+      proc->ctx           = p;
+      proc->label         = mem::duplStr(pstate.proc_label);
+      proc->label_sfx_id  = pstate.proc_label_sfx_id;
+      proc->proc_cfg      = proc_inst_cfg->pair_value();
+      proc->arg_label     = pstate.arg_label;
+      proc->arg_cfg       = pstate.arg_cfg;
+      proc->class_desc    = class_desc;
+      proc->net           = &net;
+
+      // parse the in-list ,fill in pstate.in_array, and create var proc instances for var's referenced by in-list
+      if((rc = _in_stmt_parse_in_list( net, proc, proxyVarL, pstate )) != kOkRC )
+      {
+        rc = cwLogError(rc,"in-list parse failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
+        goto errLabel;
+      }
+
+      // if this is a subnet wrapper proc then create the vars that are connected to the proxy vars
+      if((rc = _subnet_create_proxied_vars( proc, proxyVarL )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Proxy vars create failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
+        goto errLabel;
+      }
+
+      // Instantiate all the variables in the class description - that were not already created in _in_stmt_parse_in_list()
+      for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
+        if( !_is_var_proc_already_created( proc, vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
+        {
+          variable_t* var = nullptr;        
+          if((rc = var_create( proc, vd->label, kBaseSfxId, kInvalidId, kAnyChIdx, vd->val_cfg, kInvalidTFl, var )) != kOkRC )
+            goto errLabel;
+        }
+
+      // All the variables that can be used by this proc instance have now been created
+      // and the chIdx of each variable is set to 'any'.
+      
+      // If a 'preset' field was included in the class cfg then apply the specified class preset
+      if( pstate.preset_labels != nullptr )      
+        if((rc = _class_apply_presets(proc, pstate.preset_labels )) != kOkRC )
+          goto errLabel;
+
+      // All the class presets values have now been set and those variables
+      // that were expressed with a list have numeric channel indexes assigned.
+
+      // Apply the proc inst instance 'args:{}' values.
+      if( pstate.arg_cfg != nullptr )
+      {
+        if((rc = _proc_inst_args_channelize_vars( proc, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
+          goto errLabel;
+      }
+      
+      // All the proc instance arg values have now been set and those variables
+      // that were expressed with a list have numeric channel indexes assigned.
+
+
+      // TODO: Should the 'all' variable be removed for variables that have numeric channel indexes?
+
+      if((rc = _io_stmt_connect_vars(net, proc, "in", "src", pstate.iStmtA, pstate.iStmtN)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Input connection processing failed.");
+        goto errLabel;
+      }
+
+      /*
+      // Connect the in-list variables to their sources.
+      if((rc = _in_stmt_connect_in_vars(net, proc, pstate)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Input connection processing failed.");
+        goto errLabel;
+      }
+      */
+      
+      // Connect the proxied vars in this subnet proc
+      if((rc = _subnet_connect_proxy_vars( proc, proxyVarL )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Proxy connection processing failed.");
+        goto errLabel;
+      }
+
+      
+      // Complete the instantiation of the proc inst instance by calling the custom proc instance creation function.
+
+      // Call the custom proc instance create() function.
+      if((rc = class_desc->members->create( proc )) != kOkRC )
+      {
+        rc = cwLogError(kInvalidArgRC,"Custom instantiation failed." );
+        goto errLabel;
+      }
+
+      // Create the proc instance->varMap[] lookup array
+      if((rc =_proc_create_var_map( proc )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Variable map creation failed.");
+        goto errLabel;
+      }
+
+      // create the feedback connections
+      _out_stmt_processing( net, proc, pstate );
+      
+      // the custom creation function may have added channels to in-list vars fix up those connections here.
+      //_complete_input_connections(proc);
+
+      // set the log flags again so that vars created by the proc instance can be included in the log output
+      if((rc = _proc_set_log_flags(proc,pstate.log_labels)) != kOkRC )
+        goto errLabel;
+      
+      // call the 'value()' function to inform the proc instance of the current value of all of it's variables.
+      if((rc = _proc_call_value_func_on_all_variables( proc )) != kOkRC )
+        goto errLabel;
+
+      if((rc = proc_validate(proc)) != kOkRC )
+      {
+        rc = cwLogError(rc,"proc inst instance validation failed.");
+        goto errLabel;
+      }
+      
+      proc_ref = proc;
+      
+    errLabel:
+      if( rc != kOkRC )
+      {
+        rc = cwLogError(rc,"Proc instantiation failed on '%s:%i'.",cwStringNullGuard(pstate.proc_label),pstate.proc_label_sfx_id);
+        proc_destroy(proc);
+      }
+      
+      _pstate_destroy(pstate);
+      
+      return rc;      
+    }
+
     
   }
 }
@@ -2254,7 +2448,7 @@ cw::rc_t cw::flow::network_create( flow_t*            p,
         assert(net.proc_arrayN < net.proc_arrayAllocN );
         
         // create the proc inst instance
-        if( (rc= _create_proc_instance( p, proc_cfg, sfx_id, net, proxyVarL, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
+        if( (rc= _proc_create( p, proc_cfg, sfx_id, net, proxyVarL, net.proc_array[net.proc_arrayN] ) ) != kOkRC )
         {
           //rc = cwLogError(rc,"The instantiation at proc index %i is invalid.",net.proc_arrayN);
           goto errLabel;

From f09c9b0151a9a4d9014120b0b3c7f4e2f78ec0ac Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 11 May 2024 07:42:09 -0400
Subject: [PATCH 078/101] README.md : Updates

---
 README.md | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index c200725..4fd7b4d 100644
--- a/README.md
+++ b/README.md
@@ -1012,28 +1012,29 @@ Next:
 
 	+ DONE: improve code comments on subnet creation
 
-- Implement feedback	
 - Audio inputs should be able to be initialized with a channel count and srate without actually connecting an input.
   This will allow feedback connections to be attached to them at a later stage of the network 
   instantiation.
-- Remove the multiple 'args' thing and and 'argsLabe'.  'args' should be a simple set of arg's.  
+- Remove the multiple 'args' thing and and 'argsLabel'.  'args' should be a simple set of arg's.  
 - Implement subnet preset application.	
 - Implement the var attributes and attribute checking.
 - Implement dynamic loading of procs.
 - Implement a debug mode to aid in building networks and subnets (or is logging good enough)
 - Implement multi-field messages.
-- Implement the ability to set backward connections - from late to early proc's.
+- Look more closely at the way of identify an in-stmt src-net or a out-stmt in-net.
+It's not clear there is a difference between specifying  `_` and the default behaviour.
+Is there a way to tell it to search the entire network from the root? Isn't that 
+what '_' is supposed to do.
+  
+- DONE: Implement feedback	
+
+- DONE: Implement the ability to set backward connections - from late to early proc's.
   This can be done by implementing the same process as 'in_stmt' but in a separate 
   'out_stmt'. The difficulty is that it prevents doing some checks until the network
   is completely specified.  For example if audio inputs can accept connections from 
   later proc's then they will not have all of their inputs when they are instantiated.
   One way around this is to instantiate them with an initial set of inputs but then
   allow those inputs to be replaced by a later connection.
-- Look more closely at the way of identify an in-stmt src-net or a out-stmt in-net.
-It's not clear there is a difference between specifying  `_` and the default behaviour.
-Is there a way to tell it to search the entire network from the root? Isn't that 
-what '_' is supposed to do.
-  
 
 BUGS:
 - The counter modulo mode is not working as expected.

From 07822a1c44da1283994331c5e967d0d57254474e Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sun, 19 May 2024 15:24:33 -0400
Subject: [PATCH 079/101] cwFlow,cwFlowNet,cwFlowTypes : Preset compile and
 rewrite of network_apply_preset() and network_apply_dual_preset(). Code
 complete but not fully tested.

---
 cwFlow.cpp      |   2 +-
 cwFlowNet.cpp   | 883 ++++++++++++++++++++++++++++++++++++++++++------
 cwFlowTypes.cpp | 138 +++++++-
 cwFlowTypes.h   | 100 ++++--
 4 files changed, 993 insertions(+), 130 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index 47cf7fa..884ade0 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -310,7 +310,7 @@ namespace cw
               goto errLabel;
             }
 
-            preset_t* preset =  mem::allocZ< preset_t >();
+            class_preset_t* preset =  mem::allocZ< class_preset_t >();
               
             preset->label = pair->pair_label();
             preset->cfg   = pair->pair_value();
diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index 4eb3a47..bae0a56 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -23,6 +23,33 @@ namespace cw
   {
 
 
+    void _preset_value_destroy( preset_value_t* v )
+    {
+      mem::release(v);
+    }
+    
+    void _network_preset_destroy(network_preset_t& network_preset)
+    {
+      preset_value_t* pv = network_preset.value_head;
+      while( pv != nullptr )
+      {
+        preset_value_t* pv0 = pv->link;
+        _preset_value_destroy(pv);
+        pv = pv0;
+      }
+      
+      network_preset.value_head = nullptr;
+      network_preset.value_tail = nullptr;
+      
+    }
+    
+    void _network_preset_array_destroy( network_t& net )
+    {
+      for(unsigned i=0; i<net.presetN; ++i)
+        _network_preset_destroy( net.presetA[i] );
+      mem::release(net.presetA);
+    }
+    
     rc_t _network_destroy( network_t& net )
     {
       rc_t rc = kOkRC;
@@ -33,6 +60,11 @@ namespace cw
       mem::release(net.proc_array);
       net.proc_arrayAllocN = 0;
       net.proc_arrayN = 0;
+
+      _network_preset_array_destroy(net);
+
+      mem::release(net.preset_pairA);
+      net.preset_pairN = 0;
       
       return rc;
     }
@@ -112,6 +144,7 @@ namespace cw
       return rc;
     }
 
+#ifdef NOT_DEF    
 
     template< typename T >
     T _interp_dual_value( T v0, T v1, double coeff )
@@ -315,7 +348,8 @@ namespace cw
     errLabel:
       return rc;
     }
-    
+
+
     rc_t _multi_preset_channelize_vars( proc_t* proc, const char* type_src_label, const char** presetLabelA, const object_t** preset_cfgA, unsigned presetN, double coeff )
     {
       rc_t rc = kOkRC;
@@ -406,7 +440,7 @@ namespace cw
       {
         if( class_preset_labelA[i] != nullptr )
         {
-          const preset_t* pr;
+          const class_preset_t* pr;
           
           // locate the requestd preset record
           if((pr = class_preset_find(proc->class_desc, class_preset_labelA[i])) == nullptr )
@@ -449,11 +483,12 @@ namespace cw
       return rc;
       
     }
+#endif
     
     rc_t _class_preset_channelize_vars( proc_t* proc, const char* preset_label )
     {
       rc_t            rc = kOkRC;
-      const preset_t* pr;
+      const class_preset_t* pr;
 
       if( preset_label == nullptr )
         return kOkRC;
@@ -591,63 +626,6 @@ namespace cw
       return idxMapA[sel_idx];
     }
 
-    /*
-    unsigned _select_ranked_ele_by_rank_prob( const preset_order_t* rankV, unsigned rankN )
-    {     
-      unsigned threshV[ rankN ];
-      unsigned uniqueRankV[ rankN ];      
-      unsigned uniqueRankN = 0;
-      unsigned sel_idx = rankN - 1; //
-
-      if( rankN == 0 )
-        return kInvalidIdx;
-
-      if( rankN == 1 )
-        return 0;
-
-      // for each possible rank value
-      for(unsigned i=0; i<rankN; ++i)
-      {
-        // locate the rank in the uniqueRankV[]
-        unsigned j=0;
-        for(; j<uniqueRankN; ++j)
-          if( uniqueRankV[j]==rankV[i].order )
-            break;
-
-        // if the rank was not found then include it here
-        if( j == uniqueRankN )
-          uniqueRankV[uniqueRankN++] = rankV[i].order;
-
-      }
-
-      // uniqueRankV[] now includes the set of possible rank values
-      
-      // Take the product of all possible values.
-      // (this will be evenly divisible by all values)
-      unsigned prod = vop::prod(uniqueRankV,uniqueRankN);
-
-      unsigned thresh = 0;
-      for(unsigned i=0; i<rankN; ++i)
-        threshV[i] = (thresh += rankV[i].order * prod);
-
-      // Thresh is now set to the max possible random value.
-      
-      // Generate a random number between 0 and thresh
-      double   fval = (double)std::rand() * thresh / RAND_MAX;
-
-      unsigned thresh0 = 0;
-      for(unsigned i=0; i<rankN; ++i)
-      {
-        if( thresh0 <= fval && fval < threshV[i] )
-        {
-          sel_idx = i;
-          break;
-        }
-      }
-
-      return sel_idx;
-    }
-    */
     
     const char* _select_ranked_ele_label_by_rank_prob( const preset_order_t* rankV, const bool* selA, unsigned rankN )
     {
@@ -711,7 +689,8 @@ namespace cw
       
       return result;
     }
-    
+
+#ifdef NOT_DEF    
     rc_t _find_network_preset_proc_pair( network_t& net, const char* preset_label, const char* proc_label, const object_t*& preset_val_ref )
     {
       rc_t rc = kOkRC;
@@ -744,7 +723,7 @@ namespace cw
     errLabel:
       return rc;
     }
-
+#endif
                                  
     
     //=======================================================================================================
@@ -914,7 +893,7 @@ namespace cw
       if((bufN = textLength(id_str)) == 0 )
       {
         if( !inProcFl )         
-          rc = cwLogError(kSyntaxErrorRC,"A blank connection id string was encountered.");
+          rc = cwLogError(kSyntaxErrorRC,"A blank id string was encountered.");
         goto errLabel;
       }
       else
@@ -960,7 +939,7 @@ namespace cw
               // a literal iteration count was given - parse it into an integer
               if((rc = string_to_number(underscore + 1,r.sfx_id_count)) != kOkRC )
               {
-                rc = cwLogError(rc,"Unable to parse the secondary integer in the connection label '%s'.",cwStringNullGuard(id_str));
+                rc = cwLogError(rc,"Unable to parse the secondary integer in the id label '%s'.",cwStringNullGuard(id_str));
                 goto errLabel;
               }
             }              
@@ -970,7 +949,7 @@ namespace cw
         // verify that some content remains in the id string
         if( textLength(buf) == 0 )
         {
-          rc = cwLogError(kSyntaxErrorRC,"Unable to parse the connection id string '%s'.",cwStringNullGuard(id_str));
+          rc = cwLogError(kSyntaxErrorRC,"Unable to parse the id string '%s'.",cwStringNullGuard(id_str));
           goto errLabel;
         }
 
@@ -990,7 +969,7 @@ namespace cw
           // a literal base-sfx-id was given - parse it into an integer
           if((rc = string_to_number(digit,r.base_sfx_id)) != kOkRC )
           {
-            rc = cwLogError(rc,"Unable to parse the primary integer in the connection label '%s'.",cwStringNullGuard(id_str));
+            rc = cwLogError(rc,"Unable to parse the primary integer in the id '%s'.",cwStringNullGuard(id_str));
             goto errLabel;            
           }
 
@@ -1001,7 +980,7 @@ namespace cw
         // verify that some content remains in the id string
         if( textLength(buf) == 0 )
         {
-          rc = cwLogError(kSyntaxErrorRC,"Unexpected invalid connection id string '%s'.",cwStringNullGuard(id_str));
+          rc = cwLogError(kSyntaxErrorRC,"Unexpected invalid id '%s'.",cwStringNullGuard(id_str));
           goto errLabel;
 
         }
@@ -2202,20 +2181,10 @@ namespace cw
       _io_stmt_array_destroy(pstate.iStmtA,pstate.iStmtN);
       _io_stmt_array_destroy(pstate.oStmtA,pstate.oStmtN);
 
-      /*
-      for(unsigned i=0; i<pstate.in_arrayN; ++i)
-        _in_stmt_destroy(pstate.in_array[i]);
-      mem::release(pstate.in_array);
-
-      for(unsigned i=0; i<pstate.out_arrayN; ++i)
-        _out_stmt_destroy(pstate.out_array[i]);
-      mem::release(pstate.out_array);
-      */
-      
       mem::release(pstate.proc_label);
     }
 
-    // Count of proc inst instances which exist in the network with a given class.
+    // Count of proc instances which exist in the network with a given class.
     unsigned _poly_copy_count( const network_t& net, const char* proc_clas_label )
     {
       unsigned n = 0;
@@ -2231,7 +2200,7 @@ namespace cw
                        unsigned        sfx_id,
                        network_t&      net,
                        variable_t*     proxyVarL,
-                       proc_t*&    proc_ref )
+                       proc_t*&        proc_ref )
     {
       rc_t                    rc         = kOkRC;
       proc_inst_parse_state_t pstate     = {};
@@ -2286,6 +2255,7 @@ namespace cw
       }
 
       // Instantiate all the variables in the class description - that were not already created in _in_stmt_parse_in_list()
+      // or _subnet_create_proxied_vars().
       for(var_desc_t* vd=class_desc->varDescL; vd!=nullptr; vd=vd->link)
         if( !_is_var_proc_already_created( proc, vd->label, pstate ) && cwIsNotFlag(vd->type,kRuntimeTFl) )
         {
@@ -2298,11 +2268,12 @@ namespace cw
       // and the chIdx of each variable is set to 'any'.
       
       // If a 'preset' field was included in the class cfg then apply the specified class preset
+      // Note that the 'preset' field can be a string or list of strings.
       if( pstate.preset_labels != nullptr )      
         if((rc = _class_apply_presets(proc, pstate.preset_labels )) != kOkRC )
           goto errLabel;
 
-      // All the class presets values have now been set and those variables
+      // The requested class presets values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
       // Apply the proc inst instance 'args:{}' values.
@@ -2315,25 +2286,14 @@ namespace cw
       // All the proc instance arg values have now been set and those variables
       // that were expressed with a list have numeric channel indexes assigned.
 
-
-      // TODO: Should the 'all' variable be removed for variables that have numeric channel indexes?
-
+      // Connect the var's that are referenced in the in-stmt to their respective sources
       if((rc = _io_stmt_connect_vars(net, proc, "in", "src", pstate.iStmtA, pstate.iStmtN)) != kOkRC )
       {
         rc = cwLogError(rc,"Input connection processing failed.");
         goto errLabel;
       }
-
-      /*
-      // Connect the in-list variables to their sources.
-      if((rc = _in_stmt_connect_in_vars(net, proc, pstate)) != kOkRC )
-      {
-        rc = cwLogError(rc,"Input connection processing failed.");
-        goto errLabel;
-      }
-      */
       
-      // Connect the proxied vars in this subnet proc
+      // Connect the proxied vars in this subnet proc to their respective proxy vars.
       if((rc = _subnet_connect_proxy_vars( proc, proxyVarL )) != kOkRC )
       {
         rc = cwLogError(rc,"Proxy connection processing failed.");
@@ -2371,6 +2331,7 @@ namespace cw
       if((rc = _proc_call_value_func_on_all_variables( proc )) != kOkRC )
         goto errLabel;
 
+      // validate the proc's state.
       if((rc = proc_validate(proc)) != kOkRC )
       {
         rc = cwLogError(rc,"proc inst instance validation failed.");
@@ -2391,6 +2352,630 @@ namespace cw
       return rc;      
     }
 
+    //
+    //  Network preset pair table
+    //
+
+    rc_t _network_preset_pair_count( const network_t& net, unsigned& count_ref  )
+    {
+      rc_t rc = kOkRC;
+      
+      count_ref = 0;
+      unsigned n = 0;
+      for(unsigned i=0; i<net.proc_arrayN; ++i)
+      {
+        const proc_t* proc = net.proc_array[i];
+        for(const variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+          if( var->chIdx == kAnyChIdx )
+          {
+            unsigned varChCnt = 0;
+            if((rc = var_channel_count(var,varChCnt)) != kOkRC )
+            {
+              rc = cwLogError(rc,"The network preset pair count operation failed.");
+              goto errLabel;
+            }
+            
+            n += varChCnt + 1; // Add 1 for the kAnyCh
+          }
+      }
+      
+      count_ref = n;
+    errLabel:
+      
+      return rc;
+    }
+
+    rc_t _network_preset_pair_fill_table( const network_t& net, network_preset_pair_t* nppA, unsigned nppN)
+    {
+      rc_t     rc = kOkRC;
+      unsigned j  = 0;
+      for(unsigned i=0; i<net.proc_arrayN; ++i)
+      {
+        const proc_t* proc = net.proc_array[i];
+        for(const variable_t* var=proc->varL; var!=nullptr; var=var->var_link)
+          if( var->chIdx == kAnyChIdx )
+          {
+            unsigned varChCnt                          = 0;
+            if((rc = var_channel_count(var,varChCnt)) != kOkRC )
+              goto errLabel;
+
+            unsigned k=0;
+            for(const variable_t* ch_var=var; ch_var!=nullptr; ch_var = ch_var->ch_link, ++j,++k )
+            {
+              if( j >= nppN )
+              {
+                rc = cwLogError(kInvalidStateRC,"Unexpected end of preset-pair table was encountered.");
+                goto errLabel;
+              }
+              
+              nppA[j].proc  = proc;
+              nppA[j].var   = ch_var;
+              nppA[j].chIdx = var->chIdx;;
+              nppA[j].chN   = varChCnt;;
+            }
+
+            if( k != varChCnt+1 )
+            {
+              rc = cwLogError(kInvalidStateRC,"An inconsistent var channel count was encountered on '%s:%i'-'%s:%i'.",
+                              cwStringNullGuard(proc->label),proc->label_sfx_id,
+                              cwStringNullGuard(var->label),var->label_sfx_id);
+              goto errLabel;
+            }
+            
+          }
+      }
+
+      if( j != nppN )
+        rc = cwLogError(kInvalidStateRC,"The expected count of entries in the preset_pair table (%i) does not match the actual count (%i).",nppN,j);
+
+    errLabel:
+      if( rc != kOkRC )
+        rc = cwLogError(rc,"Preset pair table fill failed.");
+      return rc;
+    }
+
+    rc_t _network_preset_pair_create_table( network_t& net )
+    {
+      rc_t     rc         = kOkRC;
+      unsigned pair_count = 0;
+
+      // get the total count of variables in this network
+      if((rc = _network_preset_pair_count(net, pair_count  )) != kOkRC )
+        goto errLabel;
+      
+      // allocate the preset pair tble
+      net.preset_pairA = mem::allocZ<network_preset_pair_t>(pair_count);
+      net.preset_pairN = pair_count;
+
+      // fill the preset pair table
+      if((rc= _network_preset_pair_fill_table(net, net.preset_pairA, net.preset_pairN)) != kOkRC )
+        goto errLabel;
+      
+
+    errLabel:
+      if( rc != kOkRC )
+      {
+        rc = cwLogError(rc,"Network preset pair table create failed.");
+        mem::release(net.preset_pairA);
+        net.preset_pairN = 0;
+      }
+      
+      return rc;
+    }
+
+    unsigned _network_preset_pair_find_index( const network_t& net, const variable_t* var )
+    {      
+      for(unsigned i=0; i<net.preset_pairN; ++i)
+      {
+        const network_preset_pair_t* npp = net.preset_pairA + i;
+        
+        if( var->proc == npp->proc && var == npp->var )
+        {
+          assert( var->chIdx == npp->var->chIdx );
+          return i;
+        }
+      }
+
+      return kInvalidIdx;
+    }
+
+    //
+    //  Preset processing
+    //
+    
+    rc_t _parse_network_proc_label( const network_t& net, const network_preset_t& network_preset, const char* proc_label, io_ele_t& proc_id )
+    {
+      rc_t rc = kOkRC;
+      
+      // parse the proc label
+      if((rc= _io_stmt_parse_ele( proc_label, proc_id )) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"Parse failed on the proc label '%s' of preset '%s'.",cwStringNullGuard(proc_label),cwStringNullGuard(network_preset.label));
+        goto errLabel;
+      }
+
+      // set the proc_id base sfx id
+      if( proc_id.base_sfx_id == kInvalidId )
+        proc_id.base_sfx_id = kBaseSfxId;
+
+      // if not iterating
+      if( !proc_id.is_iter_fl )
+      {
+        proc_id.sfx_id_count = 1;
+      }
+      else
+      {
+        if( proc_id.sfx_id_count == kInvalidCnt )
+          proc_id.sfx_id_count = proc_mult_count(net, proc_label );
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _parse_network_proc_var_label( network_t& net, const char* network_preset_label, const object_t* var_pair, const char* proc_label, unsigned proc_label_sfx_id, io_ele_t& var_id )
+    {
+      rc_t        rc        = kOkRC;
+      const char* var_label = nullptr;
+          
+      if( var_pair==nullptr || !var_pair->is_pair() || (var_label=var_pair->pair_label())==nullptr || var_pair->pair_value() == nullptr )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"A syntax error was encountered on a preset pair value on preset '%s:%s'.",cwStringNullGuard(network_preset_label),cwStringNullGuard(proc_label));
+        goto errLabel;
+      }
+
+      // 
+      if((rc= _io_stmt_parse_ele( var_label, var_id )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parse failed on the var label of preset '%s:%s:%s'.",cwStringNullGuard(network_preset_label),cwStringNullGuard(proc_label),cwStringNullGuard(var_label));
+        goto errLabel;
+      }
+
+      // set the var_id base sfx id
+      if( var_id.base_sfx_id == kInvalidId )
+        var_id.base_sfx_id = kBaseSfxId;
+
+      // if not iterating
+      if( !var_id.is_iter_fl )
+      {
+        var_id.sfx_id_count = 1;
+      }
+      else
+      {
+
+        proc_t* proc;
+
+        // find the var proc
+        if((proc = proc_find(net,proc_label,proc_label_sfx_id)) == nullptr )
+        {
+          rc = cwLogError(kEleNotFoundRC,"The proc '%s' could not be found for network preset '%s'.",cwStringNullGuard(proc_label),cwStringNullGuard(network_preset_label));
+          goto errLabel;
+        }
+                  
+        if( var_id.sfx_id_count == kInvalidCnt )
+          var_id.sfx_id_count = var_mult_count(proc, proc_label );
+      }
+      
+    errLabel:
+      return rc;
+      
+    }
+
+    rc_t _network_preset_get_class_preset( network_t& net, const char* network_preset_label, const char* proc_label,  const object_t* class_preset_label_cfg, const object_t*& class_preset_cfg_ref )
+    {
+      rc_t                  rc                 = kOkRC;
+      const char*           class_preset_label = nullptr;;
+      const class_preset_t* class_preset       = nullptr;
+      class_desc_t*         class_desc         = nullptr;
+      proc_t*               proc               = nullptr;
+
+      class_preset_cfg_ref = nullptr;
+      
+      // get the label of the proc class preset
+      if((rc = class_preset_label_cfg->value(class_preset_label)) != kOkRC )
+      {
+        rc = cwLogError(rc,"The preset label could not be parsed on the preset:'%s:%s'",cwStringNullGuard(network_preset_label),cwStringNullGuard(proc_label));
+        goto errLabel;
+      }
+
+      // locate the proc this preset will be applied to
+      if((proc = proc_find(net, proc_label, kBaseSfxId )) == nullptr )
+      {
+        rc = cwLogError(rc,"The proc '%s' could not be found for the preset:'%s'",cwStringNullGuard(proc_label),cwStringNullGuard(network_preset_label));
+        goto errLabel;
+      }
+      
+      // get the preset record for this proc/preset_label
+      if((class_preset = class_preset_find( proc->class_desc, class_preset_label )) == nullptr )
+      {
+        rc = cwLogError(rc,"The class description for proc '%s' could not be found for the preset:'%s'",cwStringNullGuard(proc_label),cwStringNullGuard(network_preset_label));
+        goto errLabel; 
+     }
+
+      class_preset_cfg_ref = class_preset->cfg;
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _network_preset_create_channel_value( network_t& net, network_preset_t& network_preset, proc_t* proc, variable_t* var, unsigned chN, const object_t* value_cfg )
+    {
+      rc_t            rc           = kOkRC;
+      unsigned        pairTblIdx   = kInvalidIdx;
+      preset_value_t* preset_value = mem::allocZ<preset_value_t>();
+
+      // cfg to value
+      if((rc = cfg_to_value( value_cfg, preset_value->value )) != kOkRC )
+      {
+        rc = cwLogError(rc,"The preset cfg to value conversion failed on '%s:%i'-'%s:%i'.",cwStringNullGuard(var->label),var->label_sfx_id,cwStringNullGuard(proc->label),proc->label_sfx_id);
+        goto errLabel;
+      }
+
+      // locate the the 
+      if((pairTblIdx = _network_preset_pair_find_index(net, var )) == kInvalidIdx )
+      {
+        rc = cwLogError(rc,"The preset pair record could not be found for '%s:%i'-'%s:%i'.",cwStringNullGuard(var->label),var->label_sfx_id,cwStringNullGuard(proc->label),proc->label_sfx_id);
+        goto errLabel;        
+      }
+
+      preset_value->proc       = proc;
+      preset_value->var        = var;
+      preset_value->chN        = chN;
+      preset_value->pairTblIdx = pairTblIdx;
+
+      if( network_preset.value_head == nullptr )
+        network_preset.value_head = preset_value;
+      else
+        network_preset.value_tail->link = preset_value;
+      
+      network_preset.value_tail = preset_value;
+
+    errLabel:
+      if(rc != kOkRC )
+        _preset_value_destroy(preset_value);
+      
+      return rc;
+    }
+
+    rc_t _network_preset_find_or_create_variable( proc_t* proc, const char* var_label, unsigned var_sfx_id, unsigned chIdx, const object_t* value_cfg, bool allow_create_fl, variable_t*& var_ref )
+    {
+      rc_t        rc  = kOkRC;
+      variable_t* var = nullptr;
+      var_ref         = nullptr;
+      
+      // if the var was not found on 'chIdx'
+      if((rc = var_find(proc, var_label, var_sfx_id, chIdx, var )) != kOkRC )
+      {
+
+        if( !allow_create_fl )
+        {
+          rc = cwLogError(kEleNotFoundRC,"The preset variable '%s:%i' ch:%i could not be found on proc: '%s:%i'.",
+                          cwStringNullGuard(var_label),var_sfx_id,chIdx, cwStringNullGuard(proc->label),proc->label_sfx_id );
+          goto errLabel;
+        }
+        else
+        {
+          variable_t* base_var                                             = nullptr;
+          // get the base var 
+          if((rc = var_find(proc, var_label, kBaseSfxId, kAnyChIdx, var)) != kOkRC )
+          {
+            rc = cwLogError(rc,"The base variable '%s:%i' ch:%i could not be found to pre-emptively create the variable '%s:%i' ch:%i on proc: '%s:%i'.",
+                            cwStringNullGuard(var_label),kBaseSfxId,kAnyChIdx,
+                            cwStringNullGuard(var_label),var_sfx_id,chIdx,
+                            cwStringNullGuard(proc->label),proc->label_sfx_id);
+            goto errLabel;
+          }
+
+          // create the variable
+          if((rc = var_create( proc, var_label, var_sfx_id, kInvalidId, chIdx, value_cfg, kInvalidTFl, var )) != kOkRC )
+          {
+            rc = cwLogError(rc,"Pre-emptive variable creation failed for '%s:%i' ch:%i on proc:'%s:%i'.",
+                            cwStringNullGuard(var_label),var_sfx_id,chIdx,
+                            cwStringNullGuard(proc->label),proc->label_sfx_id);
+            goto errLabel;
+          }
+        }        
+      }
+
+      var_ref = var;
+      
+    errLabel:
+      return rc;
+    }
+      
+    
+    rc_t _network_preset_create_value( network_t&        net,
+                                       network_preset_t& network_preset,
+                                       const char*       proc_label,
+                                       unsigned          proc_sfx_id,
+                                       const char*       var_label,
+                                       unsigned          var_sfx_id,
+                                       const object_t*   value_cfg )
+    {
+      rc_t        rc       = kOkRC;
+      var_desc_t* var_desc = nullptr;
+      proc_t*     proc     = nullptr;
+      
+      
+      // locate the proc this preset will be applied to
+      if((proc = proc_find(net, proc_label, proc_sfx_id )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"The proc '%s:%i' does not exist.",cwStringNullGuard(proc_label),proc_sfx_id);
+        goto errLabel;
+      }
+      else
+      {
+        bool is_var_cfg_type_fl = (var_desc = var_desc_find( proc->class_desc, var_label ))!=nullptr && cwIsFlag(var_desc->type,kCfgTFl);
+        bool is_list_fl         = value_cfg->is_list();
+        bool is_list_of_list_fl = is_list_fl && value_cfg->child_count() > 0 && value_cfg->child_ele(0)->is_list();
+        bool parse_list_fl      = (is_list_fl && !is_var_cfg_type_fl) || (is_list_of_list_fl && is_var_cfg_type_fl);
+
+        // Case 1: By default we assume a single variable instance on channel 'kAnyChIdx' ....
+        unsigned        valueN = 1;
+        unsigned        chIdx  = kAnyChIdx;
+        const object_t* vobj   = value_cfg;
+
+        // Case 2: ... however if a list of preset values was given and the var type is not a 'cfg' type or if a list of lists was given
+        // then we are going to iterate through a list of preset values each on a successive channel index
+        if( parse_list_fl )
+        {
+          chIdx  = 0;
+          valueN = value_cfg->child_count();
+          vobj   = value_cfg->child_ele(0);
+        }
+      
+        // Iterate over each channel
+        for(unsigned i = 0; i<valueN; ++i)
+        {
+          variable_t* var = nullptr;
+
+          // find the var referenced in the preset
+          if((rc = _network_preset_find_or_create_variable( proc, var_label, var_sfx_id, chIdx, vobj, false, var )) != kOkRC )
+            goto errLabel;
+
+          // create a 'preset_value_t' record and prepend it to 'network_preset.valueL'
+          if((rc = _network_preset_create_channel_value(net, network_preset, proc, var, valueN, vobj )) != kOkRC )
+            goto errLabel;
+          
+
+          // Case 2:
+          if( parse_list_fl )
+          {
+            chIdx += 1;
+            vobj   = value_cfg->child_ele(i);
+          }
+        }
+        //printf("%s %s:%i-%s:%i\n",network_preset.label,proc_label,proc_sfx_id,var_label,var_sfx_id);
+      }
+    errLabel:
+      
+      return rc;
+    }
+    
+    
+    rc_t _network_preset_parse( flow_t* p, network_t& net, const object_t* network_preset_dict_cfg, network_preset_t& network_preset )
+    {
+      rc_t rc = kOkRC;
+      unsigned procN = 0;
+      
+      if( network_preset_dict_cfg==nullptr || !network_preset_dict_cfg->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The proc preset dictionary is not a dictionary in network preset:'%s'.",cwStringNullGuard(network_preset.label));
+        goto errLabel;
+      }
+
+      procN = network_preset_dict_cfg->child_count();
+
+      // for each proc in the network preset
+      for(unsigned i=0; i<procN; ++i)
+      {
+        const object_t* var_dict         = nullptr;
+        const object_t* proc_preset_pair = network_preset_dict_cfg->child_ele(i);
+        const char*     proc_label       = nullptr;
+        io_ele_t        proc_id          = {};
+        unsigned        varN             = 0;
+
+        // validate the process preset syntax
+        if( proc_preset_pair==nullptr || !proc_preset_pair->is_pair() || (proc_label=proc_preset_pair->pair_label())==nullptr || proc_preset_pair->pair_value()==nullptr )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"A syntax error was encountered on a preset pair on preset '%s'.",cwStringNullGuard(network_preset.label));
+          goto errLabel;
+        }
+
+        // parse the proc label
+        if((rc= _parse_network_proc_label(net, network_preset, proc_label, proc_id )) != kOkRC )
+          goto errLabel;
+
+        // if the preset refers to a proc class preset
+        if( proc_preset_pair->pair_value()->is_string() )
+        {
+          // get the referenced preset cfg from the class desc
+          if((rc = _network_preset_get_class_preset( net, network_preset.label, proc_id.label,  proc_preset_pair->pair_value(), var_dict )) != kOkRC )
+            goto errLabel;
+        }
+        else // the preset is a dictionary of var/value pairs
+        {
+          // if preset is not a dictionary 
+          if( !proc_preset_pair->pair_value()->is_dict() )
+          {
+            rc = cwLogError(kSyntaxErrorRC,"The preset value dictionary for '%s:%s' is not valid.",cwStringNullGuard(network_preset.label),cwStringNullGuard(proc_id.label));
+            goto errLabel;
+          }
+
+          var_dict = proc_preset_pair->pair_value();
+        }
+
+        // var_dict now refers to a dictionary of var/value pairs for a single proc
+
+        varN = var_dict->child_count();
+
+        // for each proc/sf_id  (the proc label may refer to multiple proc instances)
+        for(unsigned j=0; j<proc_id.sfx_id_count; ++j)
+        {
+
+          // for each variable label:value pair
+          for(unsigned k=0; k<varN; ++k)
+          {
+            io_ele_t var_id = {};
+            const object_t* var_pair = var_dict->child_ele(k);
+            
+            // parse the preset var label
+            if((rc = _parse_network_proc_var_label(net, network_preset.label, var_pair, proc_id.label, proc_id.base_sfx_id + j, var_id )) != kOkRC )
+              goto errLabel;
+
+            // create a preset for each var:sfx_id pair (the var label may refer to multiple var instances) 
+            for(unsigned m=0; m<var_id.sfx_id_count; ++m)
+              if((rc = _network_preset_create_value( net, network_preset, proc_id.label, proc_id.base_sfx_id, var_id.label, var_id.base_sfx_id + m, var_pair->pair_value() )) != kOkRC )
+                goto errLabel;
+
+            mem::release(var_id.label);                
+          }          
+        }
+
+        mem::release(proc_id.label);
+      }
+      
+    errLabel:
+      return rc;
+    }
+    
+    
+    rc_t _network_preset_parse_top_level_dict( flow_t* p, network_t& net, const object_t* preset_cfg )
+    {
+      rc_t rc = kOkRC;
+      unsigned presetAllocN = 0;
+      
+      if( preset_cfg == nullptr )
+        return rc;
+      
+      if( !preset_cfg->is_dict() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The network preset list is not a dictionary.");
+        goto errLabel;
+      }
+
+      presetAllocN = preset_cfg->child_count();
+      net.presetA  = mem::allocZ<network_preset_t>(presetAllocN);
+      net.presetN  = 0;
+
+      // parse each preset_label pair
+      for(unsigned i=0; i<presetAllocN; ++i)
+      {
+        const object_t* preset_pair_cfg = preset_cfg->child_ele(i);
+        network_preset_t&  network_preset     = net.presetA[i];
+
+        // validate the network preset pair
+        if( preset_pair_cfg==nullptr || !preset_pair_cfg->is_pair() || (network_preset.label = preset_pair_cfg->pair_label())==nullptr || preset_pair_cfg->pair_value()==nullptr || !preset_pair_cfg->pair_value()->is_dict() )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Invalid syntax encountered on a network preset.");
+          goto errLabel;
+        }
+
+        // parse the dictionary of proc presets
+        if((rc = _network_preset_parse(p, net, preset_pair_cfg->pair_value(), network_preset)) != kOkRC )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"Network preset parse failed on preset:'%s'.",cwStringNullGuard(network_preset.label));
+          goto errLabel;
+          
+        }
+
+        net.presetN += 1;
+      }
+      
+    errLabel:
+      if(rc != kOkRC )
+      {
+        _network_preset_array_destroy(net);
+      }
+
+      return rc;
+    }
+
+
+    template<typename T0, typename T1 >
+    rc_t _preset_set_var_from_dual_interp_1( variable_t* var, T0 v0, T1 v1, double coeff )
+    {
+      return var_set(var, (T0)(v0 + (v1-v0)*coeff ));
+    }
+    
+    template< typename T >
+    rc_t _preset_set_var_from_dual_interp_0( variable_t* var,  T v0, const value_t* v1, double coeff )
+    {
+      rc_t rc = kOkRC;
+      switch( v1->tflag & kTypeMask )
+      {
+        case kUIntTFl:
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+          break;
+          
+        case kIntTFl:
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+          break;
+          
+        case kFloatTFl:
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+          break;
+          
+        case kDoubleTFl:
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+          break;
+          
+        default:
+          rc = cwLogError(kInvalidDataTypeRC,"The second operand of a set by interpolation had a non-numeric data type.");
+      }
+      return rc;
+    }
+
+  
+
+    rc_t _preset_set_var_from_dual( const preset_value_t* preset_val, const value_t* value_1, double coeff )
+    {
+      rc_t rc = kOkRC;
+      unsigned legalTypeMask = kUIntTFl | kIntTFl | kFloatTFl | kDoubleTFl;
+      
+      if( value_1 == nullptr || (preset_val->value.tflag & legalTypeMask)==0 )
+        rc = var_set( preset_val->var, &preset_val->value );
+      else
+      {
+        if( (value_1->tflag & legalTypeMask) == 0 )
+        {
+          rc = cwLogError(kInvalidDataTypeRC,"The type of value-1 (0x%x) is not a scalar number.",value_1->tflag);
+          goto errLabel;
+        }
+
+        switch( preset_val->value.tflag & legalTypeMask )
+        {
+          case kUIntTFl:
+            rc = _preset_set_var_from_dual_interp_0( preset_val->var, preset_val->value.u.u, value_1, coeff );
+            break;
+            
+          case kIntTFl:
+            rc = _preset_set_var_from_dual_interp_0( preset_val->var, preset_val->value.u.i, value_1, coeff );
+            break;
+            
+          case kFloatTFl:
+            rc = _preset_set_var_from_dual_interp_0( preset_val->var, preset_val->value.u.f, value_1, coeff );
+            break;
+            
+          case kDoubleTFl:
+            rc = _preset_set_var_from_dual_interp_0( preset_val->var, preset_val->value.u.d, value_1, coeff );
+            break;
+
+        default:
+          rc = cwLogError(kInvalidDataTypeRC,"The first operand of a set by interpolation had a non-numeric data type.");
+            
+        }
+      }
+
+    errLabel:
+      if(rc != kOkRC )
+        rc = cwLogError(rc,"Set variable from dual preset failed on '%s:%i'-'%s:%i' ch:0.",
+                        cwStringNullGuard(preset_val->proc->label),preset_val->proc->label_sfx_id,
+                        cwStringNullGuard(preset_val->var->label),preset_val->var->label_sfx_id,
+                        preset_val->var->chIdx);
+      return rc;
+    }
+
     
   }
 }
@@ -2460,6 +3045,12 @@ cw::rc_t cw::flow::network_create( flow_t*            p,
   }
 
   net.poly_cnt = polyCnt;
+
+
+  if((rc = _network_preset_pair_create_table(net)) != kOkRC )
+    goto errLabel;
+  
+  _network_preset_parse_top_level_dict(p, net, net.presetsCfg );
   
 errLabel:
   if( rc != kOkRC )
@@ -2535,7 +3126,104 @@ errLabel:
   return rc;
 }
 
+cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* preset_label, unsigned proc_label_sfx_id )
+{
+  rc_t                    rc             = kOkRC;
+  const network_preset_t* network_preset = nullptr;
+  const preset_value_t*   preset_value   = nullptr;
 
+  if((network_preset = network_preset_from_label(net, preset_label )) == nullptr )
+  {
+    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", preset_label );
+    goto errLabel;
+  }
+
+  for(preset_value=network_preset->value_head; preset_value!=nullptr; preset_value=preset_value->link)
+    if( preset_value->proc->label_sfx_id == proc_label_sfx_id )
+      if((rc = var_set( preset_value->var, &preset_value->value )) != kOkRC )
+      {
+        rc = cwLogError(rc,"Preset value apply failed on '%s:%i'-'%s:%i' in the network preset:'%s'.",
+                        cwStringNullGuard(preset_value->proc->label),preset_value->proc->label_sfx_id,
+                        cwStringNullGuard(preset_value->var->label),preset_value->var->label_sfx_id,
+                        cwStringNullGuard(preset_label));
+        goto errLabel;
+      }
+
+  cwLogInfo("Activated preset:%s",preset_label);
+
+errLabel:
+  return rc;
+ 
+}
+
+cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset_label_0, const char* preset_label_1, double coeff )
+{
+  rc_t                    rc      = kOkRC;
+  const network_preset_t* net_ps0 = nullptr;
+  const network_preset_t* net_ps1 = nullptr;
+  
+  if((net_ps0 = network_preset_from_label(net, preset_label_0 )) == nullptr )
+  {
+    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", preset_label_0 );
+    goto errLabel;
+  }
+
+  if((net_ps1 = network_preset_from_label(net, preset_label_1 )) == nullptr )
+  {
+    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", preset_label_1 );
+    goto errLabel;
+  }
+
+  // clear the value filed of the preset-pair array
+  for(unsigned i=0; i<net.preset_pairN; ++i)
+    net.preset_pairA[i].value = nullptr;
+
+  // set the value pointer in each of the preset-pair records referenced by preset-1
+  for(const preset_value_t* pv1=net_ps1->value_head; pv1!=nullptr; pv1=pv1->link)
+  {
+    if( pv1->var->chIdx != kAnyChIdx )
+      net.preset_pairA[ pv1->pairTblIdx ].value = &pv1->value;
+    else
+    {
+      for(unsigned i=0; i<net.preset_pairA[ pv1->pairTblIdx ].chN; ++i)
+      {
+        net.preset_pairA[ pv1->pairTblIdx+i ].value = &pv1->value;
+        assert( textIsEqual(net.preset_pairA[ pv1->pairTblIdx+i ].var->label,pv1->var->label) && net.preset_pairA[ pv1->pairTblIdx+i ].var->label_sfx_id == pv1->var->label_sfx_id );        
+      }
+    }    
+  }
+
+  // 
+  for(const preset_value_t* pv0=net_ps0->value_head; pv0!=nullptr; pv0=pv0->link)
+  {
+    if( pv0->var->chIdx != kAnyChIdx )
+    {
+      rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx ].value, coeff );
+    }
+    else
+    {
+      for(unsigned i=0; i<net.preset_pairA[ pv0->pairTblIdx ].chN; ++i)
+      {
+        if((rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx+i ].value, coeff )) != kOkRC )
+          goto errLabel;
+
+        assert( textIsEqual(net.preset_pairA[ pv0->pairTblIdx+i ].var->label,pv0->var->label) && net.preset_pairA[ pv0->pairTblIdx+i ].var->label_sfx_id == pv0->var->label_sfx_id );        
+      }
+    }    
+    
+  }
+
+errLabel:
+  if( rc != kOkRC )
+    rc = cwLogError(rc,"Apply dual-preset failed.");
+  
+  return rc;
+  
+}
+
+
+
+#ifdef NOT_DEF
 cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel, unsigned proc_label_sfx_id )
 {
   rc_t    rc = kOkRC;
@@ -2625,10 +3313,10 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
     const object_t* preset_pair_0      = net_preset_value_0->child_ele(i);
     const char*     proc_label         = preset_pair_0->pair_label(); 
     const object_t* preset_value_cfg_0 = preset_pair_0->pair_value();
-    proc_t*     proc               = nullptr;
+    proc_t*         proc               = nullptr;
     const object_t* preset_value_cfg_1 = nullptr;
-    const int two = 2;
-    const char* class_preset_labelA[two];
+    const int       two                = 2;
+    const char*     class_preset_labelA[two];
     
     // get the proc instance label/value pair
     if((preset_pair_0 = net_preset_value_0->child_ele(i)) == nullptr || !preset_pair_0->is_pair() )
@@ -2699,6 +3387,9 @@ errLabel:
   return rc;
 }
 
+#endif
+
+
 cw::rc_t cw::flow::network_apply_preset( network_t& net, const multi_preset_selector_t& mps )
 {
   rc_t        rc        = kOkRC;
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 8597ac7..866918e 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -1347,8 +1347,8 @@ void cw::flow::class_desc_destroy( class_desc_t* class_desc)
   }
 
   // release the preset list
-  preset_t* pr0 = class_desc->presetL;
-  preset_t* pr1 = nullptr;
+  class_preset_t* pr0 = class_desc->presetL;
+  class_preset_t* pr1 = nullptr;
   while( pr0 != nullptr )
   {
     pr1 = pr0->link;
@@ -1393,9 +1393,9 @@ cw::rc_t cw::flow::var_desc_find( class_desc_t* cd, const char* label, var_desc_
   return kOkRC;
 }
 
-const cw::flow::preset_t* cw::flow::class_preset_find( const class_desc_t* cd, const char* preset_label )
+const cw::flow::class_preset_t* cw::flow::class_preset_find( const class_desc_t* cd, const char* preset_label )
 {
-  const preset_t* pr;
+  const class_preset_t* pr;
   for(pr=cd->presetL; pr!=nullptr; pr=pr->link)
     if( textCompare(pr->label,preset_label) == 0 )
       return pr;
@@ -1430,6 +1430,71 @@ void cw::flow::network_print( const network_t& net )
     }
         
   }
+
+  if(net.presetN > 0 )
+  {
+    cwLogPrint("Presets:\n");
+    for(unsigned i=0; i<net.presetN; ++i)
+    {
+      const network_preset_t* net_preset = net.presetA + i;
+      cwLogPrint("%i %s\n",i,net_preset->label);
+      const preset_value_t* net_val = net_preset->value_head;
+      for(; net_val!=nullptr; net_val=net_val->link)
+      {
+        cwLogPrint("    %s:%i %s:%i ",cwStringNullGuard(net_val->proc->label),net_val->proc->label_sfx_id,cwStringNullGuard(net_val->var->label),net_val->var->label_sfx_id);
+        _value_print( &net_val->value );
+        cwLogPrint("\n");
+      }
+    }
+    cwLogPrint("\n");
+  }
+}
+
+const cw::flow::network_preset_t* cw::flow::network_preset_from_label( const network_t& net, const char* preset_label )
+{
+  const network_preset_t* net_preset;
+  for(unsigned i=0; i<net.presetN; ++i)
+    if( textIsEqual(net.presetA[i].label,preset_label))
+      return net.presetA + i;
+  return nullptr;
+}
+
+
+unsigned cw::flow::proc_mult_count( const network_t& net, const char* proc_label )
+{
+  unsigned multN = 0;
+  for(unsigned i=0; i<net.proc_arrayN; ++i)
+    if( textIsEqual(net.proc_array[i]->label,proc_label) )
+      multN += 1;
+
+  return multN;
+}
+    
+cw::rc_t cw::flow::proc_mult_sfx_id_array( const network_t& net, const char* proc_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref )
+{
+  rc_t     rc    = kOkRC;
+  unsigned multN = 0;
+
+  idN_ref = 0;
+  
+  for(unsigned i=0; i<net.proc_arrayN; ++i)
+    if( textIsEqual(net.proc_array[i]->label,proc_label) )
+    {
+      if( multN >= idAllocN )
+      {
+        rc = cwLogError(kBufTooSmallRC,"The mult-sfx-id result array is too small for the proc:'%s'.",cwStringNullGuard(proc_label));
+        goto errLabel;
+      }
+      
+      idA[multN] = net.proc_array[i]->label_sfx_id;
+      multN += 1;
+    }
+  
+  idN_ref = multN;
+
+errLabel:
+  
+  return kOkRC;  
 }
 
 void cw::flow::proc_destroy( proc_t* proc )
@@ -2162,6 +2227,71 @@ cw::rc_t  cw::flow::var_get( variable_t* var, mbuf_t*& valRef )
 cw::rc_t  cw::flow::var_get( const variable_t* var, const object_t*& valRef )
 { return _val_get_driver(var,valRef); }
 
+cw::rc_t cw::flow::cfg_to_value( const object_t* cfg, value_t& value_ref )
+{
+  rc_t rc = kOkRC;
+      
+  switch( cfg->type->id )
+  {
+    case kCharTId:  
+    case kUInt8TId:
+    case kUInt16TId:
+    case kUInt32TId:
+      value_ref.tflag = kUIntTFl;
+      if((rc = cfg->value(value_ref.u.u)) != kOkRC )
+        rc = cwLogError(rc,"Conversion to uint failed.");
+      break;
+          
+    case kInt8TId:
+    case kInt16TId:
+    case kInt32TId:
+      value_ref.tflag = kUIntTFl;
+      if((rc = cfg->value(value_ref.u.i)) != kOkRC )
+        rc = cwLogError(rc,"Conversion to int failed.");
+      break;
+          
+    case kInt64TId:
+    case kUInt64TId:
+      rc = cwLogError(kInvalidArgRC,"The flow system does not currently implement 64bit integers.");
+      goto errLabel;
+      break;
+          
+    case kFloatTId:
+      value_ref.tflag = kFloatTFl;
+      if((rc = cfg->value(value_ref.u.f)) != kOkRC )
+        rc = cwLogError(rc,"Conversion to float failed.");
+      break;
+          
+    case kDoubleTId:
+      value_ref.tflag = kDoubleTFl;
+      if((rc = cfg->value(value_ref.u.d)) != kOkRC )
+        rc = cwLogError(rc,"Conversion to double failed.");
+      break;
+          
+    case kBoolTId:
+      value_ref.tflag = kBoolTFl;
+      if((rc = cfg->value(value_ref.u.b)) != kOkRC )
+        rc = cwLogError(rc,"Conversion to bool failed.");
+      break;
+          
+    case kStringTId:
+    case kCStringTId:
+      value_ref.tflag = kStringTFl;
+      if((rc = cfg->value(value_ref.u.s)) != kOkRC )
+        rc = cwLogError(rc,"Conversion to string failed.");
+      break;
+          
+    default:
+      value_ref.tflag = kCfgTFl;
+      value_ref.u.cfg = cfg;
+        
+  }
+errLabel:
+
+  return rc;
+}
+    
+
 cw::rc_t cw::flow::var_set_from_preset( variable_t* var, const object_t* value )
 {
   rc_t rc = kOkRC;
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 9b79bd2..32b856a 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -164,19 +164,19 @@ namespace cw
       struct var_desc_str* link;    // class_desc->varDescL list link
     } var_desc_t;
 
-    typedef struct preset_str
+    typedef struct class_preset_str
     {
-      const char*        label;
-      const object_t*    cfg;
-      struct preset_str* link;
-    } preset_t;
+      const char*              label;
+      const object_t*          cfg;
+      struct class_preset_str* link;
+    } class_preset_t;
     
     typedef struct class_desc_str
     {
       const object_t*   cfg;        // class cfg 
       const char*       label;      // class label;      
       var_desc_t*       varDescL;   // varDescL variable description linked on var_desc_t.link
-      preset_t*         presetL;    // presetA[ presetN ]
+      class_preset_t*   presetL;    // presetA[ presetN ]
       class_members_t*  members;    // member functions for this class
       unsigned          polyLimitN; // max. poly copies of this class per network_t or 0 if no limit
     } class_desc_t;
@@ -220,26 +220,13 @@ namespace cw
 
     } variable_t;
 
-    
-    struct proc_str;
 
-    typedef struct network_str
-    {
-      const object_t*   procsCfg;   // network proc list
-      const object_t*   presetsCfg; // presets designed for this network
-      unsigned          poly_cnt;   // count of duplicated networks in the list
-      
-      struct proc_str** proc_array;
-      
-      unsigned          proc_arrayAllocN;
-      unsigned          proc_arrayN;
-      
-    } network_t;
+    struct network_str;
     
     typedef struct proc_str
     {
-      struct flow_str* ctx;          // global system context
-      network_t*       net;          // network which owns this proc
+      struct flow_str*    ctx;  // global system context
+      struct network_str* net;  // network which owns this proc
 
       class_desc_t*   class_desc;    //
       
@@ -260,11 +247,57 @@ namespace cw
       unsigned        varMapN;       // varMapN = varMapIdN * varMapChN 
       variable_t**    varMapA;       // varMapA[ varMapN ] = allows fast lookup from ('vid','chIdx) to variable
 
-      network_t*  internal_net;
+      struct network_str*  internal_net;
       
     } proc_t;
 
 
+    typedef struct preset_value_str
+    {
+      proc_t*                  proc;
+      variable_t*              var;
+      value_t                  value;
+      unsigned                 chN;        // count of channels specified by this preset
+      unsigned                 pairTblIdx; // index into the preset pair table for this preset value
+      struct preset_value_str* link;
+    } preset_value_t;
+    
+    typedef struct network_preset_str
+    {
+      const char*     label;
+      preset_value_t* value_head;  // List of preset_value_t for this preset. 
+      preset_value_t* value_tail;
+    } network_preset_t;
+
+    typedef struct network_preset_pair_str
+    {
+      const proc_t*     proc;
+      const variable_t* var;
+      unsigned          chIdx;
+      unsigned          chN;
+      const value_t*    value;
+    } network_preset_pair_t;
+
+    typedef struct network_str
+    {
+      const object_t*   procsCfg;   // network proc list
+      const object_t*   presetsCfg; // presets designed for this network
+      unsigned          poly_cnt;   // count of duplicated networks in the list
+      
+      struct proc_str** proc_array;
+      
+      unsigned          proc_arrayAllocN;
+      unsigned          proc_arrayN;
+
+      network_preset_t* presetA;
+      unsigned          presetN;
+
+      network_preset_pair_t* preset_pairA;
+      unsigned               preset_pairN;
+      
+    } network_t;
+    
+    
     typedef struct flow_str
     {
       const object_t*      flowCfg;     // complete cfg used to create this flow 
@@ -347,7 +380,7 @@ namespace cw
     const var_desc_t* var_desc_find( const class_desc_t* cd, const char* var_label );
     rc_t              var_desc_find(       class_desc_t* cd, const char* var_label, var_desc_t*& vdRef );
 
-    const preset_t*   class_preset_find( const class_desc_t* cd, const char* preset_label );
+    const class_preset_t*   class_preset_find( const class_desc_t* cd, const char* preset_label );
     
     void              class_dict_print( flow_t* p );
 
@@ -356,11 +389,18 @@ namespace cw
     //
     // Network
     //
-    void           network_print(const network_t& net );
+    void     network_print(const network_t& net );
 
+    const network_preset_t* network_preset_from_label( const network_t& net, const char* preset_label );
+    
+    unsigned proc_mult_count( const network_t& net, const char* proc_label );
+    
+    rc_t     proc_mult_sfx_id_array( const network_t& net, const char* proc_label, unsigned* idA, unsigned idAllocN, unsigned& idN_ref );
+        
+    
     //------------------------------------------------------------------------------------------------------------------------
     //
-    // Instance
+    // Proc
     //
 
     void               proc_destroy( proc_t* proc );
@@ -368,7 +408,7 @@ namespace cw
     
     proc_t*            proc_find( network_t& net, const char* proc_label, unsigned sfx_id );
     rc_t               proc_find( network_t& net, const char* proc_label, unsigned sfx_id, proc_t*& procPtrRef );
-    
+
     external_device_t* external_device_find( flow_t* p, const char* device_label, unsigned typeId, unsigned inOrOutFl, const char* midiPortLabel=nullptr );
 
     void               proc_print( proc_t* proc );
@@ -546,10 +586,12 @@ namespace cw
     rc_t           var_find(   proc_t* proc, unsigned vid,                           unsigned chIdx,       variable_t*& varRef );
 
     
-    // Count of numbered channels - does not count the kAnyChIdx variable procance.
+    // Count of numbered channels - does not count the kAnyChIdx variable instance.
     rc_t           var_channel_count( proc_t* proc, const char* label, unsigned sfx_idx, unsigned& chCntRef );
     rc_t           var_channel_count( const variable_t* var, unsigned& chCntRef );
-    
+
+    rc_t           cfg_to_value( const object_t* cfg, value_t& value_ref );
+
 
     //
     // var_get() coerces the value of the variable to the type of the returned value.

From 567660a60024c2c6f19a289a7312d30dfead871b Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sun, 19 May 2024 15:25:18 -0400
Subject: [PATCH 080/101] cwFlowTest.cpp : When a specific test is named and
 compare is set only that test is compared.

---
 cwFlowTest.cpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/cwFlowTest.cpp b/cwFlowTest.cpp
index 1e0dcaa..3678a19 100644
--- a/cwFlowTest.cpp
+++ b/cwFlowTest.cpp
@@ -28,7 +28,7 @@ namespace cw
       file::handle_t         logFileH;
     } exec_test_t;
 
-    rc_t _compare_dirs( const char* dir0, const char* dir1 )
+    rc_t _compare_dirs( const char* dir0, const char* dir1, const char* test_name )
     {
       rc_t                 rc          = kOkRC;
       rc_t                 testRC      = kOkRC;
@@ -49,7 +49,7 @@ namespace cw
 
       // for each test
       for(unsigned i=0; i<dirRefN; ++i)
-        if( dirRefA[i].name != nullptr )
+        if( dirRefA[i].name != nullptr && (test_name==nullptr || textIsEqual(dirRefA[i].name,test_name)) )
         {
           // form the test directory
           if(( testRefDir = filesys::makeFn( dir0, nullptr, nullptr, dirRefA[i].name, nullptr )) == nullptr )
@@ -215,12 +215,17 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
   const char*     proj_dir         = nullptr;
   const char*     test_ref_dir     = nullptr;
   bool            cmp_enable_fl    = false;
+  const char*     test_name        = nullptr;
+  bool            test_all_fl      = false;
 
   if( argc < 2 || textLength(argv[1]) == 0 )
   {
     rc = cwLogError(kInvalidArgRC,"No 'test-case' label was given on the command line.");
     goto errLabel;
   }
+
+  test_name   = argv[1];
+  test_all_fl = textIsEqual(test_name,"all");
   
   if((rc = cfg->getv("proc_cfg_fname",proc_cfg_fname,
                      "test_cases",    test_cases_cfg,
@@ -267,7 +272,6 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
   {
     const object_t* test_cfg_pair       = test_cases_cfg->child_ele(i);
     const char*     test_label          = nullptr;
-    bool            test_all_fl         = textIsEqual(argv[1],"all");
     bool            is_test_disabled_fl = false;
 
     // validate the test cfg pair
@@ -296,7 +300,7 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     }
 
     // if we are testing all test or this specific test
-    if( test_all_fl || textIsEqual(argv[1],test_label) )
+    if( test_all_fl || textIsEqual(test_name,test_label) )
     {
       if((rc = _exec_test(class_cfg,subnet_cfg,test_cfg,proj_dir,test_label)) != kOkRC )
       {
@@ -312,7 +316,8 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
   // if comparision is enabled
   if( test_ref_dir != nullptr && cmp_enable_fl )
   {
-    _compare_dirs( test_ref_dir, proj_dir );
+    const char* sel_test_name = test_all_fl ? nullptr : test_name;
+    _compare_dirs( test_ref_dir, proj_dir, sel_test_name );
   }
   
   

From 4e8f9e1eb7b40d3bc7bc48e0f518d7eda95e7fac Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sun, 19 May 2024 15:25:38 -0400
Subject: [PATCH 081/101] flow_doc.md  : Updates.

---
 flow/flow_doc.md | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 2dfb03b..0ef11ce 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -3,10 +3,27 @@
 
 # Flow Documentation:
 
-Flow is an audio processing framework that is designed to 
-facilitate the specification of real-time and non-real-time music 
+_flow_ is an experimental audio processing framework which supports 
+the execution of real-time and non-real-time music 
 and audio processing networks and the application of network state data. 
 
+The framework is designed to easily build a certain flavor of 
+audio processing network which is defined by the ability
+to arbitrarily and seemlessly update the state of the network in real-time.
+
+
+A _flow_ program is a data flow network formed from a collection of
+interconnected processing units.  A processing unit is referered
+to as a __proc__. Each processing unit has a function which 
+operates on a set of variables. The network is formed
+by connecting processors together via their variables.
+
+
+Fig. 1 shows a simple network non-real time network
+where the output of a sine oscillator is written to an audio file.
+
+
+
 
 
 

From 0c157999e5489cee436a93d0947e67567665d9a3 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sun, 19 May 2024 15:25:46 -0400
Subject: [PATCH 082/101] README.md : Updates

---
 README.md | 40 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 4fd7b4d..5c99126 100644
--- a/README.md
+++ b/README.md
@@ -953,6 +953,9 @@ This may be a good idea because 'kAnyChIdx' will in general not be used
 if a var has been channelized - and yet it is possible for another 
 var to connect to it as a source ... which doesn't provoke an error
 but would almost certainly not do what the user expects.
+Note that the kAnyChIdx provides an easy way to set all of the channels
+of a variable to the same value.
+
 
 - DONE: verifiy that all proc variables values have a valid type - (i.e. (type & typeMask) != 0)
   when the proc instance create is complete. This checks that both the type is assigned and
@@ -966,7 +969,7 @@ elements of the network should not be visible outside of it. Instead it should
 include the idea of input and output ports which act as proxies to the physical
 ports of the internal elements.
 
-- 'poly' and 'sub' should be arbitrarily nestable. DONE?
+- DONE: 'poly' and 'sub' should be arbitrarily nestable. 
 
 - Reduce runtime overhead for var get/set operations.
   
@@ -998,9 +1001,12 @@ Next:
 	+ write a paragraph in the flow_doc.md about overall approach taken to subnet implementation.
 	  Subnets are implemented in the following phases:
 	  - During program initialization the subnet cfg files is scanned and the
-	  proxy vars for each subnet are used to create `class_desc_t` records for each subnet.
+	  proxy vars for each subnet are used to create a `class_desc_t` record for each subnet.
 	  - When the subnet is instantiated the proxy vars are instantiated first.
 	  - Then the internal network is instantiated.
+	  - The proxy var's are then connected to the proxied vars. This may require
+	  connecting in either direction: proxy->proxied or proxied->proxy, with the later
+	  case being indicated by an 'out' attribute in proxied 'flags' list.
 
 	+ DONE: subnet var desc's should be the same as non+subnet vars but also include the 'proxy' field.
 	In particular they should get default values.
@@ -1064,3 +1070,33 @@ Consider:
    e.g. `lfo: { class:sine_tone, in:{ osc_.dc:list.value_ } }` 
 
 - DONE: Fix up the coding language - change the use of `instance_t` to `proc_t` and `inst` to `proc`, change use of `ctx` in cwFlowProc
+
+
+
+
+
+Prior to executing the custom constructor the values are assigned to the 
+variables as follows:
+1. Default value as defined by the class are applied when the variable is created.
+2. The proc instance 'preset' class preset is applied.
+3. The proc instance 'args' values are applied.
+
+During this stage of processing preset values may be given for
+variables that do not yet exist. This will commonly occur when a
+variable has multiple channels that will not be created until the
+custom constructor is run.  For these cases the variable will be
+pre-emptively created and the preset value will be applied.  
+
+This approach has the advantage of communicating network information
+to the proc constructor from the network configuration - thereby
+allowing the network programmer to influence the configuration of the
+proc. instance.
+
+
+DONE: After the network is fully instantiated the network and class presets
+are compiled.  At this point all preset values must be resolvable to
+an actual proc variable.  A warning is issued for presets with values
+that cannot be resolved and they are disabled.  The primary reason
+that a preset might not be resolvable is by targetting a variable
+channel that does not exist.
+

From 06099e83a2887c24235a8d3475f9adb839e3b2fc Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Tue, 21 May 2024 15:34:46 -0400
Subject: [PATCH 083/101] cwObject.h : Added type_id().

---
 cwObject.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cwObject.h b/cwObject.h
index 494b17c..4585ee6 100644
--- a/cwObject.h
+++ b/cwObject.h
@@ -135,6 +135,8 @@ namespace cw
     // Value containers are parents of leaf nodes. (A dictionary is not a value container because it's children are pairs with are not leaf nodes.)
     inline bool is_value_container() const { return type != nullptr && cwIsFlag(type->flags,kValueContainerFl); }
 
+    inline unsigned type_id() const { return type==nullptr ? (unsigned)kInvalidTId : type->id; }
+
     // Containers have children and use the object.u.children pointer.
     inline bool is_container() const { return type != nullptr && cwIsFlag(type->flags,kContainerFl); }
     inline bool is_pair()      const { return type != nullptr && type->id == kPairTId; }

From cfe4883f3e4eb46f6451328e76675d72370b102a Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Tue, 21 May 2024 18:53:11 -0400
Subject: [PATCH 084/101] cwFlowNet,cwFlowType,cwFlowProc : Initial working and
 tested version of new preset compile and apply scheme.

---
 cwFlowNet.cpp   | 292 ++++++++++++++++++++++++++++++++++--------------
 cwFlowProc.cpp  |   6 +
 cwFlowTypes.cpp |  23 +++-
 cwFlowTypes.h   |  50 ++++++---
 4 files changed, 270 insertions(+), 101 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index bae0a56..a4652f8 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -30,16 +30,19 @@ namespace cw
     
     void _network_preset_destroy(network_preset_t& network_preset)
     {
-      preset_value_t* pv = network_preset.value_head;
-      while( pv != nullptr )
+      if( network_preset.tid == kPresetVListTId )
       {
-        preset_value_t* pv0 = pv->link;
-        _preset_value_destroy(pv);
-        pv = pv0;
-      }
+        preset_value_t* pv = network_preset.u.vlist.value_head;
+        while( pv != nullptr )
+        {
+          preset_value_t* pv0 = pv->link;
+          _preset_value_destroy(pv);
+          pv = pv0;
+        }
       
-      network_preset.value_head = nullptr;
-      network_preset.value_tail = nullptr;
+        network_preset.u.vlist.value_head = nullptr;
+        network_preset.u.vlist.value_tail = nullptr;
+      }
       
     }
     
@@ -2443,7 +2446,7 @@ namespace cw
       if((rc = _network_preset_pair_count(net, pair_count  )) != kOkRC )
         goto errLabel;
       
-      // allocate the preset pair tble
+      // allocate the preset pair table
       net.preset_pairA = mem::allocZ<network_preset_pair_t>(pair_count);
       net.preset_pairN = pair_count;
 
@@ -2506,7 +2509,7 @@ namespace cw
       else
       {
         if( proc_id.sfx_id_count == kInvalidCnt )
-          proc_id.sfx_id_count = proc_mult_count(net, proc_label );
+          proc_id.sfx_id_count = proc_mult_count(net, proc_id.label );
       }
 
     errLabel:
@@ -2553,7 +2556,7 @@ namespace cw
         }
                   
         if( var_id.sfx_id_count == kInvalidCnt )
-          var_id.sfx_id_count = var_mult_count(proc, proc_label );
+          var_id.sfx_id_count = var_mult_count(proc, var_id.label );
       }
       
     errLabel:
@@ -2620,15 +2623,14 @@ namespace cw
 
       preset_value->proc       = proc;
       preset_value->var        = var;
-      preset_value->chN        = chN;
       preset_value->pairTblIdx = pairTblIdx;
 
-      if( network_preset.value_head == nullptr )
-        network_preset.value_head = preset_value;
+      if( network_preset.u.vlist.value_head == nullptr )
+        network_preset.u.vlist.value_head = preset_value;
       else
-        network_preset.value_tail->link = preset_value;
+        network_preset.u.vlist.value_tail->link = preset_value;
       
-      network_preset.value_tail = preset_value;
+      network_preset.u.vlist.value_tail = preset_value;
 
     errLabel:
       if(rc != kOkRC )
@@ -2751,9 +2753,76 @@ namespace cw
       
       return rc;
     }
+
+    rc_t _network_preset_parse_dual_label(network_t& net, const object_t* list_cfg, unsigned idx, const char* pri_sec_label, const char* network_preset_label, const network_preset_t*& vlist_ref )
+    {
+      rc_t rc = kOkRC;
+      const char* preset_label = nullptr;
+      const preset_value_list_t* vlist = nullptr;
+
+      vlist_ref = nullptr;
+      
+      if( !list_cfg->child_ele(idx)->is_string() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The dual preset list %s preset is not a string on network preset:'%s'.",pri_sec_label,cwStringNullGuard(network_preset_label));
+        goto errLabel;
+      }
+
+      if((rc = list_cfg->child_ele(idx)->value(preset_label)) != kOkRC )
+      {
+        rc = cwLogError(kOpFailRC,"The dual preset %s preset could not be parsed on network preset:'%s'.",pri_sec_label,cwStringNullGuard(network_preset_label));
+        goto errLabel;
+      }
+
+      if((vlist_ref = network_preset_from_label(net, preset_label )) == nullptr )
+      {
+        rc = cwLogError(kEleNotFoundRC,"The dual preset %s preset could not be found on network preset:'%s'.",pri_sec_label,cwStringNullGuard(network_preset_label));
+        goto errLabel;
+      }
+
+    errLabel:
+      return rc;
+    }
     
+    rc_t _network_preset_parse_dual(flow_t* p, network_t& net, const object_t* dual_list_cfg, network_preset_t& network_preset )
+    {
+      rc_t rc = kOkRC;
+
+
+      if( dual_list_cfg==nullptr || !dual_list_cfg->is_list() )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The dual preset specification is not a list on network preset:'%s'.",cwStringNullGuard(network_preset.label));
+        goto errLabel;
+      }
+
+      if( dual_list_cfg->child_count() != 3 )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The dual preset list does not have 3 elements on network preset:'%s'.",cwStringNullGuard(network_preset.label));
+        goto errLabel;
+      }
+
+      if((rc = _network_preset_parse_dual_label(net,dual_list_cfg, 0, "primary", network_preset.label, network_preset.u.dual.pri )) != kOkRC )
+        goto errLabel;
+      
+
+      if((rc = _network_preset_parse_dual_label(net,dual_list_cfg, 1, "secondary", network_preset.label, network_preset.u.dual.sec )) != kOkRC )
+        goto errLabel;
+        
+      
+      if((rc = dual_list_cfg->child_ele(2)->value(network_preset.u.dual.coeff)) != kOkRC )
+      {
+        rc = cwLogError(kSyntaxErrorRC,"The dual preset coeff could not be parsed on network preset:'%s'.",cwStringNullGuard(network_preset.label));
+        goto errLabel;
+      }
+      
+      network_preset.tid = kPresetDualTId;
+
+
+    errLabel:
+      return rc;
+    }
     
-    rc_t _network_preset_parse( flow_t* p, network_t& net, const object_t* network_preset_dict_cfg, network_preset_t& network_preset )
+    rc_t _network_preset_parse_value_list( flow_t* p, network_t& net, const object_t* network_preset_dict_cfg, network_preset_t& network_preset )
     {
       rc_t rc = kOkRC;
       unsigned procN = 0;
@@ -2764,6 +2833,8 @@ namespace cw
         goto errLabel;
       }
 
+      network_preset.tid = kPresetVListTId;
+      
       procN = network_preset_dict_cfg->child_count();
 
       // for each proc in the network preset
@@ -2818,14 +2889,15 @@ namespace cw
           {
             io_ele_t var_id = {};
             const object_t* var_pair = var_dict->child_ele(k);
+            unsigned proc_label_sfx_id = proc_id.base_sfx_id + j;
             
             // parse the preset var label
-            if((rc = _parse_network_proc_var_label(net, network_preset.label, var_pair, proc_id.label, proc_id.base_sfx_id + j, var_id )) != kOkRC )
+            if((rc = _parse_network_proc_var_label(net, network_preset.label, var_pair, proc_id.label, proc_label_sfx_id, var_id )) != kOkRC )
               goto errLabel;
 
             // create a preset for each var:sfx_id pair (the var label may refer to multiple var instances) 
             for(unsigned m=0; m<var_id.sfx_id_count; ++m)
-              if((rc = _network_preset_create_value( net, network_preset, proc_id.label, proc_id.base_sfx_id, var_id.label, var_id.base_sfx_id + m, var_pair->pair_value() )) != kOkRC )
+              if((rc = _network_preset_create_value( net, network_preset, proc_id.label, proc_label_sfx_id, var_id.label, var_id.base_sfx_id + m, var_pair->pair_value() )) != kOkRC )
                 goto errLabel;
 
             mem::release(var_id.label);                
@@ -2865,20 +2937,36 @@ namespace cw
         network_preset_t&  network_preset     = net.presetA[i];
 
         // validate the network preset pair
-        if( preset_pair_cfg==nullptr || !preset_pair_cfg->is_pair() || (network_preset.label = preset_pair_cfg->pair_label())==nullptr || preset_pair_cfg->pair_value()==nullptr || !preset_pair_cfg->pair_value()->is_dict() )
+        if( preset_pair_cfg==nullptr || !preset_pair_cfg->is_pair() || (network_preset.label = preset_pair_cfg->pair_label())==nullptr || preset_pair_cfg->pair_value()==nullptr )
         {
           rc = cwLogError(kSyntaxErrorRC,"Invalid syntax encountered on a network preset.");
           goto errLabel;
         }
 
-        // parse the dictionary of proc presets
-        if((rc = _network_preset_parse(p, net, preset_pair_cfg->pair_value(), network_preset)) != kOkRC )
+        switch( preset_pair_cfg->pair_value()->type_id() )
         {
-          rc = cwLogError(kSyntaxErrorRC,"Network preset parse failed on preset:'%s'.",cwStringNullGuard(network_preset.label));
-          goto errLabel;
-          
+          case kDictTId: // 'value-list' preset
+            if((rc = _network_preset_parse_value_list(p, net, preset_pair_cfg->pair_value(), network_preset)) != kOkRC )
+            {
+              rc = cwLogError(kSyntaxErrorRC,"Network value-list preset parse failed on preset:'%s'.",cwStringNullGuard(network_preset.label));
+              goto errLabel;            
+            }
+            break;
+
+          case kListTId: // dual preset
+            if((rc = _network_preset_parse_dual(p, net, preset_pair_cfg->pair_value(), network_preset)) != kOkRC )
+            {
+              rc = cwLogError(kSyntaxErrorRC,"Network dual preset parse failed on preset:'%s'.",cwStringNullGuard(network_preset.label));
+              goto errLabel;              
+            }
+            break;
+
+          default:
+            rc = cwLogError(kAssertFailRC,"Unknown preset type on network preset: '%s'.",cwStringNullGuard(network_preset.label));
+            goto errLabel;
         }
 
+        
         net.presetN += 1;
       }
       
@@ -2909,15 +2997,15 @@ namespace cw
           break;
           
         case kIntTFl:
-          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.i,coeff);
           break;
           
         case kFloatTFl:
-          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.f,coeff);
           break;
           
-        case kDoubleTFl:
-          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.u,coeff);
+        case kDoubleTFl:          
+          rc = _preset_set_var_from_dual_interp_1(var,v0,v1->u.d,coeff);
           break;
           
         default:
@@ -2976,6 +3064,75 @@ namespace cw
       return rc;
     }
 
+
+    rc_t _network_apply_preset( network_t& net,  const preset_value_list_t* vlist, unsigned proc_label_sfx_id )
+    {
+      rc_t                  rc           = kOkRC;
+      const preset_value_t* preset_value = nullptr;
+
+      for(preset_value=vlist->value_head; preset_value!=nullptr; preset_value=preset_value->link)
+      {
+        if( preset_value->proc->label_sfx_id == proc_label_sfx_id )
+          if((rc = var_set( preset_value->var, &preset_value->value )) != kOkRC )
+          {
+            rc = cwLogError(rc,"Preset value apply failed on '%s:%i'-'%s:%i'.",
+                            cwStringNullGuard(preset_value->proc->label),preset_value->proc->label_sfx_id,
+                            cwStringNullGuard(preset_value->var->label),preset_value->var->label_sfx_id);
+            goto errLabel;
+          }
+      }
+      
+    errLabel:      
+      return rc;
+    }
+    
+    rc_t _network_apply_dual_preset( network_t& net,  const network_preset_t* net_ps0, const network_preset_t* net_ps1, double coeff )
+    {
+      rc_t rc = kOkRC;
+      
+      // clear the value field of the preset-pair array
+      for(unsigned i=0; i<net.preset_pairN; ++i)
+        net.preset_pairA[i].value = nullptr;
+
+      // set the value pointer in each of the preset-pair records referenced by preset-1
+      for(const preset_value_t* pv1=net_ps1->u.vlist.value_head; pv1!=nullptr; pv1=pv1->link)
+      {
+        if( pv1->var->chIdx != kAnyChIdx )
+          net.preset_pairA[ pv1->pairTblIdx ].value = &pv1->value;
+        else
+        {
+          for(unsigned i=0; i<net.preset_pairA[ pv1->pairTblIdx ].chN; ++i)
+          {
+            net.preset_pairA[ pv1->pairTblIdx+i ].value = &pv1->value;
+            assert( textIsEqual(net.preset_pairA[ pv1->pairTblIdx+i ].var->label,pv1->var->label) && net.preset_pairA[ pv1->pairTblIdx+i ].var->label_sfx_id == pv1->var->label_sfx_id );        
+          }
+        }    
+      }
+
+      // 
+      for(const preset_value_t* pv0=net_ps0->u.vlist.value_head; pv0!=nullptr; pv0=pv0->link)
+      {
+        if( pv0->var->chIdx != kAnyChIdx )
+        {
+          rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx ].value, coeff );
+        }
+        else
+        {
+          for(unsigned i=0; i<net.preset_pairA[ pv0->pairTblIdx ].chN; ++i)
+          {
+            if((rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx+i ].value, coeff )) != kOkRC )
+              goto errLabel;
+
+            assert( textIsEqual(net.preset_pairA[ pv0->pairTblIdx+i ].var->label,pv0->var->label) && net.preset_pairA[ pv0->pairTblIdx+i ].var->label_sfx_id == pv0->var->label_sfx_id );        
+          }
+        }    
+    
+      }
+
+    errLabel:
+      return rc;
+    }
+    
     
   }
 }
@@ -3130,32 +3287,41 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* preset_labe
 {
   rc_t                    rc             = kOkRC;
   const network_preset_t* network_preset = nullptr;
-  const preset_value_t*   preset_value   = nullptr;
 
   if((network_preset = network_preset_from_label(net, preset_label )) == nullptr )
   {
-    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", preset_label );
+    rc = cwLogError(kInvalidIdRC,"The network preset '%s' could not be found.", cwStringNullGuard(preset_label) );
     goto errLabel;
   }
 
-  for(preset_value=network_preset->value_head; preset_value!=nullptr; preset_value=preset_value->link)
-    if( preset_value->proc->label_sfx_id == proc_label_sfx_id )
-      if((rc = var_set( preset_value->var, &preset_value->value )) != kOkRC )
-      {
-        rc = cwLogError(rc,"Preset value apply failed on '%s:%i'-'%s:%i' in the network preset:'%s'.",
-                        cwStringNullGuard(preset_value->proc->label),preset_value->proc->label_sfx_id,
-                        cwStringNullGuard(preset_value->var->label),preset_value->var->label_sfx_id,
-                        cwStringNullGuard(preset_label));
+  switch( network_preset->tid )
+  {
+    case kPresetVListTId:
+      if((rc = _network_apply_preset( net, &network_preset->u.vlist, proc_label_sfx_id )) != kOkRC )
         goto errLabel;
-      }
-
+      break;
+      
+    case kPresetDualTId:
+      if((rc = _network_apply_dual_preset(net,  network_preset->u.dual.pri, network_preset->u.dual.sec, network_preset->u.dual.coeff )) != kOkRC )
+        goto errLabel;
+      break;
+      
+    default:
+      rc = cwLogError(kAssertFailRC,"Unknown preset type.");
+      break;
+  }
+  
   cwLogInfo("Activated preset:%s",preset_label);
 
 errLabel:
+  if(rc != kOkRC )
+    rc = cwLogError(rc,"The network application '%s' failed.", cwStringNullGuard(preset_label) );
+     
   return rc;
  
 }
 
+
 cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset_label_0, const char* preset_label_1, double coeff )
 {
   rc_t                    rc      = kOkRC;
@@ -3174,55 +3340,17 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
     goto errLabel;
   }
 
-  // clear the value filed of the preset-pair array
-  for(unsigned i=0; i<net.preset_pairN; ++i)
-    net.preset_pairA[i].value = nullptr;
-
-  // set the value pointer in each of the preset-pair records referenced by preset-1
-  for(const preset_value_t* pv1=net_ps1->value_head; pv1!=nullptr; pv1=pv1->link)
-  {
-    if( pv1->var->chIdx != kAnyChIdx )
-      net.preset_pairA[ pv1->pairTblIdx ].value = &pv1->value;
-    else
-    {
-      for(unsigned i=0; i<net.preset_pairA[ pv1->pairTblIdx ].chN; ++i)
-      {
-        net.preset_pairA[ pv1->pairTblIdx+i ].value = &pv1->value;
-        assert( textIsEqual(net.preset_pairA[ pv1->pairTblIdx+i ].var->label,pv1->var->label) && net.preset_pairA[ pv1->pairTblIdx+i ].var->label_sfx_id == pv1->var->label_sfx_id );        
-      }
-    }    
-  }
-
-  // 
-  for(const preset_value_t* pv0=net_ps0->value_head; pv0!=nullptr; pv0=pv0->link)
-  {
-    if( pv0->var->chIdx != kAnyChIdx )
-    {
-      rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx ].value, coeff );
-    }
-    else
-    {
-      for(unsigned i=0; i<net.preset_pairA[ pv0->pairTblIdx ].chN; ++i)
-      {
-        if((rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx+i ].value, coeff )) != kOkRC )
-          goto errLabel;
-
-        assert( textIsEqual(net.preset_pairA[ pv0->pairTblIdx+i ].var->label,pv0->var->label) && net.preset_pairA[ pv0->pairTblIdx+i ].var->label_sfx_id == pv0->var->label_sfx_id );        
-      }
-    }    
-    
-  }
+  if((rc = _network_apply_dual_preset(net,  net_ps0, net_ps1, coeff )) != kOkRC )
+    goto errLabel;
 
 errLabel:
   if( rc != kOkRC )
-    rc = cwLogError(rc,"Apply dual-preset failed.");
+    rc = cwLogError(rc,"Apply dual-preset failed.");  
   
   return rc;
-  
 }
 
 
-
 #ifdef NOT_DEF
 cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* presetLabel, unsigned proc_label_sfx_id )
 {
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 8c53fbc..da36c87 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -3549,6 +3549,12 @@ namespace cw
           p->netA[i].net.proc_array       = mem::allocZ<proc_t*>(p->netA[i].net.proc_arrayAllocN);
           p->netA[i].net.presetsCfg       = p->net_proc->internal_net->presetsCfg;
 
+          p->netA[i].net.presetA          = p->net_proc->internal_net->presetA;
+          p->netA[i].net.presetN          = p->net_proc->internal_net->presetN;
+          
+          p->netA[i].net.preset_pairA     = p->net_proc->internal_net->preset_pairA;
+          p->netA[i].net.preset_pairN     = p->net_proc->internal_net->preset_pairN;
+
           for(unsigned j=0,k=0; j<p->net_proc->internal_net->proc_arrayN; ++j)
             if( p->net_proc->internal_net->proc_array[j]->label_sfx_id == i )
             {
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 866918e..d710d24 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -1438,12 +1438,23 @@ void cw::flow::network_print( const network_t& net )
     {
       const network_preset_t* net_preset = net.presetA + i;
       cwLogPrint("%i %s\n",i,net_preset->label);
-      const preset_value_t* net_val = net_preset->value_head;
-      for(; net_val!=nullptr; net_val=net_val->link)
+      switch( net_preset->tid )
       {
-        cwLogPrint("    %s:%i %s:%i ",cwStringNullGuard(net_val->proc->label),net_val->proc->label_sfx_id,cwStringNullGuard(net_val->var->label),net_val->var->label_sfx_id);
-        _value_print( &net_val->value );
-        cwLogPrint("\n");
+        case kPresetVListTId:
+          {
+            const preset_value_t* net_val = net_preset->u.vlist.value_head;
+            for(; net_val!=nullptr; net_val=net_val->link)
+            {
+              cwLogPrint("    %s:%i %s:%i ",cwStringNullGuard(net_val->proc->label),net_val->proc->label_sfx_id,cwStringNullGuard(net_val->var->label),net_val->var->label_sfx_id);
+              _value_print( &net_val->value );
+              cwLogPrint("\n");
+            }
+          }
+          break;
+          
+        case kPresetDualTId:
+          cwLogPrint("     %s %s %f",net_preset->u.dual.pri->label,net_preset->u.dual.sec->label,net_preset->u.dual.coeff);
+          break;
       }
     }
     cwLogPrint("\n");
@@ -2245,7 +2256,7 @@ cw::rc_t cw::flow::cfg_to_value( const object_t* cfg, value_t& value_ref )
     case kInt8TId:
     case kInt16TId:
     case kInt32TId:
-      value_ref.tflag = kUIntTFl;
+      value_ref.tflag = kIntTFl;
       if((rc = cfg->value(value_ref.u.i)) != kOkRC )
         rc = cwLogError(rc,"Conversion to int failed.");
       break;
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 32b856a..53cfac1 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -254,28 +254,52 @@ namespace cw
 
     typedef struct preset_value_str
     {
-      proc_t*                  proc;
-      variable_t*              var;
-      value_t                  value;
-      unsigned                 chN;        // count of channels specified by this preset
-      unsigned                 pairTblIdx; // index into the preset pair table for this preset value
+      proc_t*                  proc;       // proc target for this preset value
+      variable_t*              var;        // var target for this preset value
+      value_t                  value;      // Preset value.
+      //unsigned                 chN;        // Count of channels specified by this preset
+      unsigned                 pairTblIdx; // Index into the preset pair table for this preset value
       struct preset_value_str* link;
     } preset_value_t;
+
+    typedef struct preset_value_list_str
+    {
+      preset_value_t* value_head;  // List of preset_value_t for this preset. 
+      preset_value_t* value_tail;  // Last preset value in the list.
+    } preset_value_list_t;
+
+    struct network_preset_str;
+
+    typedef struct dual_preset_str
+    {
+      const struct network_preset_str* pri;
+      const struct network_preset_str* sec;
+      double      coeff;
+    } dual_preset_t;
+
+    typedef enum {
+      kPresetVListTId,
+      kPresetDualTId
+    } preset_type_id_t;
     
     typedef struct network_preset_str
     {
-      const char*     label;
-      preset_value_t* value_head;  // List of preset_value_t for this preset. 
-      preset_value_t* value_tail;
+      const char*     label;       // Preset label
+      preset_type_id_t tid;
+      
+      union {
+        preset_value_list_t vlist;
+        dual_preset_t       dual;
+      } u;
     } network_preset_t;
 
     typedef struct network_preset_pair_str
     {
-      const proc_t*     proc;
-      const variable_t* var;
-      unsigned          chIdx;
-      unsigned          chN;
-      const value_t*    value;
+      const proc_t*     proc;   //
+      const variable_t* var;    //
+      unsigned          chIdx;  // 
+      unsigned          chN;    //
+      const value_t*    value;  //
     } network_preset_pair_t;
 
     typedef struct network_str

From 7e2c18afa9945970eb8ac37c5725935c3c7ab75a Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Tue, 21 May 2024 18:53:21 -0400
Subject: [PATCH 085/101] flow_doc.md : Updates

---
 flow/flow_doc.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index 0ef11ce..f9e0922 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -266,3 +266,32 @@ variables based on the number of input audio channels cannot know how many outpu
 it may need until it accesses the number of audio channels it has been instantiated with.
 
 
+
+# Applying Dual Presets
+
+- When the network is instantiated the 'network-preset-pair' table is created.
+This table has an entry for every proc/variable/channel instance in the network.
+
+- When the preset preset-value lists are created the associated 'pair'
+record is found in the 'network-preset-pair' table and stored in the preset-value
+`pairTblIdx` field.
+
+To apply a dual preset.
+1. The preset-value list for the two presets are located.
+
+2. The network-preset-pair value field is set to NULL.
+
+3. The value associated with every preset-value in the secondary preset
+is assigned to the associated 'value' field in the preset-pair-table.
+The preset-pair record is found via a fast lookup using the `pairTblIdx` field.
+
+4. For every preset-value in the primary preset-value list the matching
+entry is found in the preset-pair-table. This is done via a fast lookup
+using the `pairTblIdx` field.
+
+5. If the preset-pair record value field is non-NULL then the primary preset-value's 
+value field is then interpolated with the preset-pair record value field 
+the associated network variable is set.
+
+6. If the preset-pair record value field is NULL then the primary preset-value
+is used to set the associated network variable.

From 9ef50bf081a41f245b4f4de733a48cf6ecf7bcd9 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 23 May 2024 09:32:24 -0400
Subject: [PATCH 086/101] cwFlowNet.cpp : The proc instance desc. now have only
 a single 'args' record rather than named records inside of args.  The
 'args_label' field was therefore removed.

---
 cwFlowNet.cpp | 41 +++--------------------------------------
 1 file changed, 3 insertions(+), 38 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index a4652f8..a7214de 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -785,7 +785,6 @@ namespace cw
       char*           proc_label;        //
       unsigned        proc_label_sfx_id; //
       const char*     proc_clas_label;   //
-      const char*     arg_label;         //
       const object_t* preset_labels;     //
       const object_t* arg_cfg;           //
       const object_t* log_labels;        //
@@ -1861,18 +1860,6 @@ namespace cw
       return false;
     }
     
-    rc_t _proc_inst_args_channelize_vars( proc_t* proc, const char* arg_label, const object_t* arg_cfg )
-    {
-      rc_t rc = kOkRC;
-      
-      if( arg_cfg == nullptr )
-        return rc;
-
-      return _preset_channelize_vars( proc, "proc instance", arg_label, arg_cfg );
-      
-    }
-
-    
     rc_t  _var_map_id_to_index(  proc_t* proc, unsigned vid, unsigned chIdx, unsigned& idxRef );
 
     rc_t _proc_create_var_map( proc_t* proc )
@@ -2126,7 +2113,6 @@ namespace cw
       if((rc = proc_inst_cfg->pair_value()->getv_opt("args",     arg_dict,
                                                      "in",       pstate.in_dict_cfg,
                                                      "out",      pstate.out_dict_cfg,
-                                                     "argLabel", pstate.arg_label,
                                                      "preset",   pstate.preset_labels,
                                                      "log",      pstate.log_labels )) != kOkRC )
       {
@@ -2145,29 +2131,10 @@ namespace cw
           cwLogError(kSyntaxErrorRC,"The proc instance argument dictionary on proc instance '%s:%i' is not a dictionary.",pstate.proc_label,pstate.proc_label_sfx_id);
           goto errLabel;
         }
-        
-        // if no label was given then try 'default'
-        if( pstate.arg_label == nullptr)
-        {
-          pstate.arg_label = "default";
-          rptErrFl = false;
-        }
 
-        // locate the specified argument record
-        if((pstate.arg_cfg = arg_dict->find_child(pstate.arg_label)) == nullptr )
-        {
 
-          // if an explicit arg. label was given but it was not found
-          if( rptErrFl )
-          {
-            rc = cwLogError(kSyntaxErrorRC,"The argument cfg. '%s' was not found on proc instance cfg. '%s:%i'.",pstate.arg_label,pstate.proc_label,pstate.proc_label_sfx_id);
-            goto errLabel;
-          }
+        pstate.arg_cfg = arg_dict;
 
-          // no explicit arg. label was given - make arg_dict the proc instance arg cfg.
-          pstate.arg_cfg = arg_dict;
-          pstate.arg_label = nullptr;
-        }        
       }
 
     errLabel:
@@ -2238,7 +2205,6 @@ namespace cw
       proc->label         = mem::duplStr(pstate.proc_label);
       proc->label_sfx_id  = pstate.proc_label_sfx_id;
       proc->proc_cfg      = proc_inst_cfg->pair_value();
-      proc->arg_label     = pstate.arg_label;
       proc->arg_cfg       = pstate.arg_cfg;
       proc->class_desc    = class_desc;
       proc->net           = &net;
@@ -2282,7 +2248,7 @@ namespace cw
       // Apply the proc inst instance 'args:{}' values.
       if( pstate.arg_cfg != nullptr )
       {
-        if((rc = _proc_inst_args_channelize_vars( proc, pstate.arg_label, pstate.arg_cfg )) != kOkRC )
+        if((rc = _preset_channelize_vars( proc, "proc instance", "args", pstate.arg_cfg )) != kOkRC )
           goto errLabel;
       }
       
@@ -3233,8 +3199,7 @@ const cw::object_t* cw::flow::find_network_preset( const network_t& net, const c
       cwLogError(rc,"Search for network preset named '%s' failed.", cwStringNullGuard(presetLabel));
   }
 
-  return preset_value;
-      
+  return preset_value;     
 }
 
 cw::rc_t cw::flow::exec_cycle( network_t& net )

From 760ab68d4f5b326df9ab9988c75023c03824e869 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Thu, 23 May 2024 09:32:33 -0400
Subject: [PATCH 087/101] README.md : Updates

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 5c99126..3c30e8e 100644
--- a/README.md
+++ b/README.md
@@ -1073,8 +1073,6 @@ Consider:
 
 
 
-
-
 Prior to executing the custom constructor the values are assigned to the 
 variables as follows:
 1. Default value as defined by the class are applied when the variable is created.
@@ -1100,3 +1098,6 @@ that cannot be resolved and they are disabled.  The primary reason
 that a preset might not be resolvable is by targetting a variable
 channel that does not exist.
 
+
+
+- All cfg to value conversion should go through `cfg_to_value()`.

From d1ba6f76d708fe377afb053ed26bc12a3146a227 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:36:43 -0400
Subject: [PATCH 088/101] cwFlowNet : network_apply_???_presets() now all
 optionally use 'proc_label_sfx_id'

---
 cwFlowNet.cpp | 68 ++++++++++++++++++++++++++-------------------------
 cwFlowNet.h   |  7 +++---
 2 files changed, 39 insertions(+), 36 deletions(-)

diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index a7214de..a1b4223 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -90,7 +90,7 @@ namespace cw
       {
         bool is_var_cfg_type_fl = (vd = var_desc_find( proc->class_desc, var_label ))!=nullptr && cwIsFlag(vd->type,kCfgTFl);
         bool is_list_fl         = value->is_list();
-        bool is_list_of_list_fl = is_list_fl && value->child_count() > 0 && value->child_ele(0)->is_list();
+        bool is_list_of_list_fl = is_list_fl && value->child_count() > 0 && value->child_ele(0)->is_container();
         bool parse_list_fl      = (is_list_fl && !is_var_cfg_type_fl) || (is_list_of_list_fl && is_var_cfg_type_fl);
 
         // if a list of values was given and the var type is not a 'cfg' type or if a list of lists was given
@@ -2209,7 +2209,7 @@ namespace cw
       proc->class_desc    = class_desc;
       proc->net           = &net;
 
-      // parse the in-list ,fill in pstate.in_array, and create var proc instances for var's referenced by in-list
+      // parse the in-list ,fill in pstate.in_array, and create var instances for var's referenced by in-list
       if((rc = _in_stmt_parse_in_list( net, proc, proxyVarL, pstate )) != kOkRC )
       {
         rc = cwLogError(rc,"in-list parse failed on proc inst instance '%s:%i'.",cwStringNullGuard(proc->label),pstate.proc_label_sfx_id);
@@ -3038,7 +3038,7 @@ namespace cw
 
       for(preset_value=vlist->value_head; preset_value!=nullptr; preset_value=preset_value->link)
       {
-        if( preset_value->proc->label_sfx_id == proc_label_sfx_id )
+        if( proc_label_sfx_id==kInvalidId || preset_value->proc->label_sfx_id == proc_label_sfx_id )
           if((rc = var_set( preset_value->var, &preset_value->value )) != kOkRC )
           {
             rc = cwLogError(rc,"Preset value apply failed on '%s:%i'-'%s:%i'.",
@@ -3052,7 +3052,7 @@ namespace cw
       return rc;
     }
     
-    rc_t _network_apply_dual_preset( network_t& net,  const network_preset_t* net_ps0, const network_preset_t* net_ps1, double coeff )
+    rc_t _network_apply_dual_preset( network_t& net, const network_preset_t* net_ps0, const network_preset_t* net_ps1, double coeff,  unsigned proc_label_sfx_id )
     {
       rc_t rc = kOkRC;
       
@@ -3062,36 +3062,38 @@ namespace cw
 
       // set the value pointer in each of the preset-pair records referenced by preset-1
       for(const preset_value_t* pv1=net_ps1->u.vlist.value_head; pv1!=nullptr; pv1=pv1->link)
-      {
-        if( pv1->var->chIdx != kAnyChIdx )
-          net.preset_pairA[ pv1->pairTblIdx ].value = &pv1->value;
-        else
+        if( proc_label_sfx_id == kInvalidId || pv1->proc->label_sfx_id == proc_label_sfx_id )
         {
-          for(unsigned i=0; i<net.preset_pairA[ pv1->pairTblIdx ].chN; ++i)
+          if( pv1->var->chIdx != kAnyChIdx )
+            net.preset_pairA[ pv1->pairTblIdx ].value = &pv1->value;
+          else
           {
-            net.preset_pairA[ pv1->pairTblIdx+i ].value = &pv1->value;
-            assert( textIsEqual(net.preset_pairA[ pv1->pairTblIdx+i ].var->label,pv1->var->label) && net.preset_pairA[ pv1->pairTblIdx+i ].var->label_sfx_id == pv1->var->label_sfx_id );        
-          }
-        }    
-      }
+            for(unsigned i=0; i<net.preset_pairA[ pv1->pairTblIdx ].chN; ++i)
+            {
+              net.preset_pairA[ pv1->pairTblIdx+i ].value = &pv1->value;
+              assert( textIsEqual(net.preset_pairA[ pv1->pairTblIdx+i ].var->label,pv1->var->label) && net.preset_pairA[ pv1->pairTblIdx+i ].var->label_sfx_id == pv1->var->label_sfx_id );        
+            }
+          }    
+        }
 
       // 
       for(const preset_value_t* pv0=net_ps0->u.vlist.value_head; pv0!=nullptr; pv0=pv0->link)
-      {
-        if( pv0->var->chIdx != kAnyChIdx )
+        if( proc_label_sfx_id == kInvalidId || pv0->proc->label_sfx_id == proc_label_sfx_id )
         {
-          rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx ].value, coeff );
-        }
-        else
-        {
-          for(unsigned i=0; i<net.preset_pairA[ pv0->pairTblIdx ].chN; ++i)
+          if( pv0->var->chIdx != kAnyChIdx )
           {
-            if((rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx+i ].value, coeff )) != kOkRC )
-              goto errLabel;
-
-            assert( textIsEqual(net.preset_pairA[ pv0->pairTblIdx+i ].var->label,pv0->var->label) && net.preset_pairA[ pv0->pairTblIdx+i ].var->label_sfx_id == pv0->var->label_sfx_id );        
+            rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx ].value, coeff );
           }
-        }    
+          else
+          {
+            for(unsigned i=0; i<net.preset_pairA[ pv0->pairTblIdx ].chN; ++i)
+            {
+              if((rc = _preset_set_var_from_dual( pv0, net.preset_pairA[ pv0->pairTblIdx+i ].value, coeff )) != kOkRC )
+                goto errLabel;
+
+              assert( textIsEqual(net.preset_pairA[ pv0->pairTblIdx+i ].var->label,pv0->var->label) && net.preset_pairA[ pv0->pairTblIdx+i ].var->label_sfx_id == pv0->var->label_sfx_id );        
+            }
+          }    
     
       }
 
@@ -3267,7 +3269,7 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const char* preset_labe
       break;
       
     case kPresetDualTId:
-      if((rc = _network_apply_dual_preset(net,  network_preset->u.dual.pri, network_preset->u.dual.sec, network_preset->u.dual.coeff )) != kOkRC )
+      if((rc = _network_apply_dual_preset(net, network_preset->u.dual.pri, network_preset->u.dual.sec, network_preset->u.dual.coeff,  proc_label_sfx_id )) != kOkRC )
         goto errLabel;
       break;
       
@@ -3287,7 +3289,7 @@ errLabel:
 }
 
 
-cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset_label_0, const char* preset_label_1, double coeff )
+cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset_label_0, const char* preset_label_1, double coeff, unsigned proc_label_sfx_id )
 {
   rc_t                    rc      = kOkRC;
   const network_preset_t* net_ps0 = nullptr;
@@ -3305,7 +3307,7 @@ cw::rc_t cw::flow::network_apply_dual_preset( network_t& net, const char* preset
     goto errLabel;
   }
 
-  if((rc = _network_apply_dual_preset(net,  net_ps0, net_ps1, coeff )) != kOkRC )
+  if((rc = _network_apply_dual_preset(net, net_ps0, net_ps1, coeff,  proc_label_sfx_id )) != kOkRC )
     goto errLabel;
 
 errLabel:
@@ -3483,7 +3485,7 @@ errLabel:
 #endif
 
 
-cw::rc_t cw::flow::network_apply_preset( network_t& net, const multi_preset_selector_t& mps )
+cw::rc_t cw::flow::network_apply_preset( network_t& net, const multi_preset_selector_t& mps, unsigned proc_label_sfx_id )
 {
   rc_t        rc        = kOkRC;
   const char* label0    = nullptr;
@@ -3544,7 +3546,7 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const multi_preset_sele
       assert( pri_sel_idx <= 1 );
       label1  = mps.presetA[ pri_sel_idx == 0 ? 1 : 0 ].preset_label;
     }
-    else                        // at least two remaining presets exist to select between
+    else  // at least two remaining presets exist to select between
     {
       // mark the selected primary preset as not-available
       bool selA[ mps.presetN ];
@@ -3574,12 +3576,12 @@ cw::rc_t cw::flow::network_apply_preset( network_t& net, const multi_preset_sele
   
   if( label1 == nullptr )
   {
-    rc = network_apply_preset( net, label0 );
+    rc = network_apply_preset( net, label0, proc_label_sfx_id );
   }
   else
   {
     double coeff = _calc_multi_preset_dual_coeff(mps);
-    rc = network_apply_dual_preset( net, label0, label1, coeff );
+    rc = network_apply_dual_preset( net, label0, label1, coeff, proc_label_sfx_id );
   }
   
 
diff --git a/cwFlowNet.h b/cwFlowNet.h
index ca8cf60..f469e1d 100644
--- a/cwFlowNet.h
+++ b/cwFlowNet.h
@@ -74,9 +74,10 @@ namespace cw
     // 'proc_label_sfx_id' is the proc label_sfx_id to be used to identify all proc's which will
     // be updated by the preset application. This is used to identify the set of procs to be updated
     // for 'poly' networks.
-    rc_t network_apply_preset( network_t& net, const char* presetLabel, unsigned proc_label_sfx_id=kBaseSfxId );
-    rc_t network_apply_dual_preset( network_t& net, const char* presetLabel_0, const char* presetLabel_1, double coeff );      
-    rc_t network_apply_preset( network_t& net, const multi_preset_selector_t& mps );
+    // If 'proc_label_sfx_id' is set to 'kInvalidId' then the preset will be applied to all proc's.
+    rc_t network_apply_preset( network_t& net, const char* presetLabel, unsigned proc_label_sfx_id=kInvalidId );
+    rc_t network_apply_dual_preset( network_t& net, const char* presetLabel_0, const char* presetLabel_1, double coeff, unsigned proc_label_sfx_id=kInvalidId );      
+    rc_t network_apply_preset( network_t& net, const multi_preset_selector_t& mps, unsigned proc_label_sfx_id=kInvalidId );
     
     
   }

From 973b1bdd3208b768658ba6f763ccaffe3dea46b7 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:37:31 -0400
Subject: [PATCH 089/101] cwFlow.cpp : Added the system parameter 'preset' to
 apply a network preset prior to network runtime.

---
 cwFlow.cpp | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/cwFlow.cpp b/cwFlow.cpp
index 884ade0..a67bb5d 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -62,6 +62,7 @@ namespace cw
       { "list",            &list::members },
       { "add",             &add::members },
       { "preset",          &preset::members },
+      { "print",           &print::members },
       { nullptr, nullptr }
     };
 
@@ -714,13 +715,14 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   
   // parse the optional args
   if((rc = flowCfg->getv_opt("framesPerCycle",      p->framesPerCycle,
-                            "sample_rate",          p->sample_rate,
-                            "maxCycleCount",        maxCycleCount,
-                            "multiPriPresetProbFl", p->multiPriPresetProbFl,
-                            "multiSecPresetProbFl", p->multiSecPresetProbFl,
-                            "multiPresetInterpFl",  p->multiPresetInterpFl,
-                            "printClassDictFl",     printClassDictFl,
-                            "printNetworkFl",       printNetworkFl)) != kOkRC )
+                             "sample_rate",          p->sample_rate,
+                             "maxCycleCount",        maxCycleCount,
+                             "preset",               p->init_net_preset_label,
+                             "multiPriPresetProbFl", p->multiPriPresetProbFl,
+                             "multiSecPresetProbFl", p->multiSecPresetProbFl,
+                             "multiPresetInterpFl",  p->multiPresetInterpFl,
+                             "printClassDictFl",     printClassDictFl,
+                             "printNetworkFl",       printNetworkFl)) != kOkRC )
   {
     rc = cwLogError(kSyntaxErrorRC,"Error parsing the optional flow configuration parameters.");
     goto errLabel;
@@ -756,7 +758,12 @@ cw::rc_t cw::flow::create( handle_t&          hRef,
   if( printNetworkFl )
     network_print(p->net);
 
+  if( p->init_net_preset_label != nullptr )
+    network_apply_preset( p->net, p->init_net_preset_label );
+  
   p->isInRuntimeFl = true;
+  cwLogInfo("Entering runtime.");
+
   hRef.set(p);
   
  errLabel:
@@ -832,6 +839,7 @@ cw::rc_t cw::flow::exec(    handle_t h )
   return rc;
 }
 
+
 cw::rc_t cw::flow::apply_preset( handle_t h, const char* presetLabel )
 {
   flow_t* p  = _handleToPtr(h);

From b79318a983f3b967fe668e959eefb70dd04921ca Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:39:16 -0400
Subject: [PATCH 090/101] cwFlowProc : Added the 'print' proc. Small changes to
 'number' and 'add' to prevent incorrect extra outputs.

---
 cwFlowProc.cpp | 239 +++++++++++++++++++++++++++++++++++++------------
 cwFlowProc.h   |   1 +
 2 files changed, 182 insertions(+), 58 deletions(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index da36c87..41d6d59 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -4106,7 +4106,7 @@ namespace cw
       rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
       {
         // skip the 'stored' value sent through prior to runtime.
-        if( var->vid == kStorePId && proc->ctx->isInRuntimeFl)
+        if( var->vid == kStorePId /*&& proc->ctx->isInRuntimeFl*/)
           p->store_fl = true;
         
         return kOkRC;
@@ -4123,9 +4123,10 @@ namespace cw
           // Note that we set the 'value' directly from var->value so that
           // no extra type converersion is applied. In this case the value
           // 'store'  will be coerced to the type of 'value'
-          if((rc = var_find(proc, kStorePId, kAnyChIdx, var )) == kOkRC && var->value != nullptr )
+          if((rc = var_find(proc, kStorePId, kAnyChIdx, var )) == kOkRC && var->value != nullptr && is_connected_to_source(var) )
+          {
             rc = var_set(proc,kValuePId,kAnyChIdx,var->value);
-
+          }
           p->store_fl = false;
         }
         
@@ -4145,59 +4146,6 @@ namespace cw
       
     }    
 
-    /*
-    namespace number
-    {
-      enum {
-        kValuePId,
-        kStorePId,
-      };
-      
-
-
-      rc_t create( proc_t* proc )
-      {
-        rc_t        rc    = kOkRC;        
-        
-        if((rc  = var_register(proc,kAnyChIdx,
-                               kValuePId,"value",kBaseSfxId,
-                               kStorePId,"store",kBaseSfxId)) != kOkRC )
-        {
-          goto errLabel;
-        }
-
-      errLabel:
-        return rc;
-      }
-
-      rc_t destroy( proc_t* proc )
-      {
-        rc_t rc = kOkRC;
-        return rc;
-      }
-
-      rc_t value( proc_t* proc, variable_t* var )
-      {
-        rc_t rc = kOkRC;
-        return rc;
-      }
-
-      rc_t exec( proc_t* proc )
-      {
-        rc_t rc      = kOkRC;
-        return rc;
-      }
-
-      class_members_t members = {
-        .create = create,
-        .destroy = destroy,
-        .value   = value,
-        .exec = exec,
-        .report = nullptr
-      };
-      
-    }    
-    */
     
     //------------------------------------------------------------------------------------------------------------------
     //
@@ -5116,8 +5064,11 @@ namespace cw
       {
         rc_t rc = kOkRC;
         inst_t* p = (inst_t*)(proc->userPtr);
-        
-        if( kInPId <= var->vid && var->vid < kInPId+p->inN )
+
+        // The check for 'isInRuntimeFl' prevents the adder from issuing an output
+        // on cycle 0 - otherwise the delta flag will be set by the adder
+        // receiving pre-runtime messages.
+        if( kInPId <= var->vid && var->vid < kInPId+p->inN && proc->ctx->isInRuntimeFl )
           p->delta_fl = true;
         
         return rc;
@@ -5259,6 +5210,178 @@ namespace cw
       
     }    
 
+    //------------------------------------------------------------------------------------------------------------------
+    //
+    // Print
+    //
+    namespace print
+    {
+      enum {
+        kTextPId,
+        kBaseInPId
+      };
+
+      typedef struct
+      {
+        unsigned     eolPId;
+        unsigned     inVarN;
+        const char** labelA;
+        unsigned     labelN;
+      } inst_t;
+
+      rc_t _parse_label_array( proc_t* proc, inst_t* p )
+      {
+        rc_t rc = kOkRC;
+        const object_t* textListCfg = nullptr;
+        unsigned textListN = 0;
+        
+        // get the text list
+        if((rc = var_get(proc,kTextPId,kAnyChIdx,textListCfg)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        if(( textListN = textListCfg->child_count()) != p->labelN )
+        {
+          cwLogWarning("The count of labels does in print proc '%s' does not match the count of inputs plus one. %i != %i",proc->label,textListN,textListCfg->child_count());          
+        }
+
+        // for each string in the list
+        for(unsigned i=0; i<textListN && i<p->labelN; ++i)
+        {
+          const object_t* textCfg = textListCfg->child_ele(i);
+          
+          if( textCfg==nullptr || !textCfg->is_string() )
+            rc = cwLogError(kSyntaxErrorRC,"The print proc '%s' text list must be a list of strings.",proc->label);
+
+          if((rc = textCfg->value(p->labelA[i])) != kOkRC )
+            rc = cwLogError(kSyntaxErrorRC,"The print proc '%s' text label at index could not be read.");
+        }
+
+        // fill in any unspecified labels with blank strings
+        for(unsigned i=textListN; i<p->labelN; ++i)
+          p->labelA[i] = "";
+
+      errLabel:
+        return rc;
+      }
+      
+      
+      rc_t _print_field( proc_t* proc, inst_t* p, unsigned field_idx, const value_t* value )
+      {
+        if( field_idx >= p->inVarN )
+        {
+          assert( p->labelA[p->labelN-1] != nullptr );
+          cwLogPrint("%s\n",p->labelA[p->labelN-1]);          
+        }
+        else
+        {
+          assert( field_idx<p->labelN && p->labelA[field_idx] != nullptr );
+          cwLogPrint("%s ",p->labelA[field_idx]);
+          value_print(value);
+        }
+
+        return kOkRC;
+      }
+
+      rc_t _create( proc_t* proc, inst_t* p )
+      {
+        rc_t     rc           = kOkRC;        
+        unsigned inVarN       = var_mult_count(proc, "in" );
+        unsigned inVarSfxIdA[ inVarN ];
+
+        if((rc = var_register(proc,kAnyChIdx,kTextPId,"text",kBaseSfxId)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+    
+        if((rc = var_mult_sfx_id_array(proc, "in", inVarSfxIdA, inVarN, p->inVarN )) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        for(unsigned i=0; i<p->inVarN; ++i)
+        {
+          if((rc = var_register(proc,kAnyChIdx,kBaseInPId+i,"in",inVarSfxIdA[i])) != kOkRC )
+          {
+            goto errLabel;
+          }
+        }
+        
+        // There must be one label for each input plus an end of line label
+        p->labelN = p->inVarN+1;
+        p->labelA = mem::allocZ<const char*>( p->labelN );
+        p->eolPId = kBaseInPId + p->inVarN;
+
+        // Register the eol_fl with the highest variable id - so that it is called last during the later stage
+        // of proc initialization where the value() function is called for each variable.
+        // This way the EOL message will occur after all the 'in' values have been printed.
+        if((rc = var_register(proc,kAnyChIdx,p->eolPId,"eol_fl",kBaseSfxId)) != kOkRC )
+        {
+          goto errLabel;
+        }
+
+        for(unsigned i=0; i<p->labelN; ++i)
+          p->labelA[i] = "";
+
+        rc = _parse_label_array(proc,p);
+        
+      errLabel:
+
+        return rc;
+      }
+
+      rc_t _destroy( proc_t* proc, inst_t* p )
+      {
+        mem::release(p->labelA);
+        p->labelN=0;
+        p->inVarN=0;
+        return kOkRC;
+      }
+
+      rc_t _value( proc_t* proc, inst_t* p, variable_t* var )
+      {
+        switch( var->vid )
+        {
+            
+          case kTextPId:
+            _parse_label_array(proc,p);            
+            break;
+            
+          default:
+            //printf("[%i %i] ",proc->ctx->cycleIndex,var->vid);
+
+            if( var->vid == p->eolPId )
+              _print_field(proc,p,p->inVarN,nullptr);
+            else
+            {
+              if( kBaseInPId <= var->vid && var->vid <= kBaseInPId + p->inVarN )
+              {
+                _print_field(proc,p,var->vid - kBaseInPId,var->value);
+              }
+            }
+        }
+
+        // always report success - don't let print() interrupt the network
+        return kOkRC;
+      }
+
+      rc_t _exec( proc_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      rc_t _report( proc_t* proc, inst_t* p )
+      { return kOkRC; }
+
+      class_members_t members = {
+        .create  = std_create<inst_t>,
+        .destroy = std_destroy<inst_t>,
+        .value   = std_value<inst_t>,
+        .exec    = std_exec<inst_t>,
+        .report  = std_report<inst_t>
+      };
+      
+    }    
     
   } // flow
 } // cw
diff --git a/cwFlowProc.h b/cwFlowProc.h
index daaff15..9d30f49 100644
--- a/cwFlowProc.h
+++ b/cwFlowProc.h
@@ -35,6 +35,7 @@ namespace cw
     namespace list            { extern class_members_t members;  }
     namespace add             { extern class_members_t members;  }
     namespace preset          { extern class_members_t members;  }
+    namespace print           { extern class_members_t members;  }
     
   }
 }

From d90a3c31da71d2410ec341d5b88b046cd1c4abd4 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:41:42 -0400
Subject: [PATCH 091/101] cwFlowTypes : Added value_print() and made extra info
 print optional on _value_print(). The current exec. cycle index is now
 printed out with all 'log' lines.

---
 cwFlowTypes.cpp | 245 ++++++++++++++++++++----------------------------
 cwFlowTypes.h   |  21 +++--
 2 files changed, 119 insertions(+), 147 deletions(-)

diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index d710d24..024a752 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -189,7 +189,7 @@ namespace cw
 
     }
     
-    void _value_print( const value_t* v )
+    void _value_print( const value_t* v, bool info_fl=true )
     {
       if( v == nullptr )
         return;
@@ -199,35 +199,84 @@ namespace cw
         case kInvalidTFl:
           break;
           
-        case kBoolTFl:  cwLogPrint("b:%s ", v->u.b ? "true" : "false" ); break;          
-        case kUIntTFl:  cwLogPrint("u:%i ", v->u.u ); break;
-        case kIntTFl:   cwLogPrint("i:%i ", v->u.i ); break;          
-        case kFloatTFl: cwLogPrint("f:%f ", v->u.f ); break;
-        case kDoubleTFl:cwLogPrint("d:%f ", v->u.d ); break;
+        case kBoolTFl:
+          
+          cwLogPrint("%s%s ", info_fl ? "b:" : "", v->u.b ? "true" : "false" );
+          break;
+          
+        case kUIntTFl:
+          cwLogPrint("%s%i ", info_fl ? "u:" : "", v->u.u );
+          break;
+          
+        case kIntTFl:
+          cwLogPrint("%s%i ", info_fl ? "i:" : "", v->u.i );
+          break;
+          
+        case kFloatTFl:
+          cwLogPrint("%s%f ", info_fl ? "f:" : "", v->u.f );
+          break;
+          
+        case kDoubleTFl:
+          cwLogPrint("%s%f ", info_fl ? "d:" : "", v->u.d );
+          break;
+          
         case kABufTFl:
-          if( v->u.abuf == nullptr )
-            cwLogPrint("abuf: <null>");
+          if( info_fl )
+          {
+            if( v->u.abuf == nullptr )
+              cwLogPrint("abuf: <null>");
+            else
+              cwLogPrint("abuf: chN:%i frameN:%i srate:%8.1f ", v->u.abuf->chN, v->u.abuf->frameN, v->u.abuf->srate );
+          }
           else
-            cwLogPrint("abuf: chN:%i frameN:%i srate:%8.1f ", v->u.abuf->chN, v->u.abuf->frameN, v->u.abuf->srate ); 
+          {
+            bool null_fl = v->u.abuf==nullptr || v->u.abuf->buf == nullptr;
+            cwLogPrint("(");
+            for(unsigned i=0; i<v->u.abuf->chN; ++i)
+              cwLogPrint("%f ",null_fl ? 0.0 : vop::rms(v->u.abuf->buf + i*v->u.abuf->frameN, v->u.abuf->frameN));
+            cwLogPrint(") ");
+          }
           break;
           
         case kFBufTFl:
-          if( v->u.fbuf == nullptr )
-            cwLogPrint("fbuf: <null>");
+          if( info_fl )
+          {
+            if( v->u.fbuf == nullptr )
+              cwLogPrint("fbuf: <null>");
+            else
+            {
+              cwLogPrint("fbuf: chN:%i srate:%8.1f ", v->u.fbuf->chN, v->u.fbuf->srate );
+              for(unsigned i=0; i<v->u.fbuf->chN; ++i)                
+                cwLogPrint("(binN:%i hopSmpN:%i) ", v->u.fbuf->binN_V[i], v->u.fbuf->hopSmpN_V[i] );
+            }
+          }
           else
           {
-            cwLogPrint("fbuf: chN:%i srate:%8.1f ", v->u.fbuf->chN, v->u.fbuf->srate );
-            for(unsigned i=0; i<v->u.fbuf->chN; ++i)
-              cwLogPrint("(binN:%i hopSmpN:%i) ", v->u.fbuf->binN_V[i], v->u.fbuf->hopSmpN_V[i] );
+            
+            bool null_fl = v->u.fbuf==nullptr || v->u.fbuf->magV == nullptr;
+            cwLogPrint("(");
+            for(unsigned i=0,N=0; i<v->u.fbuf->chN; ++i)
+              cwLogPrint("%f ",null_fl ? 0.0 : vop::mean(v->u.fbuf->magV[i], v->u.fbuf->binN_V[i]));
+            cwLogPrint(") ");
+            
           }
           break;
 
         case kMBufTFl:
-          if( v->u.mbuf == nullptr )
-            cwLogPrint("mbuf: <null>");
+          if( info_fl )
+          {
+            if( v->u.mbuf == nullptr )
+              cwLogPrint("mbuf: <null>");
+            else
+            {
+              cwLogPrint("mbuf: cnt: %i", v->u.mbuf->msgN );
+            }
+          }
           else
           {
-            cwLogPrint("mbuf: cnt: %i", v->u.mbuf->msgN );
+            bool null_fl = v->u.mbuf==nullptr || v->u.mbuf->msgA == nullptr;
+            for(unsigned i=0; i<v->u.mbuf->msgN; ++i)
+              cwLogPrint("(0x%x 0x%x 0x%x) ",v->u.mbuf->msgA[i].status + v->u.mbuf->msgA[i].ch,v->u.mbuf->msgA[i].d0,v->u.mbuf->msgA[i].d1);
           }
           break;
           
@@ -258,7 +307,7 @@ namespace cw
       }
 
     }
-    
+
 
     rc_t _val_get( const value_t* val, bool& valRef )
     {
@@ -1077,11 +1126,22 @@ namespace cw
       
       // if value_cfg is valid set the variable value
       if( value_cfg != nullptr && cwIsNotFlag(vd->type,kRuntimeTFl))
-        if((rc = var_set_from_preset( var, value_cfg )) != kOkRC )
+        if((rc = var_set_from_cfg( var, value_cfg )) != kOkRC )
           goto errLabel;
 
-      var->var_link  = proc->varL;
-      proc->varL = var;
+      // Add the variable to the end of the chain
+      if( proc->varL == nullptr )
+        proc->varL = var;
+      else
+      {
+        variable_t* v = proc->varL;
+        while( v->var_link != nullptr )
+          v=v->var_link;
+        v->var_link = var;
+        
+      }
+      //var->var_link  = proc->varL;
+      //proc->varL = var;
 
       // link the new var into the ch_link list
       if((rc = _var_add_to_ch_list(proc, var )) != kOkRC )
@@ -1121,6 +1181,12 @@ namespace cw
   }
 }
 
+void  cw::flow::value_print( const value_t* value, bool info_fl)
+{
+   _value_print(value,info_fl);
+}
+
+
 cw::flow::abuf_t* cw::flow::abuf_create( srate_t srate, unsigned chN, unsigned frameN )
 {
   abuf_t* a  = mem::allocZ<abuf_t>();
@@ -1513,7 +1579,7 @@ void cw::flow::proc_destroy( proc_t* proc )
   if( proc == nullptr )
     return;
       
-  if( proc->class_desc->members->destroy != nullptr && proc->userPtr != nullptr )
+  if( proc->class_desc->members != nullptr && proc->class_desc->members->destroy != nullptr && proc->userPtr != nullptr )
     proc->class_desc->members->destroy( proc );
 
   // destroy the proc instance variables
@@ -1753,7 +1819,7 @@ cw::rc_t  cw::flow::var_channelize( proc_t* proc, const char* var_label, unsigne
         var_connect( last_src_ch_var, var );
             
       }
-      else
+      else // the base-var is not connected, and no value was provided for the new var
       {
       
         // Set the value of the new variable to the value of the 'any' channel
@@ -1766,14 +1832,13 @@ cw::rc_t  cw::flow::var_channelize( proc_t* proc, const char* var_label, unsigne
     }
     
   }
-  else
+  else // the var was found - set the value
   {
     
     // a correctly channelized var was found - but we still may need to set the value
     if( value_cfg != nullptr )
     {
-      //cwLogInfo("%s ch:%i",var_label,chIdx);
-      rc = var_set_from_preset( var, value_cfg );
+      rc = var_set_from_cfg( var, value_cfg );
     }
     else
     {
@@ -1799,15 +1864,20 @@ cw::rc_t cw::flow::var_call_custom_value_func( variable_t* var )
   
   if( var->flags & kLogVarFl )
   {    
+    cwLogPrint("cycle: %8i ",var->proc->ctx->cycleIndex);
     cwLogPrint("%10s:%5i", var->proc->label,var->proc->label_sfx_id);
     
     if( var->chIdx == kAnyChIdx )
+    {
       _var_print(var);
+    }
     else
     {
       printf("\n");
       for(variable_t* ch_var = var; ch_var!=nullptr; ch_var=ch_var->ch_link)
+      {
         _var_print(ch_var);
+      }
       
     }
   }
@@ -2006,7 +2076,7 @@ cw::rc_t cw::flow::var_register( proc_t* proc, const char* var_label, unsigned s
   {
     // if a value was given - then update the value
     if( value_cfg != nullptr )
-      if((rc = var_set_from_preset( var, value_cfg )) != kOkRC )
+      if((rc = var_set_from_cfg( var, value_cfg )) != kOkRC )
         goto errLabel;    
   }
   else // an exact match was not found - channelize the variable
@@ -2303,124 +2373,17 @@ errLabel:
 }
     
 
-cw::rc_t cw::flow::var_set_from_preset( variable_t* var, const object_t* value )
+cw::rc_t cw::flow::var_set_from_cfg( variable_t* var, const object_t* cfg_value )
 {
   rc_t rc = kOkRC;
+  value_t v;
 
-  //
-  // Determine the flow variable type of cfg. argument 'value'.
-  // 
-  unsigned value_flag = 0;
-      
-  switch( value->type->id )
-  {
-    case kCharTId:  
-    case kUInt8TId:
-    case kUInt16TId:
-    case kUInt32TId:
-      value_flag = kUIntTFl;
-      break;
-          
-    case kInt8TId:
-    case kInt16TId:
-    case kInt32TId:
-      value_flag = kIntTFl;
-      break;
-          
-    case kInt64TId:
-    case kUInt64TId:
-      rc = cwLogError(kInvalidArgRC,"The flow system does not currently implement 64bit integers.");
-      goto errLabel;
-      break;
-          
-    case kFloatTId:
-      value_flag = kFloatTFl;
-      break;
-          
-    case kDoubleTId:
-      value_flag = kDoubleTFl;
-      break;
-          
-    case kBoolTId:
-      value_flag = kBoolTFl;
-      break;
-          
-    case kStringTId:
-    case kCStringTId:
-      value_flag = kStringTFl;
-      break;
-          
-    default:
-      value_flag = kCfgTFl;
-        
-  }
-
-  //
-  // Convert the cfg value to a c++ typed value and then call _var_set_driver() with the c++ value.
-  //
-  switch( value_flag )
-  {
-    case kBoolTFl:
-      {
-        bool v;
-        // assign the value of 'value' to to 'v' (do type conversion if necessary)
-        if((rc = value->value(v)) == kOkRC )
-          // set the value of 'var' where 'v' is the new value and 'value_flag' is the type of 'v'.
-          rc = _var_set_driver( var, value_flag, v );
-      }
-      break;
-          
-    case kUIntTFl:
-      {
-        unsigned v;
-        if((rc = value->value(v)) == kOkRC )
-          rc = _var_set_driver( var, value_flag, v );
-      }
-      break;
-          
-    case kIntTFl:
-      {
-        int v;
-        if((rc = value->value(v)) == kOkRC )
-          rc = _var_set_driver( var, value_flag, v );
-      }
-      break;
-          
-    case kFloatTFl:
-      {
-        float v;
-        if((rc = value->value(v)) == kOkRC )
-          rc = _var_set_driver( var, value_flag, v );
-      }
-      break;
-
-    case kDoubleTFl:
-      {
-        double v;
-        if((rc = value->value(v)) == kOkRC )
-          rc = _var_set_driver( var, value_flag, v );
-      }
-      break;
-          
-    case kStringTFl:
-      {
-        const char* v;
-        if((rc = value->value(v)) == kOkRC )
-          rc = _var_set_driver( var, value_flag, v );
-      }
-      break;
-
-    case kCfgTFl:
-      {
-        rc = _var_set_driver( var, value_flag, value );
-      }
-      break;
-          
-    default:
-      rc = cwLogError(kOpFailRC,"The variable type 0x%x cannot yet be set via a cfg.", var->varDesc->type );
-      goto errLabel;
-  }
+  if((rc = cfg_to_value(cfg_value, v)) != kOkRC )
+    goto errLabel;
 
+  if((rc = var_set(var,&v)) != kOkRC )
+    goto errLabel;
+  
 errLabel:
   if( rc != kOkRC )
     rc = cwLogError(kSyntaxErrorRC,"The %s:%i.%s:%i could not extract a type:%s from a configuration value.",var->proc->label,var->proc->label_sfx_id,var->label,var->label_sfx_id,_typeFlagToLabel(var->varDesc->type & kTypeMask));
diff --git a/cwFlowTypes.h b/cwFlowTypes.h
index 53cfac1..221f0ad 100644
--- a/cwFlowTypes.h
+++ b/cwFlowTypes.h
@@ -252,12 +252,12 @@ namespace cw
     } proc_t;
 
 
+    // preset_value_t holds a preset value and the proc/var to which it will be applied.
     typedef struct preset_value_str
     {
       proc_t*                  proc;       // proc target for this preset value
       variable_t*              var;        // var target for this preset value
       value_t                  value;      // Preset value.
-      //unsigned                 chN;        // Count of channels specified by this preset
       unsigned                 pairTblIdx; // Index into the preset pair table for this preset value
       struct preset_value_str* link;
     } preset_value_t;
@@ -293,6 +293,7 @@ namespace cw
       } u;
     } network_preset_t;
 
+    // Preset-pair record used to apply dual presets.
     typedef struct network_preset_pair_str
     {
       const proc_t*     proc;   //
@@ -316,6 +317,7 @@ namespace cw
       network_preset_t* presetA;
       unsigned          presetN;
 
+      // Preset pair table used by network_apply_dual_preset()
       network_preset_pair_t* preset_pairA;
       unsigned               preset_pairN;
       
@@ -326,15 +328,20 @@ namespace cw
     {
       const object_t*      flowCfg;     // complete cfg used to create this flow 
 
-      bool                 isInRuntimeFl;        // Set when compile-time is complete
-      
       unsigned             framesPerCycle;       // sample frames per cycle (64)
       srate_t              sample_rate;          // default sample rate (48000.0)
+      unsigned             maxCycleCount;        // count of cycles to run on flow::exec() or 0 if there is no limit.
+      const char*          init_net_preset_label;// network initialization preset label or nullptr if there is no net. init. preset
+      
+      bool                 isInRuntimeFl;        // Set when compile-time is complete
+      
+      
+      unsigned             cycleIndex;           // Incremented with each processing cycle      
+
+      
       bool                 multiPriPresetProbFl; // If set then probability is used to choose presets on multi-preset application
       bool                 multiSecPresetProbFl; // 
       bool                 multiPresetInterpFl;  // If set then interpolation is applied between two selectedd presets on multi-preset application
-      unsigned             cycleIndex;           // Incremented with each processing cycle      
-      unsigned             maxCycleCount;        // count of cycles to run on flow::exec() or 0 if there is no limit.
       
       class_desc_t*        classDescA;           // 
       unsigned             classDescN;           //
@@ -384,6 +391,8 @@ namespace cw
 
     unsigned       value_type_label_to_flag( const char* type_desc );
     const char*    value_type_flag_to_label( unsigned flag );
+
+    void           value_print( const value_t* value, bool info_fl=false);
     
     //------------------------------------------------------------------------------------------------------------------------
     //
@@ -659,7 +668,7 @@ namespace cw
     //  var_set() coerces the incoming value to the type of the variable (var->type)
     //
 
-    rc_t var_set_from_preset( variable_t* var, const object_t* val );
+    rc_t var_set_from_cfg( variable_t* var, const object_t* cfg_value );
 
     rc_t var_set( variable_t* var, const value_t* val );
     rc_t var_set( variable_t* var, bool val );

From a09ca54315e654151c29dfd64a916edfeb159c59 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:42:24 -0400
Subject: [PATCH 092/101] cwFlowTest.cpp : Added 'compare' as a command line
 arg. and removed it as a system param.

---
 cwFlowTest.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/cwFlowTest.cpp b/cwFlowTest.cpp
index 3678a19..6e8c74c 100644
--- a/cwFlowTest.cpp
+++ b/cwFlowTest.cpp
@@ -215,7 +215,7 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
   const char*     proj_dir         = nullptr;
   const char*     test_ref_dir     = nullptr;
   bool            cmp_enable_fl    = false;
-  const char*     test_name        = nullptr;
+  const char*     test_name        = nullptr;  
   bool            test_all_fl      = false;
 
   if( argc < 2 || textLength(argv[1]) == 0 )
@@ -235,9 +235,13 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     goto errLabel;
   }
 
+  // was 'compare' requested
+  if( argc > 2 && textLength(argv[2])!=0 and textIsEqual(argv[2],"compare") )
+    cmp_enable_fl = true;
+    
+
   // get the subnet cfg filename
   if((rc = cfg->getv_opt("subnet_cfg_fname",subnet_cfg_fname,
-                         "cmp_enable_fl", cmp_enable_fl,
                          "test_ref_dir",test_ref_dir)) != kOkRC )
   {
     rc = cwLogError(rc,"The name of the subnet file could not be parsed.");

From ac42dd7653b80d5e5594879abbd53f1ef0d25fd9 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:42:46 -0400
Subject: [PATCH 093/101] flow/flow_doc.md : Updates.

---
 flow/flow_doc.md | 175 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 156 insertions(+), 19 deletions(-)

diff --git a/flow/flow_doc.md b/flow/flow_doc.md
index f9e0922..302a14d 100644
--- a/flow/flow_doc.md
+++ b/flow/flow_doc.md
@@ -1,6 +1,142 @@
 
 
 
+
+## Proc Class Notation
+
+```
+<class-label> : { 
+                  vars:    { (<var-label>:<var-desc>)* },
+                  presets: { (<var-preset-label>:<var-preset>)* },
+                  poly_limit_cnt: <int> 
+               }
+
+<var-desc> -> { type:<type-id>, value:<value-literal>, doc:<q-string>, flags:[ <attr-label> ] }
+
+<var-preset> -> { <var-label> : <preset-value>  }
+
+<preset-value> -> <value-list> | NUMBER | STRING | CFG
+
+<value-list> -> [ (value-literal)* ] 
+                    
+
+```
+
+### Applying class presets during proc instantiaion
+
+The way class preset values get applied is a function of the type of the variable and the format of the value.
+If a variable is not a _cfg_ type and the preset value is a list, or if the variable is a _cfg_ type
+and the preset value is a list-of-containers then each each value in the list is assigned to successive
+channels on the variable.  This is shown as the __multi-chan__ algorithm in the table below.
+In all other cases the the value is applied to the 'any' channel, which is applied to 
+all existing channels.
+
+|    cfg      |   list  |   LoC           | chan | algorithm                                      |
+| ----------- | ------- | --------------- | ---- | ---------------------------------------------- |
+|      no     |   no    |     no          | any  | single-chan                                    |
+|      no     |   no    |    yes          | n/a  | Value can't be an l-of-c w/o also being a list.| 
+|      no     |  yes    |     no          |  N   | multi-chan                                     |
+|      no     |  yes    |    yes          |  N   | multi-chan                                     |
+|      yes    |   no    |     no          | any  | single-chan                                    |
+|      yes    |   no    |    yes          | n/a  | Value can't be an l-of-c w/o also being a list.|
+|      yes    |  yes    |     no          | any  | single-chan                                    |
+|      yes    |  yes    |    yes          |  N   | multi-chan                                     |
+
+When the class preset is applied during proc instantiation all variables have 
+been instantiated with the base channel. This implies that the __single-chan__ 
+algorithm is only setting the value of the the existig base channel.
+The __multi-chan__ algorithm however will instantiate any channels above the base channel
+that do not already exist by duplicating the base channel and then assigning the preset value.
+
+
+### Notes
+
+1. Legal `<type-id>` values
+
+type     | Description
+---------|-------------------------------------------------------------------------------------------------------------------
+string   | 
+bool     | `true` or `false`
+int      | `int32_t`
+uint     | `uint32_t`. The literal value must be suffixed with a 'u'. [See JSON Notes](#json-notes)
+float    | Single precision float.  The literal value must be suffixed with an 'f'. [See JSON Notes](#json-notes)
+double   | Double precision float
+cfg      | JSON string
+audio    |
+spectrum | 
+midi     |
+srate    | (float) Sample rate type
+sample   | (float) Audio sample type
+coeff    | (float) Value that will be directly applied to a sample value (e.g added or multiplied)
+ftime    | (double) Fractional seconds
+runtime  | The type is left up to the processors custom 'create' function. These variables are not created automatically 
+         | prior to calling the proc custom function.
+all      | 
+numeric  |
+
+
+See list in cwFlowTypes.cpp : typeLabelFlagsA[]
+
+
+2. Attribute labels indicate properties of this variable.
+
+Attribute | Description
+----------|--------------------------------------------------------------
+`src`     | This variable must have a value or be connected to a source or
+          | the proc cannot be instantiated, and therefore the network cannot be instantiated.
+`src_opt` |
+`no_src`  | This variable cannot be connected to a 'source' variable. Variables that are
+          | only used as output usually have this property.
+`init`    | This is an an initialization only variable. 
+          | Changing the value during runtime will have no effect.
+`mult`    | This variable may be instantiated multiple times by the in-statement.
+          | Variables that do not have this property may only be instantiated
+          | once per proc-instance.
+`out`     | This is a subnet output variable. [See Subnet Implementation](#subnet-implementation)
+`no_chan` | This variable cannot be 'channelized'.
+
+## Schema Notation
+
+1. The schemas all describe JSON like structures. For clarity the dictionary braces and
+list brackets are shown.
+
+2. Variables are wrapped in `< >` markers.
+
+3. Entitities wrapped in `( )*` indicate that the wrapped structure may be repeated 0 or more times.
+Entitities wrapped in `( )+` may be repeated 1 or more times.
+
+4. Variables with names ending in `label` indicate identifiers which are unique at least within
+their local scope and possibly some greater scope.  For example proc-class names must be
+unique across all loaded proc-class modules.
+
+5. `<q-string>` indicates arbitrary text.
+
+6. Entities are often optional.  Rather than clutter the notation with additional 
+mark-up to indicate optional entitities this information is inclued in the notes 
+that accompany each schema.
+
+
+
+
+
+## JSON Notes
+
+The 'cfg' language is a JSON like with some added features:
+
+1. Comments can be inserted using C++ `\\` line comment and  `\* *\` block comment syntax.
+
+2. Quotes are not necessary around strings that have no internal whitespace.
+
+3. Numeric literals without decimal places are interpretted as integers, numbers
+with decimal places are interpretted as doubles.  Unsigned and single precision float values
+may be specified using suffix notation
+
+Type     | Suffix   | Example
+---------|----------|--------------
+unsigned |   u      |  10u
+float    |   f      |  12.34f 
+
+
 # Flow Documentation:
 
 _flow_ is an experimental audio processing framework which supports 
@@ -42,10 +178,17 @@ Use `$` prefix to a filename. Use proc_expand_filename() to prepend `proj_dir` t
 
 ### Network with sub-nets.
 
+
+## Proc Class Descriptions
+
+```
+```
+
+
 ## Proc Instance Syntax:
 
 ```
-<label> : { 'class':<class>, "in":{<in_stmt>*}, "preset":<class_preset_label>, "log":<log_dict> "argLabel":<arg_preset_label>, "args":<args_dict> }
+<label> : { 'class':<class>, "in":{<in_stmt>*}, "out":{<out_stmt>}, "preset":<class_preset_label> "args":<args_dict>, "log":<log_dict> }
 ```
 
 Proc instance and variabel labels consist of two parts a leading identifier and a
@@ -55,9 +198,6 @@ A proc or variable label without a numeric suffix is automatically assigned the
 
 __args__ : This is a dictionary of named variable value records. 
 __preset__ : This string references a class preset to use for initializing this proc instance.
-__argLabel__ : This string references an `args` dictionary parameter set to be applied after the __preset__ class preset.
-If this argument is not given then it is automatically assigned the value "default". (What if there is not __arg__ record named default?
-What if the are no __arg__ records at all?)
 __log__ : This is a dictionary of `<var_label>:<sfx_id>` pairs whose value should be printed to the console when they change at runtime.
 
 
@@ -75,21 +215,6 @@ as a single value.
 
 ## Processing Unit Class
 
-type   | Description
--------|-------------------------------------
-string | 
-bool   |
-int    | `int32_t`
-uint   | `uint32_t`
-float  | f32
-double | f64
-srate  | (float) Sample rate type
-sample | (float) Audio sample type
-coeff  | (float) Value that will be directly applied to a sample value (e.g added or multiplied)
-ftime  | (double) Fractional seconds
-runtime| The type is left up to the processors custom 'create' function. These vars are not automatically created.
-
-See list in cwFlowTypes.cpp : typeLabelFlagsA[]
 
 
 ### Processing Units (proc)
@@ -295,3 +420,15 @@ the associated network variable is set.
 
 6. If the preset-pair record value field is NULL then the primary preset-value
 is used to set the associated network variable.
+
+# Subnet Implementation
+
+Subnets are implemented in the following phases:
+- During program initialization the subnet cfg files is scanned and the
+proxy vars for each subnet are used to create a `class_desc_t` record for each subnet.
+
+- When the subnet is instantiated the proxy vars are instantiated first.
+- Then the internal network is instantiated.
+- The proxy var's are then connected to the proxied vars. This may require
+connecting in either direction: proxy->proxied or proxied->proxy, with the later
+case being indicated by an 'out' attribute in proxied 'flags' list.

From b31d8dd5c0c5c767f1c8b3b50bb7b98b72effdca Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Fri, 24 May 2024 16:43:05 -0400
Subject: [PATCH 094/101] README.md : Updates.

---
 README.md | 127 ++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 99 insertions(+), 28 deletions(-)

diff --git a/README.md b/README.md
index 3c30e8e..d247577 100644
--- a/README.md
+++ b/README.md
@@ -930,25 +930,48 @@ resolvable without more information.
 
 ### TODO:
 
+- Check for illegal variable names in class descriptions.  (no periods, trailing digits, or trailing underscores)
+- Check for unknown fields where the syntax clearly specifies only certain options.
+
+- Class presets cannot address 'mult' variables (maybe this is ok since 'mult' variables are generally connected to a source.).
+
 - Documentation w/ examples.
   + Write the rules for each implementing member function.
     
 - value() should return a special return-code value to indicate that the
 value should not be updated and distinguish it from an error code - which should stop the system.
 
-- Compile presets: at load time the presets should be resolved
-  to the proc and vars to which they will be assigned.
-
 - flow classes and variable should have a consistent naming style: camelCase or snake_case.
 
+-  String assignment is allocating  memory:
+   See: `rc_t _val_set( value_t* val, const char* v ) cwFlowTypes.cpp line:464.`
+
+
 - Variable attributes should be meaningful. e.g. src,src_opt,mult,init, ....
   Should we check for 'src' or 'mult' attribute on var's?
   (In other words: Enforce var attributes.)
 
--  String assignment is allocating  memory:
-   See: `rc_t _val_set( value_t* val, const char* v ) cwFlowTypes.cpp line:464.`
+- Reduce runtime overhead for var get/set operations.
+  
+- Implement matrix types.
 
-- Should the var's with multiple channels remove the 'kAnyChIdx'?
+- Should the `object_t` be used in place of `value_t`?
+
+- Allow min/max limits on numeric variables.
+
+- log: 
+    + should print the values for all channels - right now it is only
+	printing the values for kAnyChIdx
+	+ log should print values for abuf (mean,max), fbuf (mean,max) mag, mbuf
+
+
+
+- DONE: Compile presets: at load time the presets should be resolved
+  to the proc and vars to which they will be assigned.
+
+
+- DONE: (We are not removing the kAnyChIdx) 
+Should the var's with multiple channels remove the 'kAnyChIdx'?
 This may be a good idea because 'kAnyChIdx' will in general not be used
 if a var has been channelized - and yet it is possible for another 
 var to connect to it as a source ... which doesn't provoke an error
@@ -971,42 +994,22 @@ ports of the internal elements.
 
 - DONE: 'poly' and 'sub' should be arbitrarily nestable. 
 
-- Reduce runtime overhead for var get/set operations.
-  
-- Implement matrix types.
-
-- Should the `object_t` be used in place of `value_t`?
-
 - DONE: Allow multiple types on an input.
    For example 'adder' should have a single input 
    which can by any numeric type.
    
-- Allow min/max values on numeric variables.
 
 - DONE: Make a standard way to turn on output printing from any port on any instance
 This might be a better approach to logging than having a 'printer' object.
 Add proc instance field: `log:{ var_label_0:0, var_label_1:0 } `
 
-- log: 
-    + should print the values for all channels - right now it is only
-	printing the values for kAnyChIdx
-	+ log should print values for abuf (mean,max), fbuf (mean,max) mag, mbuf
-
 Next:
 
 - Complete subnets:
 	+ Subnets should have presets written in terms of the subnet vars rather than the network vars
 	or the value application needs to follow the internal variable src_var back to the proxy var.
 
-	+ write a paragraph in the flow_doc.md about overall approach taken to subnet implementation.
-	  Subnets are implemented in the following phases:
-	  - During program initialization the subnet cfg files is scanned and the
-	  proxy vars for each subnet are used to create a `class_desc_t` record for each subnet.
-	  - When the subnet is instantiated the proxy vars are instantiated first.
-	  - Then the internal network is instantiated.
-	  - The proxy var's are then connected to the proxied vars. This may require
-	  connecting in either direction: proxy->proxied or proxied->proxy, with the later
-	  case being indicated by an 'out' attribute in proxied 'flags' list.
+	+ DONE: write a paragraph in the flow_doc.md about overall approach taken to subnet implementation.
 
 	+ DONE: subnet var desc's should be the same as non+subnet vars but also include the 'proxy' field.
 	In particular they should get default values.
@@ -1100,4 +1103,72 @@ channel that does not exist.
 
 
 
-- All cfg to value conversion should go through `cfg_to_value()`.
+- How much of the proc initialization implementation can use the preset compile/apply code?
+- DONE: All cfg to value conversion should go through `cfg_to_value()`.
+
+
+Names:
+ixon - 
+hoot
+caw, screech, warble, coo, peep, hoot, gobble, quack, honk, whistle, tweet, cheep, chirrup, trill, squawk, seet, 
+cluck,cackle,clack
+cock-a-dooodle-doo
+song,tune,aria
+
+
+caw by example:
+0. DONE: Add log object.
+   DONE: Add automatic network preset selection.
+
+1. sine->af
+   in-stmt
+   
+2. sine->af with network preset
+   topics:preset, class info
+
+3. number,timer,counter,list,log
+   topics: log, data types, system parameters
+
+4. sine->delay->mixer->af
+       -------->
+   topics: mult vars, system parameters
+   
+5. topic: modulate sine with sine
+
+6. topic: modulate sine with sine and timed preset change.
+
+7. topic: iterating input stmt 0 - connect multiple inputs to a single source
+          
+8. topic: iterating input stmt 1 - multiple inputs to multiple sources
+
+9. topic: iterating input stmt 2 - two ranges
+
+12. topic: poly
+
+13. topic: poly w/iterating input stmt
+
+14. topic: poly w/ xfade ctl and presets
+
+15. topic: msg feedback
+
+16. topic: audio feedback
+
+17. topic: subnets
+
+18. topic: subnet with presets
+
+19. topic: presets w/ sfx id's
+
+
+
+
+
+
+
+
+
+
+
+   
+   
+   

From 48fefa705b3b074b70d27ff5ddbe3056d7ae7687 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 25 May 2024 08:49:45 -0400
Subject: [PATCH 095/101] cwFlowProc.cpp : Fixed typo in error message.

---
 cwFlowProc.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 41d6d59..9d693d2 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -709,7 +709,7 @@ namespace cw
         // verify that a source buffer exists
         if((rc = var_get(proc,kOutPId,kAnyChIdx,abuf)) != kOkRC )
         {
-          rc = cwLogError(kInvalidStateRC,"The audio file instance '%s' does not have a valid audio output buffer.",proc->label);
+          rc = cwLogError(kInvalidStateRC,"The audio  input instance '%s' does not have a valid audio output buffer.",proc->label);
         }
         else
         {

From f4a6b015e1326a0102dd58533d2da9f1145bfcca Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Sat, 25 May 2024 08:50:13 -0400
Subject: [PATCH 096/101] README.md : Updates

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d247577..f4a0647 100644
--- a/README.md
+++ b/README.md
@@ -1118,7 +1118,7 @@ song,tune,aria
 
 caw by example:
 0. DONE: Add log object.
-   DONE: Add automatic network preset selection.
+   DONE: Add initial network preset selection system parameter.
 
 1. sine->af
    in-stmt

From eb0a773302cbf3b27af6e96ea1d49e9dfaa5cb0e Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Mon, 27 May 2024 13:33:01 -0400
Subject: [PATCH 097/101] cwObject.h : Added read() interface.

---
 cwObject.h | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 110 insertions(+), 1 deletion(-)

diff --git a/cwObject.h b/cwObject.h
index 4585ee6..ed1a6ad 100644
--- a/cwObject.h
+++ b/cwObject.h
@@ -31,7 +31,8 @@ namespace cw
    kRootTId    = 0x00100000,
 
    kHexFl      = 0x10000000,
-   kIdentFl    = 0x20000000
+   kIdentFl    = 0x20000000,
+   kOptFl      = 0x40000000
    
   };
 
@@ -206,7 +207,115 @@ namespace cw
     const struct object_str* next_child_ele( const struct object_str* ele) const;
     struct       object_str* next_child_ele(       struct object_str* ele);
 
+    typedef struct read_str
+    {
+      const char* label;
+      unsigned    flags;
+      const struct read_str* link;        
+    } read_t;
+
+    template< typename T >
+    rc_t read( const char* label, unsigned flags, T& v ) const
+    {
+      const struct object_str* o;
+      if((o = find(label, 0)) == nullptr )
+      {
+        if( cwIsNotFlag(flags, kOptFl) )
+          return cwLogError(kInvalidIdRC,"The pair label '%s' could not be found.",cwStringNullGuard(label));
+        
+        return kEleNotFoundRC;        
+      }
+      else
+      {
+        flags = cwClrFlag(flags,kOptFl);
+        if( flags &&  cwIsNotFlag(o->type->id,flags) )
+          return cwLogError(kInvalidDataTypeRC,"The field '%s' data type 0x%x does not match 0x%x.",cwStringNullGuard(label),o->type->id,flags);
+      }
+      
+      
+      return o->value(v);
+    }
     
+    rc_t _readv(const read_t* list) const
+    {
+      rc_t rc = kOkRC;
+      
+      unsigned childN = child_count();
+      
+      // for each child of this dict node
+      for(unsigned i=0; i<childN; ++i)
+      {
+        const struct object_str* child = child_ele(i);
+        const char*              label = nullptr;
+        const read_t*            r     = list;
+          
+        if( child == nullptr )
+        {
+          rc = cwLogError(kAssertFailRC,"A null child was encountered.");
+          goto errLabel;
+        }
+
+        if( !child->is_pair() )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"A non-pair element was encountered inside a dictionary.");
+          goto errLabel;
+        }
+
+        if( (label = child->pair_label()) == nullptr )
+        {
+          rc = cwLogError(kInvalidStateRC,"A blank label was encountered as a dictionary label.");
+          goto errLabel;
+        }
+
+        // verify that this is a known label
+        // (all labels in the dictionary must be known - this prevents mispelled fields from being inadverently skipped during parsing)
+        for(; r!=nullptr; r=r->link)
+          if( strcmp(r->label,label) == 0 )
+            break;
+
+        if( r == nullptr )
+        {
+          rc = cwLogError(kSyntaxErrorRC,"The unknown field '%s' was encountered.",cwStringNullGuard(label));
+          goto errLabel;
+        }
+        
+      }
+
+    errLabel:
+      return kOkRC;
+    } 
+
+    // readv("label0",v0,"label1",v1, ... )
+    template< typename T0, typename T1, typename... ARGS >
+    rc_t _readv( const read_t* list, T0 label, unsigned flags, T1& valRef, ARGS&&... args ) const
+    {
+      rc_t rc = read(label,flags,valRef);
+      
+      read_t r = { .label=label, .flags=flags, .link=list };
+
+      // if no error occurred ....
+      if( rc == kOkRC || (rc == kEleNotFoundRC && cwIsFlag(flags,kOptFl)))
+        rc =  _readv(&r, std::forward<ARGS>(args)...); // ... recurse to find next label/value pair
+      else
+        rc = cwLogError(rc,"Object parse failed for the pair label:'%s'.",cwStringNullGuard(label));
+
+      return rc;
+    }
+
+    
+    // readv("label0",flags0,v0,"label1",flags0,v1, ... )
+    // Use kOptFl for optional fields.
+    // Use kListTId and kDictTId to validate the type of container fields.
+    // In general it should not be necessary to validate numeric and string types because
+    // they are validated by virtue of being converted to the returned value.
+    template< typename T0, typename T1, typename... ARGS >
+    rc_t readv( T0 label, unsigned flags, T1& valRef, ARGS&&... args ) const
+      { return _readv(nullptr, label,flags,valRef,args...); }
+
+
+    
+    
+
     // Set flag  'kRecurseFl' to recurse into the object in search of the value.
     // Set flag  'kOptionalFl' if the label is optional and may not exist.
     template< typename T >

From 9f00c88964f57930d80602c3518c2420854bbd5b Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 29 May 2024 12:32:33 -0400
Subject: [PATCH 098/101] cwTest.h/cpp : Initial commit.

---
 cwTest.cpp | 540 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 cwTest.h   |  31 +++
 2 files changed, 571 insertions(+)
 create mode 100644 cwTest.cpp
 create mode 100644 cwTest.h

diff --git a/cwTest.cpp b/cwTest.cpp
new file mode 100644
index 0000000..b656db0
--- /dev/null
+++ b/cwTest.cpp
@@ -0,0 +1,540 @@
+#include "cwCommon.h"
+#include "cwLog.h"
+#include "cwCommonImpl.h"
+#include "cwTest.h"
+#include "cwMem.h"
+#include "cwText.h"
+#include "cwNumericConvert.h"
+#include "cwObject.h"
+#include "cwLex.h"
+
+#include "cwTime.h"
+#include "cwFile.h"
+#include "cwFileSys.h"
+#include "cwVectOps.h"
+#include "cwFlowTest.h"
+
+
+namespace cw
+{
+  namespace test
+  {
+    typedef struct test_map_str
+    {
+      const char* module_name;
+      test_func_t test_func; 
+    } test_map_t;
+
+    test_map_t _test_map[] = {
+      { "/lex",     lex::test },
+      { "/filesys", filesys::test },
+      { "/object",  object_test },
+      { "/vop",     vop::test },
+      { "/time",    time::test },
+      { "/flow",    flow::test },
+      { nullptr, nullptr },
+    };
+    
+    typedef struct test_str
+    {
+      int             argc;        // extra cmd line arguments to be passes to the test cases
+      const char**    argv;  
+      
+      const char*     base_dir;    // base test dictionary    
+      const object_t* test_cfg;    // top level test cfg.
+      
+      const char*       rsrc_folder; // name of the 'rsrc' folder in the base dir
+      const char*       out_folder;  // name of the output folder in the base dir
+      const char*       ref_folder;  // name of the test reference folder in the base dir
+
+      const char* sel_module_label; // selected module label
+      const char* sel_test_label;   // selected test label
+      bool        all_module_fl;    // true if all modules should be run
+      bool        all_test_fl;      // true if all tests in the selected module should be run
+      bool        compare_fl;       // true if compare operation should be run
+      bool        echo_fl;          // echo test output to the console (false=write all output to log file only)
+      bool        gen_report_fl;    // print module/test names as the gen phase is executes
+
+      void*                  logCbArg;   // original log callback args
+      log::logOutputCbFunc_t logCbFunc;
+      
+      const char*    cur_test_label;    // current test label
+      file::handle_t cur_log_fileH;     // current log file handle
+
+      unsigned  gen_cnt;           // count of tests which generated output
+      unsigned  compare_ok_cnt;    // count of tests which passed the compare pass
+      unsigned  compare_fail_cnt;  // count of tests which failed the compare test 
+      
+    } test_t;
+
+
+    rc_t _parse_args( test_t& test, const object_t* cfg, int argc, const char** argv )
+    {
+      rc_t     rc      = kOkRC;
+      unsigned argN    = 1;
+      char*    out_dir = nullptr;
+      int      argi    = 1;
+      
+      test.all_module_fl = true;
+      test.all_test_fl   = true;
+      
+      if( argc > 1 )
+      {
+        test.sel_module_label = argv[1];
+        test.all_module_fl    = textIsEqual(test.sel_module_label,"all");
+        argi += 1;
+      }      
+
+      if( argc > 2 )
+      {
+        test.sel_test_label = argv[2];
+        test.all_test_fl    = textIsEqual(test.sel_test_label,"all");
+        argi += 1;
+      }
+
+      for(int i=argi; i<argc; ++i)
+      {
+        if( textIsEqual(argv[i],"compare") )
+          test.compare_fl = true;
+
+        if( textIsEqual(argv[i],"echo") )
+          test.echo_fl = true;
+
+        if( textIsEqual(argv[i],"gen_report"))
+          test.gen_report_fl = true;
+
+        // test specific args follow the 'args' keyword
+        if( textIsEqual(argv[i],"args") )
+        {
+          test.argc = argc - (i+1);
+          test.argv = argv + (i+1);
+        }
+      }
+      
+      if((rc = cfg->readv("base_dir",0,test.base_dir,
+                          "test",kDictTId,test.test_cfg,
+                          "resource_dir",0,test.rsrc_folder,
+                          "output_dir",0,test.out_folder,
+                          "ref_dir",0,test.ref_folder)) != kOkRC )
+      {
+        goto errLabel;
+      }
+
+      if((out_dir = filesys::makeFn(test.base_dir, nullptr, nullptr, test.out_folder, nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"Output directory name formation failed.");
+        goto errLabel;
+      }
+
+      if( !filesys::isDir(out_dir))
+      {
+        if((rc = filesys::makeDir(out_dir)) != kOkRC )
+          goto errLabel;
+      }
+
+    errLabel:
+      mem::release(out_dir);
+      return rc;
+    }
+
+    void _exec_test_log_cb( void* cbArg, unsigned level, const char* text )
+    {
+      rc_t rc;
+      test_t* r = (test_t*)cbArg;
+      
+      if((rc = file::print(r->cur_log_fileH,text)) != kOkRC )
+        cwLogError(rc,"Log file write failed for '%s'.",text);
+      
+      if( r->logCbFunc != nullptr && r->echo_fl )
+        r->logCbFunc( r->logCbArg,level,text);
+    }
+
+    rc_t _exec_dispatch( test_t& test, test_args_t& args )
+    {
+      rc_t     rc = kOkRC;
+      unsigned i  = 0;
+      
+      // find the requested test function ....
+      for(; _test_map[i].module_name!=nullptr; ++i)
+        if( textIsEqual(_test_map[i].module_name,args.module_label) )
+        {
+          rc = _test_map[i].test_func(args); //.... and call it
+          break;
+        }
+
+      if( _test_map[i].module_name==nullptr )
+      {
+        rc = cwLogError(kEleNotFoundRC,"The test function for module %s was not found.",cwStringNullGuard(args.module_label));
+        goto errLabel;
+      }
+
+    errLabel:
+      return rc;
+    }
+
+    rc_t _compare_one_test( test_t& test, const char* ref_dir, const char* test_dir )
+    {
+      rc_t                 rc          = kOkRC;
+      unsigned             testRefDirN = 0;
+      filesys::dirEntry_t* testRefDirA = nullptr;
+      bool                 ok_fl = true;
+
+      // get the list of files in the test directory
+      if((testRefDirA = filesys::dirEntries( ref_dir, filesys::kFileFsFl, &testRefDirN )) == nullptr )
+      {            
+        rc = cwLogError(kOpFailRC,"An error occurred while attempting to read the directory file names from '%s'.",cwStringNullGuard(ref_dir));
+        goto errLabel;
+      }
+
+      // for each file 
+      for(unsigned j=0; rc==kOkRC && j<testRefDirN; ++j)
+        if( testRefDirA[j].name != nullptr )
+        {
+          char* testRefFn = filesys::makeFn( ref_dir,  testRefDirA[j].name, nullptr, nullptr ); 
+          char* testCmpFn = filesys::makeFn( test_dir, testRefDirA[j].name, nullptr, nullptr );
+          bool  isEqualFl = false;
+          
+          // compare two files
+          if((rc = file::compare( testRefFn, testCmpFn, isEqualFl)) != kOkRC )
+            rc = cwLogError(rc,"The comparison failed on '%s' == '%s'.",cwStringNullGuard(testRefFn),cwStringNullGuard(testCmpFn));
+          else
+          {
+            // check compare status
+            if( !isEqualFl )
+            {
+              ok_fl = false;
+              cwLogInfo("Test failed on: '%s'",testRefFn);
+            }
+          }
+              
+          mem::release(testRefFn);
+          mem::release(testCmpFn);              
+        }
+
+      mem::release(testRefDirA);
+
+    errLabel:
+
+      if( ok_fl )
+        test.compare_ok_cnt += 1;
+      else
+        test.compare_fail_cnt += 1;
+      
+      return rc;
+      
+    }
+      
+    
+    rc_t _exec_one_test( test_t& test, const char* module_label, const object_t* module_args, const char* test_label, const object_t* test_args )
+    {
+      rc_t        rc        = kOkRC;
+      char*       rsrc_dir  = nullptr;
+      char*       out_dir   = nullptr;
+      char*       ref_dir   = nullptr;
+      char*       log_fname = nullptr;
+      test_args_t args      = {};
+      
+
+      if((rsrc_dir = filesys::makeFn( test.base_dir, nullptr, nullptr, test.rsrc_folder, module_label, test_label, nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"Resource directory '%s' formation failed.",cwStringNullGuard(rsrc_dir));
+        goto errLabel;
+      }
+
+      if((out_dir = filesys::makeFn( test.base_dir, nullptr, nullptr, test.out_folder, module_label, test_label, nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"Output directory '%s' formation failed.",cwStringNullGuard(out_dir));
+        goto errLabel;
+      }
+
+      if((ref_dir = filesys::makeFn( test.base_dir, nullptr, nullptr, test.ref_folder, module_label, test_label, nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"Reference directory '%s' formation failed.",cwStringNullGuard(ref_dir));
+        goto errLabel;
+      }
+      
+      if((log_fname = filesys::makeFn( out_dir, "log","txt",nullptr,nullptr)) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"Log filename '%s' formation failed.",cwStringNullGuard(log_fname));
+        goto errLabel;
+      }
+
+      if( !filesys::isDir(out_dir))
+      {
+        if((rc = filesys::makeDir(out_dir)) != kOkRC )
+        {
+          rc = cwLogError(kOpFailRC,"Output directory '%s' create failed.",cwStringNullGuard(out_dir));
+          goto errLabel;
+        }
+      }
+      
+      // open the log file
+      if((rc = file::open(test.cur_log_fileH, log_fname,file::kWriteFl)) != kOkRC )
+      {
+        rc = cwLogError(rc,"The log file '%s' could not be created.",cwStringNullGuard(log_fname));
+        goto errLabel;
+      }
+
+      if( test.gen_report_fl )
+        cwLogInfo("%s %s",module_label,test_label);
+
+      // save the log to a 
+      test.logCbArg  = log::outputCbArg( log::globalHandle() );
+      test.logCbFunc = log::outputCb(    log::globalHandle() );
+      
+      log::setOutputCb( log::globalHandle(), _exec_test_log_cb, &test );
+      
+
+      args.module_label = module_label;
+      args.test_label   = test_label;
+      args.module_args  = module_args;
+      args.test_args    = test_args;
+      args.rsrc_dir = rsrc_dir;
+      args.out_dir  = out_dir;
+      args.argc     = test.argc;
+      args.argv     = test.argv;
+
+      if((rc = _exec_dispatch(test, args )) != kOkRC )
+        goto errLabel;
+
+      test.gen_cnt += 1;
+      
+    errLabel:
+      
+      file::close(test.cur_log_fileH);      
+      log::setOutputCb( log::globalHandle(), test.logCbFunc, test.logCbArg );
+
+      // if compare is enabled 
+      if( rc == kOkRC && test.compare_fl )
+        rc = _compare_one_test(test, ref_dir, out_dir );
+     
+      if( rc != kOkRC )
+        rc = cwLogError(rc,"Test process failed on module:%s test:%s.",module_label,test_label);
+      
+      mem::release(log_fname);
+      mem::release(rsrc_dir);
+      mem::release(out_dir);
+      mem::release(ref_dir);
+      
+      return rc;
+    }
+
+    rc_t _exec_cases( test_t& test, const char* module_label, const object_t* module_args, const object_t* cases_cfg )
+    {
+      rc_t rc = kOkRC;
+      
+      // get count of test cases
+      unsigned testN = cases_cfg->child_count();
+
+      // for each test case
+      for(unsigned i=0; i<testN; ++i)
+      {
+        const object_t* test_pair = cases_cfg->child_ele(i);
+        const char*     test_label = test_pair->pair_label();
+
+        // apply filter/test label filter
+        if( (test.all_module_fl || textIsEqual(module_label,test.sel_module_label)) &&
+            ( test.all_test_fl || textIsEqual(test_label,test.sel_test_label)))
+        {          
+          if((rc = _exec_one_test(test, module_label, module_args, test_label, test_pair->pair_value() )) != kOkRC )
+          {
+            goto errLabel;
+          }
+        }
+      }
+
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _exec_module( test_t& test, const char* module_label, const object_t* module_args, const object_t* module_cfg )
+    {
+      rc_t rc = kOkRC;
+
+      const object_t* cases_cfg = nullptr;
+      const object_t* mod_args_cfg = nullptr;
+      
+      if((rc = module_cfg->getv_opt("cases",cases_cfg,
+                                    "module_args",mod_args_cfg)) != kOkRC )
+      {
+        rc = cwLogError(rc,"Parse failed on module fields in '%s'.",cwStringNullGuard(module_label));
+        goto errLabel;
+      }
+
+      if( cases_cfg == nullptr )
+        cases_cfg = module_cfg;
+
+      if( mod_args_cfg == nullptr )
+        mod_args_cfg = module_args;
+
+      if((rc = _exec_cases( test,module_label,mod_args_cfg,cases_cfg)) != kOkRC )
+        goto errLabel;
+      
+    errLabel:
+      return rc;
+    }
+    
+    rc_t _proc_test_cfg( test_t& test, const char* module_label, const object_t* test_cfg );
+    
+    rc_t _proc_test_from_file( test_t& test, const char* module_label, const char* fname )
+    {
+      rc_t rc = kOkRC;
+      char* cfg_fname;
+      object_t* test_cases_cfg = nullptr;
+      const char* orig_base_dir = test.base_dir;
+      char* new_base_dir = nullptr;
+      
+      if((cfg_fname = filesys::makeFn(test.base_dir, fname, nullptr, nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"The test cases file name for the module '%s' in '%s' / '%s' could not be formed.",cwStringNullGuard(module_label),cwStringNullGuard(test.base_dir),cwStringNullGuard(fname));
+        goto errLabel;
+      }
+
+      if((rc = objectFromFile( cfg_fname, test_cases_cfg )) != kOkRC )
+      {
+        rc = cwLogError(kOpFailRC,"Parse failed on the test case module file '%s'.",cwStringNullGuard(cfg_fname));
+        goto errLabel;
+      }
+
+      if((new_base_dir = filesys::makeFn(test.base_dir, nullptr, nullptr, test.out_folder, module_label, nullptr )) == nullptr )
+      {
+        rc = cwLogError(kOpFailRC,"The base test directory name for the module '%s' could not be formed in '%s'.",cwStringNullGuard(test.base_dir),cwStringNullGuard(module_label));
+        goto errLabel;
+      }
+
+      if( !filesys::isDir(new_base_dir))
+      {
+        rc = cwLogError(kOpFailRC,"The base test directory '%s' for the module '%s' does not exist.",cwStringNullGuard(test.base_dir),cwStringNullGuard(module_label));
+        goto errLabel;
+      }
+
+      rc = _proc_test_cfg( test, module_label, test_cases_cfg );
+      
+    errLabel:
+      mem::release(cfg_fname);
+      mem::release(new_base_dir);
+      
+      if( test_cases_cfg != nullptr )
+        test_cases_cfg->free();
+
+      
+      return rc;
+    }
+
+    rc_t _proc_module( test_t& test, const char* base_module_label, const char* module_label, const object_t* module_cfg )
+    {
+      rc_t  rc               = kOkRC;
+      char* new_module_label = filesys::makeFn(base_module_label,nullptr,nullptr,module_label,nullptr );
+      
+      switch( module_cfg->type_id() )
+      {
+        case kStringTId:
+          {
+            const char* s = nullptr;
+            if((rc = module_cfg->value(s)) != kOkRC )
+            {
+              rc = cwLogError(rc,"Parse failed on module filename in '%s'.",cwStringNullGuard(module_label));
+              goto errLabel;
+            }
+            
+            rc = _proc_test_from_file(test, new_module_label, s );
+          }
+          break;
+              
+        case kDictTId:
+          rc = _proc_test_cfg(test, new_module_label, module_cfg );
+          break;
+
+        default:
+          break;
+      }                  
+
+    errLabel:
+      mem::release(new_module_label);
+      return rc;
+    }
+    
+    rc_t _proc_test_cfg( test_t& test, const char* module_label, const object_t* test_cfg )
+    {
+      rc_t            rc          = kOkRC;
+      const object_t* module_args = nullptr;
+      const object_t* modules_cfg = nullptr;
+      const object_t* cases_cfg   = nullptr;
+
+      
+      if((rc = test_cfg->getv_opt("module_args",module_args,
+                                  "modules",modules_cfg,
+                                  "cases",cases_cfg )) != kOkRC )
+      {
+        rc = cwLogError(rc,"The 'module_args' parse failed on module '%s'.",cwStringNullGuard(module_label));
+        goto errLabel;
+      }
+
+      // if a list of modules was given
+      if( modules_cfg != nullptr )
+      {
+        unsigned modulesN = modules_cfg->child_count();
+        for(unsigned i=0; i<modulesN; ++i)
+        {
+          const object_t* mod_pair = modules_cfg->child_ele(i);
+
+          if((rc = _proc_module(test, module_label, mod_pair->pair_label(), mod_pair->pair_value() )) != kOkRC )
+            goto errLabel;
+          
+
+        }
+      }
+
+      // if 
+      if(module_args==nullptr && modules_cfg==nullptr && cases_cfg==nullptr )
+      {
+        cases_cfg = test_cfg;
+      }
+      
+      // if a list of cases was given
+      if( cases_cfg != nullptr )
+      {
+        if((rc = _exec_cases(test,module_label,module_args,cases_cfg)) != kOkRC )
+          goto errLabel;
+        
+      }
+      
+    errLabel:
+      return rc;
+    }
+    
+  }
+}
+
+cw::rc_t cw::test::test( const struct object_str* cfg, int argc, const char** argv )
+{
+  test_t test = {};
+  rc_t rc = kOkRC;
+  
+  if((rc = _parse_args(test, cfg, argc, argv )) != kOkRC )
+  {
+    rc = cwLogError(rc,"Test arguments parse failed.");
+    goto errLabel;
+  }
+
+  if((rc = _proc_test_cfg(test,"/",test.test_cfg)) != kOkRC )
+  {
+    goto errLabel;
+  }
+
+errLabel:
+  
+  cwLogInfo("Test Gen Count:%i.",test.gen_cnt);
+  
+  if( test.compare_fl )
+    cwLogInfo("Test Compare - ok:%i fail:%i.",test.compare_ok_cnt,test.compare_fail_cnt);
+
+  if( rc != kOkRC )
+    rc = cwLogError(rc,"Testing process failed.");
+    
+      
+  return rc;
+
+}
+
+
diff --git a/cwTest.h b/cwTest.h
new file mode 100644
index 0000000..f39538c
--- /dev/null
+++ b/cwTest.h
@@ -0,0 +1,31 @@
+#ifndef cwTest_h
+#define cwTest_h
+
+namespace cw
+{
+  struct object_str;
+  
+  namespace test
+  {
+    
+    typedef struct test_args_str
+    {
+      const char*              module_label;  // test module this test belongs to
+      const char*              test_label;    // test label
+      const struct object_str* module_args;   // arguments for all tests in this module
+      const struct object_str* test_args;     // arguments specific to this test
+      const char*              rsrc_dir;      // input data dir. for this test
+      const char*              out_dir;       // output data dir. for this test
+      int                      argc;          // cmd line arg count
+      const char**             argv;          // cmd line arg's
+        
+    } test_args_t;
+
+    typedef rc_t (*test_func_t)(const test_args_t& args);
+    
+    rc_t test( const struct object_str* cfg, int argc, const char** argv );
+  
+  }
+}
+
+#endif

From 3e8e0e2830e168d00e6ab54ea7f46fe7a44c9a75 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 29 May 2024 12:33:13 -0400
Subject: [PATCH 099/101] cwFlowTest.cpp : Flow testing is now managed via
 cwTest.

---
 cwFlowTest.cpp | 317 +++++--------------------------------------------
 1 file changed, 31 insertions(+), 286 deletions(-)

diff --git a/cwFlowTest.cpp b/cwFlowTest.cpp
index 6e8c74c..30c4050 100644
--- a/cwFlowTest.cpp
+++ b/cwFlowTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwNumericConvert.h"
@@ -14,318 +15,61 @@
 #include "cwFlowTest.h"
 
 
-#include "cwFile.h"
-#include "cwFileSys.h"
-
-namespace cw
+cw::rc_t cw::flow::test( const test::test_args_t& args )
 {
-  namespace flow
+  rc_t        rc               = kOkRC;
+  const char* proc_cfg_fname   = nullptr;
+  const char* subnet_cfg_fname = nullptr;
+  object_t*   class_cfg        = nullptr;
+  object_t*   subnet_cfg       = nullptr;
+  handle_t    flowH;
+
+  if( args.module_args == nullptr )
   {
-    typedef struct exec_test_str
-    {
-      void*                  logCbArg;
-      log::logOutputCbFunc_t logCbFunc;
-      file::handle_t         logFileH;
-    } exec_test_t;
-
-    rc_t _compare_dirs( const char* dir0, const char* dir1, const char* test_name )
-    {
-      rc_t                 rc          = kOkRC;
-      rc_t                 testRC      = kOkRC;
-      unsigned             dirRefN     = 0;
-      filesys::dirEntry_t* dirRefA     = nullptr;
-      char*                testRefDir  = nullptr;
-      unsigned             testRefDirN = 0;
-      filesys::dirEntry_t* testRefDirA = nullptr;
-      unsigned             testCnt     = 0;
-      unsigned             failCnt     = 0;
-
-      // get a list of sub-directories in the ref. directory
-      if((dirRefA = filesys::dirEntries( dir0, filesys::kDirFsFl, &dirRefN )) == nullptr )
-      {
-        rc = cwLogError(kOpFailRC,"An error occurred while attempting to read the list of sub-directories in '%s'.",cwStringNullGuard(dir0));
-        goto errLabel;
-      }
-
-      // for each test
-      for(unsigned i=0; i<dirRefN; ++i)
-        if( dirRefA[i].name != nullptr && (test_name==nullptr || textIsEqual(dirRefA[i].name,test_name)) )
-        {
-          // form the test directory
-          if(( testRefDir = filesys::makeFn( dir0, nullptr, nullptr, dirRefA[i].name, nullptr )) == nullptr )
-          {
-            rc = cwLogError(kOpFailRC,"Test directory formation failed on '%s' and '%s'.",cwStringNullGuard(dir0),cwStringNullGuard(dirRefA[i].name));
-            goto errLabel;
-          }
-
-          // get the list of files in the test directory
-          if((testRefDirA = filesys::dirEntries( testRefDir, filesys::kFileFsFl, &testRefDirN )) == nullptr )
-          {            
-            rc = cwLogError(kOpFailRC,"An error occurred while attempting to read the list of file from '%s'.",cwStringNullGuard(testRefDir));
-            goto errLabel;
-          }
-
-          testCnt += 1;
-
-          // for each file 
-          for(unsigned j=0; rc==kOkRC && j<testRefDirN; ++j)
-            if( testRefDirA[j].name != nullptr )
-            {
-              char* testRefFn = filesys::makeFn( dir0, testRefDirA[j].name, nullptr, dirRefA[i].name, nullptr ); 
-              char* testCmpFn = filesys::makeFn( dir1, testRefDirA[j].name, nullptr, dirRefA[i].name, nullptr );
-              bool  isEqualFl = false;
-
-              // compare two files
-              if((rc = file::compare( testRefFn, testCmpFn, isEqualFl)) != kOkRC )
-                rc = cwLogError(rc,"The comparison failed on '%s' == '%s'.",cwStringNullGuard(testRefFn),cwStringNullGuard(testCmpFn));
-              else
-              {
-                // if the test failed
-                if( !isEqualFl )
-                {
-                  cwLogInfo("Test failed on: '%s'",testRefFn);
-                  failCnt += 1;
-                }
-              }
-              
-              mem::release(testRefFn);
-              mem::release(testCmpFn);              
-            }
-
-          mem::release(testRefDirA);
-          mem::release(testRefDir);
-        }
-
-      mem::release(dirRefA);
-      
-    errLabel:
-
-      mem::release(testRefDirA);
-      mem::release(testRefDir);
-      mem::release(dirRefA);
-
-      cwLogInfo("Tests:%i failed:%i",testCnt,failCnt);
-      
-      return rc;
-
-    }
-    
-    
-    void _exec_test_log_cb( void* cbArg, unsigned level, const char* text )
-    {
-      rc_t rc;
-      exec_test_t* r = (exec_test_t*)cbArg;
-      
-      if((rc = file::print(r->logFileH,text)) != kOkRC )
-        cwLogError(rc,"Log file write failed for '%s'.text");
-      
-      if( r->logCbFunc != nullptr )
-        r->logCbFunc( r->logCbArg,level,text);
-    }
-
-    rc_t _exec_test(  const object_t* class_cfg,
-                      const object_t* subnet_cfg,
-                      const object_t* test_cfg,
-                      const char* proj_base_dir,
-                      const char* test_case_label  )
-    {
-      rc_t            rc        = kOkRC;
-      char*           proj_dir  = nullptr;
-      char*           log_fname = nullptr;
-      exec_test_t     test_recd;
-      handle_t        flowH;
-
-      // save the log to a 
-      test_recd.logCbArg  = log::outputCbArg( log::globalHandle() );
-      test_recd.logCbFunc = log::outputCb(    log::globalHandle() );
-      
-      // form the projectory directory name
-      if((proj_dir = filesys::makeFn(proj_base_dir,nullptr,nullptr,test_case_label,nullptr)) == nullptr )
-      {
-        rc = cwLogError(kOpFailRC,"The project directory name could not be formed from '%s' and '%s'.",cwStringNullGuard(proj_base_dir),cwStringNullGuard(test_case_label));
-        goto errLabel;
-      }
-
-      // create the project directory
-      if( !filesys::isDir(proj_dir) )
-      {
-        if((rc = filesys::makeDir(proj_dir)) != kOkRC )
-        {
-          rc = cwLogError(kOpFailRC,"The project directory '%s' could not be created.",proj_dir);
-          goto errLabel;
-        }
-      }
-
-      // form the log file name
-      if((log_fname = filesys::makeFn( proj_dir, "log","txt",nullptr )) == nullptr )
-      {
-        rc = cwLogError(kOpFailRC,"The log file name could not be formed from the project directory.",cwStringNullGuard(proj_dir));
-        goto errLabel;
-      }
-
-      // open the log file
-      if((rc = file::open(test_recd.logFileH, log_fname,file::kWriteFl)) != kOkRC )
-      {
-        rc = cwLogError(rc,"The log file '%s' could not be created.",cwStringNullGuard(log_fname));
-        goto errLabel;
-      }
-
-      log::setOutputCb( log::globalHandle(), _exec_test_log_cb, &test_recd );
-      
-      // create the flow object
-      if((rc = create( flowH, class_cfg, test_cfg, subnet_cfg, proj_dir)) != kOkRC )
-      {
-        rc = cwLogError(rc,"Flow object create failed.");
-        goto errLabel;
-      }
-
-      // run the network
-      if((rc = exec( flowH )) != kOkRC )
-        rc = cwLogError(rc,"Execution failed.");
-    
-
-      // destroy the flow object
-      if((rc = destroy(flowH)) != kOkRC )
-      {
-        rc = cwLogError(rc,"Close the flow object.");
-        goto errLabel;
-      }
-
-    errLabel:
-
-      file::close(test_recd.logFileH);      
-      log::setOutputCb( log::globalHandle(), test_recd.logCbFunc, test_recd.logCbArg );
-      mem::release(log_fname);
-      mem::release(proj_dir);
-      
-      return rc;
-    }    
-  }
-} 
-
-cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
-{
-  rc_t            rc               = kOkRC;
-  const char*     proc_cfg_fname   = nullptr;
-  const char*     subnet_cfg_fname = nullptr;
-  const object_t* test_cases_cfg   = nullptr;
-  object_t*       class_cfg        = nullptr;
-  object_t*       subnet_cfg       = nullptr;
-  const object_t* test_cfg         = nullptr;
-  const char*     proj_dir         = nullptr;
-  const char*     test_ref_dir     = nullptr;
-  bool            cmp_enable_fl    = false;
-  const char*     test_name        = nullptr;  
-  bool            test_all_fl      = false;
-
-  if( argc < 2 || textLength(argv[1]) == 0 )
-  {
-    rc = cwLogError(kInvalidArgRC,"No 'test-case' label was given on the command line.");
+    rc = cwLogError(kInvalidArgRC,"The flow test cases require module args.");
     goto errLabel;
   }
-
-  test_name   = argv[1];
-  test_all_fl = textIsEqual(test_name,"all");
   
-  if((rc = cfg->getv("proc_cfg_fname",proc_cfg_fname,
-                     "test_cases",    test_cases_cfg,
-                     "project_dir",   proj_dir)) != kOkRC )
+  if((rc = args.module_args->readv("proc_cfg_fname",0,proc_cfg_fname,
+                                   "subnet_cfg_fname",0,subnet_cfg_fname)) != kOkRC )
   {
-    rc = cwLogError(rc,"The name of the flow_proc_dict file could not be parsed.");
+    rc = cwLogError(rc,"Flow module arg's parse failed.");
     goto errLabel;
   }
-
-  // was 'compare' requested
-  if( argc > 2 && textLength(argv[2])!=0 and textIsEqual(argv[2],"compare") )
-    cmp_enable_fl = true;
-    
-
-  // get the subnet cfg filename
-  if((rc = cfg->getv_opt("subnet_cfg_fname",subnet_cfg_fname,
-                         "test_ref_dir",test_ref_dir)) != kOkRC )
-  {
-    rc = cwLogError(rc,"The name of the subnet file could not be parsed.");
-    goto errLabel;
-  }
-
+  
   // parse the proc dict. file
   if((rc = objectFromFile(proc_cfg_fname,class_cfg)) != kOkRC )
   {
-    rc = cwLogError(rc,"The proc dictionary could not be read from '%s'.",cwStringNullGuard(proc_cfg_fname));
+    rc = cwLogError(rc,"The flow proc dictionary could not be read from '%s'.",cwStringNullGuard(proc_cfg_fname));
     goto errLabel;
   }
 
   // parse the subnet dict file
   if((rc = objectFromFile(subnet_cfg_fname,subnet_cfg)) != kOkRC )
   {
-    rc = cwLogError(rc,"The subnet dictionary could not be read from '%s'.",cwStringNullGuard(subnet_cfg_fname));
+    rc = cwLogError(rc,"The flow subnet dictionary could not be read from '%s'.",cwStringNullGuard(subnet_cfg_fname));
     goto errLabel;
   }
 
-  // validate the project directory
-  if( proj_dir!=nullptr && !filesys::isDir(proj_dir) )
+  // create the flow object
+  if((rc = create( flowH, class_cfg, args.test_args, subnet_cfg, args.out_dir)) != kOkRC )
   {
-    if((rc = filesys::makeDir(proj_dir)) != kOkRC )
-    {
-      rc = cwLogError(rc,"The project directory '%s' could not be created.",cwStringNullGuard(proj_dir));
-    }
+    rc = cwLogError(rc,"Flow object create failed.");
+    goto errLabel;
   }
 
-  // for each test
-  for(unsigned i=0; i<test_cases_cfg->child_count(); ++i)
+  // run the network
+  if((rc = exec( flowH )) != kOkRC )
+    rc = cwLogError(rc,"Execution failed.");
+    
+errLabel:
+  // destroy the flow object
+  if((rc = destroy(flowH)) != kOkRC )
   {
-    const object_t* test_cfg_pair       = test_cases_cfg->child_ele(i);
-    const char*     test_label          = nullptr;
-    bool            is_test_disabled_fl = false;
-
-    // validate the test cfg pair
-    if(test_cfg_pair == nullptr || !test_cfg_pair->is_pair() || (test_label = test_cfg_pair->pair_label()) == nullptr || (test_cfg=test_cfg_pair->pair_value())==nullptr || !test_cfg->is_dict())
-    {
-      rc = cwLogError(kSyntaxErrorRC,"A syntax error was encountered on the test at index %i (%s).",i,cwStringNullGuard(test_label));
-      goto errLabel;
-    }
-
-    // get the 'disabled flag'
-    if((rc = test_cfg->getv_opt("testDisableFl",is_test_disabled_fl)) != kOkRC )
-    {
-      rc = cwLogError(kSyntaxErrorRC,"An error occurred while parsing the 'testDisableFl'.");
-      goto errLabel;
-    }
-
-    // if this test is disabled
-    if( is_test_disabled_fl )  
-    {
-      if( !test_all_fl )
-      {
-        rc = cwLogError(kInvalidArgRC,"The requested test '%s' is disabled.",test_label);
-        goto errLabel;
-      }
-      continue;
-    }
-
-    // if we are testing all test or this specific test
-    if( test_all_fl || textIsEqual(test_name,test_label) )
-    {
-      if((rc = _exec_test(class_cfg,subnet_cfg,test_cfg,proj_dir,test_label)) != kOkRC )
-      {
-        rc = cwLogError(kOpFailRC,"Test execution failed on '%s'.",cwStringNullGuard(test_label));
-        goto errLabel;
-      }
-
-      if( !test_all_fl )
-        break;
-    }
+    rc = cwLogError(rc,"Close the flow object.");
+    goto errLabel;
   }
 
-  // if comparision is enabled
-  if( test_ref_dir != nullptr && cmp_enable_fl )
-  {
-    const char* sel_test_name = test_all_fl ? nullptr : test_name;
-    _compare_dirs( test_ref_dir, proj_dir, sel_test_name );
-  }
-  
-  
- errLabel:
   if( class_cfg != nullptr )
     class_cfg->free();
 
@@ -333,4 +77,5 @@ cw::rc_t cw::flow::test(  const object_t* cfg, int argc, const char* argv[] )
     subnet_cfg->free();
   
   return rc;
+  
 }

From 91fad53d33ab2c7deb20524dc3c5f5e70dc68690 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 29 May 2024 12:36:57 -0400
Subject: [PATCH 100/101] Added "#include cwTest.h"  dependency to most *.cpp
 files.

---
 cwAudioBuf.cpp          | 1 +
 cwAudioDevice.cpp       | 1 +
 cwAudioDeviceAlsa.cpp   | 1 +
 cwAudioDeviceFile.cpp   | 1 +
 cwAudioDeviceTest.cpp   | 1 +
 cwAudioFile.cpp         | 1 +
 cwAudioFileOps.cpp      | 1 +
 cwAudioFileProc.cpp     | 1 +
 cwAudioTransforms.cpp   | 1 +
 cwB23Tree.cpp           | 1 +
 cwCsv.cpp               | 1 +
 cwDataSets.cpp          | 1 +
 cwDnsSd.cpp             | 1 +
 cwDsp.cpp               | 1 +
 cwDspTransforms.cpp     | 1 +
 cwDynRefTbl.cpp         | 1 +
 cwEuCon.cpp             | 1 +
 cwFile.cpp              | 2 ++
 cwFlow.cpp              | 1 +
 cwFlowCross.cpp         | 1 +
 cwFlowNet.cpp           | 1 +
 cwFlowProc.cpp          | 1 +
 cwFlowTypes.cpp         | 1 +
 cwGutimReg.cpp          | 1 +
 cwIo.cpp                | 1 +
 cwIoAudioMidi.cpp       | 1 +
 cwIoAudioMidiApp.cpp    | 1 +
 cwIoAudioPanel.cpp      | 1 +
 cwIoAudioRecordPlay.cpp | 1 +
 cwIoFlow.cpp            | 1 +
 cwIoMidiRecordPlay.cpp  | 1 +
 cwIoMinTest.cpp         | 1 +
 cwIoPresetSelApp.cpp    | 1 +
 cwIoSocketChat.cpp      | 1 +
 cwIoTest.cpp            | 1 +
 cwLib.cpp               | 1 +
 cwLog.cpp               | 1 +
 cwMdns.cpp              | 1 +
 cwMidi.cpp              | 1 +
 cwMidiAlsa.cpp          | 1 +
 cwMidiDevice.cpp        | 1 +
 cwMidiDeviceTest.cpp    | 1 +
 cwMidiFile.cpp          | 1 +
 cwMidiFileDev.cpp       | 1 +
 cwMidiParser.cpp        | 1 +
 cwMidiState.cpp         | 1 +
 cwMtx.cpp               | 1 +
 cwMutex.cpp             | 1 +
 cwNbMpScQueue.cpp       | 1 +
 cwPerfMeas.cpp          | 1 +
 cwPianoScore.cpp        | 1 +
 cwPresetSel.cpp         | 1 +
 cwPvAudioFileProc.cpp   | 1 +
 cwScoreFollowTest.cpp   | 1 +
 cwScoreFollower.cpp     | 1 +
 cwScoreParse.cpp        | 1 +
 cwScoreTest.cpp         | 1 +
 cwSfAnalysis.cpp        | 1 +
 cwSfMatch.cpp           | 1 +
 cwSfScore.cpp           | 1 +
 cwSfTrack.cpp           | 1 +
 cwSvgMidi.cpp           | 1 +
 cwSvgScoreFollow.cpp    | 1 +
 cwUi.cpp                | 1 +
 cwUiTest.cpp            | 1 +
 cwVelTableTuner.cpp     | 1 +
 cwWebSock.cpp           | 2 +-
 cwWebSockSvr.cpp        | 1 +
 68 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/cwAudioBuf.cpp b/cwAudioBuf.cpp
index e8dfdee..905925f 100644
--- a/cwAudioBuf.cpp
+++ b/cwAudioBuf.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwTextBuf.h"
diff --git a/cwAudioDevice.cpp b/cwAudioDevice.cpp
index b46e81d..a1c40f5 100644
--- a/cwAudioDevice.cpp
+++ b/cwAudioDevice.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwAudioDevice.h"
diff --git a/cwAudioDeviceAlsa.cpp b/cwAudioDeviceAlsa.cpp
index c866342..cf070ee 100644
--- a/cwAudioDeviceAlsa.cpp
+++ b/cwAudioDeviceAlsa.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwTextBuf.h"
diff --git a/cwAudioDeviceFile.cpp b/cwAudioDeviceFile.cpp
index c64f7d4..24a0dc5 100644
--- a/cwAudioDeviceFile.cpp
+++ b/cwAudioDeviceFile.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwFile.h"
diff --git a/cwAudioDeviceTest.cpp b/cwAudioDeviceTest.cpp
index cdc4dda..1c18429 100644
--- a/cwAudioDeviceTest.cpp
+++ b/cwAudioDeviceTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwTextBuf.h"
diff --git a/cwAudioFile.cpp b/cwAudioFile.cpp
index 02b6724..a303524 100644
--- a/cwAudioFile.cpp
+++ b/cwAudioFile.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwObject.h"
diff --git a/cwAudioFileOps.cpp b/cwAudioFileOps.cpp
index 03e71bd..93994f3 100644
--- a/cwAudioFileOps.cpp
+++ b/cwAudioFileOps.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwText.h"
diff --git a/cwAudioFileProc.cpp b/cwAudioFileProc.cpp
index 13c9c1b..88782cd 100644
--- a/cwAudioFileProc.cpp
+++ b/cwAudioFileProc.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwText.h"
diff --git a/cwAudioTransforms.cpp b/cwAudioTransforms.cpp
index d36022a..d85a253 100644
--- a/cwAudioTransforms.cpp
+++ b/cwAudioTransforms.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwText.h"
diff --git a/cwB23Tree.cpp b/cwB23Tree.cpp
index d028cf9..70e3bf9 100644
--- a/cwB23Tree.cpp
+++ b/cwB23Tree.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwB23Tree.h"
diff --git a/cwCsv.cpp b/cwCsv.cpp
index 3db4498..e42d9e1 100644
--- a/cwCsv.cpp
+++ b/cwCsv.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwFile.h"
diff --git a/cwDataSets.cpp b/cwDataSets.cpp
index 127327b..8365665 100644
--- a/cwDataSets.cpp
+++ b/cwDataSets.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwFile.h"
diff --git a/cwDnsSd.cpp b/cwDnsSd.cpp
index cbff1d5..31525c5 100644
--- a/cwDnsSd.cpp
+++ b/cwDnsSd.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 
diff --git a/cwDsp.cpp b/cwDsp.cpp
index 7962a69..4f4d513 100644
--- a/cwDsp.cpp
+++ b/cwDsp.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwUtility.h"
 #include "cwMath.h"
diff --git a/cwDspTransforms.cpp b/cwDspTransforms.cpp
index 2195964..29b1841 100644
--- a/cwDspTransforms.cpp
+++ b/cwDspTransforms.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwText.h"
diff --git a/cwDynRefTbl.cpp b/cwDynRefTbl.cpp
index 407c80d..a263c84 100644
--- a/cwDynRefTbl.cpp
+++ b/cwDynRefTbl.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwEuCon.cpp b/cwEuCon.cpp
index f7b482f..55b19ce 100644
--- a/cwEuCon.cpp
+++ b/cwEuCon.cpp
@@ -2,6 +2,7 @@
 
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 
 #include "cwMem.h"
 #include "cwTime.h"
diff --git a/cwFile.cpp b/cwFile.cpp
index e8a35bd..dcb845a 100644
--- a/cwFile.cpp
+++ b/cwFile.cpp
@@ -1,6 +1,8 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
+#include "cwObject.h"
 #include "cwMem.h"
 #include "cwFileSys.h"
 #include "cwText.h"
diff --git a/cwFlow.cpp b/cwFlow.cpp
index a67bb5d..f85cf86 100644
--- a/cwFlow.cpp
+++ b/cwFlow.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwNumericConvert.h"
diff --git a/cwFlowCross.cpp b/cwFlowCross.cpp
index 4589c94..de5c646 100644
--- a/cwFlowCross.cpp
+++ b/cwFlowCross.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwFlowNet.cpp b/cwFlowNet.cpp
index a1b4223..4798a20 100644
--- a/cwFlowNet.cpp
+++ b/cwFlowNet.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwNumericConvert.h"
diff --git a/cwFlowProc.cpp b/cwFlowProc.cpp
index 9d693d2..e6c7e8e 100644
--- a/cwFlowProc.cpp
+++ b/cwFlowProc.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwFlowTypes.cpp b/cwFlowTypes.cpp
index 024a752..bfe8743 100644
--- a/cwFlowTypes.cpp
+++ b/cwFlowTypes.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwMath.h"
 #include "cwText.h"
diff --git a/cwGutimReg.cpp b/cwGutimReg.cpp
index 32e746c..dc28247 100644
--- a/cwGutimReg.cpp
+++ b/cwGutimReg.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwIo.cpp b/cwIo.cpp
index fa2d66e..814aba1 100644
--- a/cwIo.cpp
+++ b/cwIo.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwText.h"
diff --git a/cwIoAudioMidi.cpp b/cwIoAudioMidi.cpp
index 0c60b5f..e13be74 100644
--- a/cwIoAudioMidi.cpp
+++ b/cwIoAudioMidi.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwFileSys.h"
diff --git a/cwIoAudioMidiApp.cpp b/cwIoAudioMidiApp.cpp
index a048411..9f45845 100644
--- a/cwIoAudioMidiApp.cpp
+++ b/cwIoAudioMidiApp.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwText.h"
diff --git a/cwIoAudioPanel.cpp b/cwIoAudioPanel.cpp
index 27d5b06..609f91b 100644
--- a/cwIoAudioPanel.cpp
+++ b/cwIoAudioPanel.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwObject.h"
diff --git a/cwIoAudioRecordPlay.cpp b/cwIoAudioRecordPlay.cpp
index 831ddb4..a8abc5b 100644
--- a/cwIoAudioRecordPlay.cpp
+++ b/cwIoAudioRecordPlay.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwFileSys.h"
diff --git a/cwIoFlow.cpp b/cwIoFlow.cpp
index 57402ec..3492127 100644
--- a/cwIoFlow.cpp
+++ b/cwIoFlow.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwFileSys.h"
diff --git a/cwIoMidiRecordPlay.cpp b/cwIoMidiRecordPlay.cpp
index 161e2ff..26c35b4 100644
--- a/cwIoMidiRecordPlay.cpp
+++ b/cwIoMidiRecordPlay.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwIoMinTest.cpp b/cwIoMinTest.cpp
index 27597bd..fa05d69 100644
--- a/cwIoMinTest.cpp
+++ b/cwIoMinTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwKeyboard.h"
 #include "cwMem.h"
 #include "cwObject.h"
diff --git a/cwIoPresetSelApp.cpp b/cwIoPresetSelApp.cpp
index 64227e3..52ca530 100644
--- a/cwIoPresetSelApp.cpp
+++ b/cwIoPresetSelApp.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwNumericConvert.h"
diff --git a/cwIoSocketChat.cpp b/cwIoSocketChat.cpp
index 6343804..8efe48a 100644
--- a/cwIoSocketChat.cpp
+++ b/cwIoSocketChat.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwTime.h"
diff --git a/cwIoTest.cpp b/cwIoTest.cpp
index 94c27ed..801e4b5 100644
--- a/cwIoTest.cpp
+++ b/cwIoTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwTime.h"
diff --git a/cwLib.cpp b/cwLib.cpp
index a66cd6d..eaf9747 100644
--- a/cwLib.cpp
+++ b/cwLib.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFileSys.h"
 #include "cwLib.h"
diff --git a/cwLog.cpp b/cwLog.cpp
index 7fa533c..f37863f 100644
--- a/cwLog.cpp
+++ b/cwLog.cpp
@@ -2,6 +2,7 @@
 #include "cwLog.h"
 
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 
diff --git a/cwMdns.cpp b/cwMdns.cpp
index 55d5760..8d1221a 100644
--- a/cwMdns.cpp
+++ b/cwMdns.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 
 #include "cwThread.h"
diff --git a/cwMidi.cpp b/cwMidi.cpp
index f73b9c4..3d19722 100644
--- a/cwMidi.cpp
+++ b/cwMidi.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwMidi.h"
diff --git a/cwMidiAlsa.cpp b/cwMidiAlsa.cpp
index bc33b7f..7b6c85c 100644
--- a/cwMidiAlsa.cpp
+++ b/cwMidiAlsa.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwText.h"
diff --git a/cwMidiDevice.cpp b/cwMidiDevice.cpp
index f36845d..fc290bf 100644
--- a/cwMidiDevice.cpp
+++ b/cwMidiDevice.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwObject.h"
diff --git a/cwMidiDeviceTest.cpp b/cwMidiDeviceTest.cpp
index 174dcd3..9f4df64 100644
--- a/cwMidiDeviceTest.cpp
+++ b/cwMidiDeviceTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwObject.h"
diff --git a/cwMidiFile.cpp b/cwMidiFile.cpp
index 9731650..95b8e27 100644
--- a/cwMidiFile.cpp
+++ b/cwMidiFile.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwObject.h"
diff --git a/cwMidiFileDev.cpp b/cwMidiFileDev.cpp
index 9978e87..42fd52f 100644
--- a/cwMidiFileDev.cpp
+++ b/cwMidiFileDev.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwFile.h"
diff --git a/cwMidiParser.cpp b/cwMidiParser.cpp
index 0ea317d..458ef27 100644
--- a/cwMidiParser.cpp
+++ b/cwMidiParser.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwMidi.h"
diff --git a/cwMidiState.cpp b/cwMidiState.cpp
index 197603f..8781d2a 100644
--- a/cwMidiState.cpp
+++ b/cwMidiState.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwText.h"
diff --git a/cwMtx.cpp b/cwMtx.cpp
index 30eb58e..27982d2 100644
--- a/cwMtx.cpp
+++ b/cwMtx.cpp
@@ -2,6 +2,7 @@
 #include "cwLog.h"
 #include "cwCommonImpl.h"
 #include "cwMem.h"
+#include "cwTest.h"
 #include "cwObject.h"
 #include "cwVectOps.h"
 #include "cwMtx.h"
diff --git a/cwMutex.cpp b/cwMutex.cpp
index 4b8df35..af98d46 100644
--- a/cwMutex.cpp
+++ b/cwMutex.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwMutex.h"
 #include "cwTime.h"
diff --git a/cwNbMpScQueue.cpp b/cwNbMpScQueue.cpp
index 2f21581..d64e698 100644
--- a/cwNbMpScQueue.cpp
+++ b/cwNbMpScQueue.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwObject.h"
diff --git a/cwPerfMeas.cpp b/cwPerfMeas.cpp
index 999a355..392d1b9 100644
--- a/cwPerfMeas.cpp
+++ b/cwPerfMeas.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwFile.h"
diff --git a/cwPianoScore.cpp b/cwPianoScore.cpp
index 1fa8c24..9305f9e 100644
--- a/cwPianoScore.cpp
+++ b/cwPianoScore.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwPresetSel.cpp b/cwPresetSel.cpp
index 2e07769..2ab9278 100644
--- a/cwPresetSel.cpp
+++ b/cwPresetSel.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwPvAudioFileProc.cpp b/cwPvAudioFileProc.cpp
index ee37283..f4d54c3 100644
--- a/cwPvAudioFileProc.cpp
+++ b/cwPvAudioFileProc.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwText.h"
diff --git a/cwScoreFollowTest.cpp b/cwScoreFollowTest.cpp
index da158ca..f3de48b 100644
--- a/cwScoreFollowTest.cpp
+++ b/cwScoreFollowTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwScoreFollower.cpp b/cwScoreFollower.cpp
index 7412a8e..975dbbe 100644
--- a/cwScoreFollower.cpp
+++ b/cwScoreFollower.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwScoreParse.cpp b/cwScoreParse.cpp
index f4158fd..0956166 100644
--- a/cwScoreParse.cpp
+++ b/cwScoreParse.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwScoreTest.cpp b/cwScoreTest.cpp
index 653cc25..e5964d2 100644
--- a/cwScoreTest.cpp
+++ b/cwScoreTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwSfAnalysis.cpp b/cwSfAnalysis.cpp
index 26044e8..4cf3866 100644
--- a/cwSfAnalysis.cpp
+++ b/cwSfAnalysis.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFile.h"
 #include "cwObject.h"
diff --git a/cwSfMatch.cpp b/cwSfMatch.cpp
index 89bf5b0..8428ec9 100644
--- a/cwSfMatch.cpp
+++ b/cwSfMatch.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwSfScore.cpp b/cwSfScore.cpp
index bb9119c..b868e20 100644
--- a/cwSfScore.cpp
+++ b/cwSfScore.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwSfTrack.cpp b/cwSfTrack.cpp
index f718de7..1004147 100644
--- a/cwSfTrack.cpp
+++ b/cwSfTrack.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwSvgMidi.cpp b/cwSvgMidi.cpp
index 1c39877..33f5b83 100644
--- a/cwSvgMidi.cpp
+++ b/cwSvgMidi.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwText.h"
diff --git a/cwSvgScoreFollow.cpp b/cwSvgScoreFollow.cpp
index 880ea7d..4266187 100644
--- a/cwSvgScoreFollow.cpp
+++ b/cwSvgScoreFollow.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwObject.h"
 #include "cwText.h"
diff --git a/cwUi.cpp b/cwUi.cpp
index 722ca9f..d0020e6 100644
--- a/cwUi.cpp
+++ b/cwUi.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwTime.h"
 #include "cwFileSys.h"
diff --git a/cwUiTest.cpp b/cwUiTest.cpp
index 48054b9..b7da65c 100644
--- a/cwUiTest.cpp
+++ b/cwUiTest.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwThread.h"
 #include "cwWebSock.h"
diff --git a/cwVelTableTuner.cpp b/cwVelTableTuner.cpp
index 6df6938..cabe9af 100644
--- a/cwVelTableTuner.cpp
+++ b/cwVelTableTuner.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwText.h"
 #include "cwObject.h"
diff --git a/cwWebSock.cpp b/cwWebSock.cpp
index e8a682d..cb6eac7 100644
--- a/cwWebSock.cpp
+++ b/cwWebSock.cpp
@@ -1,7 +1,7 @@
-
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwFileSys.h"
 #include "cwObject.h"
diff --git a/cwWebSockSvr.cpp b/cwWebSockSvr.cpp
index 9c083c8..3267d43 100644
--- a/cwWebSockSvr.cpp
+++ b/cwWebSockSvr.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwMem.h"
 #include "cwWebSock.h"
 #include "cwThread.h"

From 24f9b937a6e06f4eeb9151d753553cb2e6b07037 Mon Sep 17 00:00:00 2001
From: kevin <kevin@larke.org>
Date: Wed, 29 May 2024 12:37:53 -0400
Subject: [PATCH 101/101] cwFileSys,cwLex,cwVectOps,cwObject,cwTime : Updated
 to use cwTest to manage test() function.

---
 Makefile.am   |   8 +--
 cwFileSys.cpp |  36 +++++++++++-
 cwFileSys.h   |   2 +
 cwFlowTest.h  |   2 +-
 cwLex.cpp     |   5 +-
 cwLex.h       |   2 +-
 cwObject.cpp  | 155 +++++++++++++++++++++++++++++++++++++++++++-------
 cwObject.h    |   2 +
 cwTime.cpp    |  15 ++---
 cwTime.h      |   2 +-
 cwVectOps.cpp |  15 +++++
 cwVectOps.h   |  13 ++---
 12 files changed, 213 insertions(+), 44 deletions(-)
 create mode 100644 cwVectOps.cpp

diff --git a/Makefile.am b/Makefile.am
index 5fbc7e0..82f0f8d 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -4,8 +4,8 @@ libcwSRC =
 libcwHDR += src/libcw/cwCommon.h src/libcw/cwCommonImpl.h   src/libcw/cwMem.h   src/libcw/cwLog.h    src/libcw/cwUtility.h
 libcwSRC +=                      src/libcw/cwCommonImpl.cpp src/libcw/cwMem.cpp src/libcw/cwLog.cpp  src/libcw/cwUtility.cpp
 
-libcwHDR += src/libcw/cwString.h   src/libcw/cwMath.h   src/libcw/cwVectOps.h src/libcw/cwMtx.h    src/libcw/cwVariant.h
-libcwSRC += src/libcw/cwString.cpp src/libcw/cwMath.cpp                       src/libcw/cwMtx.cpp  src/libcw/cwVariant.cpp
+libcwHDR += src/libcw/cwString.h   src/libcw/cwMath.h   src/libcw/cwVectOps.h   src/libcw/cwMtx.h    src/libcw/cwVariant.h
+libcwSRC += src/libcw/cwString.cpp src/libcw/cwMath.cpp src/libcw/cwVectOps.cpp src/libcw/cwMtx.cpp  src/libcw/cwVariant.cpp
 
 libcwHDR += src/libcw/cwB23Tree.h
 libcwSRC += src/libcw/cwB23Tree.cpp
@@ -46,8 +46,8 @@ libcwSRC +=                       src/libcw/cwUi.cpp src/libcw/cwUiTest.cpp
 
 endif
 
-libcwHDR += src/libcw/cwKeyboard.h
-libcwSRC += src/libcw/cwKeyboard.cpp
+libcwHDR += src/libcw/cwKeyboard.h    src/libcw/cwTest.h
+libcwSRC += src/libcw/cwKeyboard.cpp  src/libcw/cwTest.cpp
 
 libcwHDR += src/libcw/cwSerialPortDecls.h src/libcw/cwSerialPort.h    src/libcw/cwSerialPortSrv.h
 libcwSRC +=                               src/libcw/cwSerialPort.cpp  src/libcw/cwSerialPortSrv.cpp
diff --git a/cwFileSys.cpp b/cwFileSys.cpp
index 6661082..9574f50 100644
--- a/cwFileSys.cpp
+++ b/cwFileSys.cpp
@@ -1,8 +1,12 @@
 #include "cwCommon.h"
 #include "cwLog.h"
+#include "cwCommonImpl.h"
+
+#include "cwTest.h"
+#include "cwObject.h"
 
 #include "cwFileSys.h"
-#include "cwCommonImpl.h"
+
 #include "cwMem.h"
 #include "cwString.h"
 #include "cwText.h"
@@ -893,3 +897,33 @@ cw::rc_t cw::filesys::makeDir( const char* dirStr )
   
   return kOkRC;
 }
+
+
+cw::rc_t cw::filesys::test( const test::test_args_t& args )
+{
+  rc_t rc = kOkRC;
+
+  filesys::pathPart_t* pp = filesys::pathParts(__FILE__);
+  
+  cwLogPrint("dir:%s",pp->dirStr);
+  cwLogPrint("fn: %s",pp->fnStr);
+  cwLogPrint("ext:%s",pp->extStr);
+
+  char* fn = filesys::makeFn( pp->dirStr, pp->fnStr, pp->extStr, nullptr );
+
+  cwLogPrint("fn: %s",fn);
+
+  mem::release(pp);
+  mem::release(fn);
+
+
+  const char myPath[] = "~/src/foo";
+
+  char* expPath = filesys::expandPath(myPath);
+
+  cwLogPrint("%s %s",myPath,expPath);
+
+  mem::release(expPath);
+  
+  return rc;
+}
diff --git a/cwFileSys.h b/cwFileSys.h
index ae2924c..d55af8c 100644
--- a/cwFileSys.h
+++ b/cwFileSys.h
@@ -90,6 +90,8 @@ namespace cw
     char* makeVersionedDirectory(const char* recordDir, const char* recordFolder );
     
     rc_t makeDir( const char* dirStr );
+
+    rc_t test( const test::test_args_t& args );
   }
   
 }
diff --git a/cwFlowTest.h b/cwFlowTest.h
index 51c40bb..5fb828a 100644
--- a/cwFlowTest.h
+++ b/cwFlowTest.h
@@ -4,6 +4,6 @@ namespace cw
   namespace flow
   {
     
-    rc_t test(  const object_t* cfg, int argc, const char* argv[] );
+    rc_t test( const test::test_args_t& args );
   }
 }
diff --git a/cwLex.cpp b/cwLex.cpp
index da73cc2..91144f2 100644
--- a/cwLex.cpp
+++ b/cwLex.cpp
@@ -3,7 +3,8 @@
 #include "cwCommonImpl.h"
 #include "cwMem.h"
 #include "cwFile.h"
-
+#include "cwTest.h"
+#include "cwObject.h"
 #include "cwLex.h"
 
 
@@ -853,7 +854,7 @@ namespace cw
     //)
 
     //(
-    rc_t test()
+    rc_t test( const test::test_args_t& args )
     {
       rc_t     rc  = kOkRC;
       unsigned tid = kInvalidId;
diff --git a/cwLex.h b/cwLex.h
index c77aafd..9e5a72f 100644
--- a/cwLex.h
+++ b/cwLex.h
@@ -129,7 +129,7 @@ namespace cw
     const char* idToLabel( handle_t h, unsigned typeId );
 
     // Lexer testing stub.
-    rc_t test(  );
+    rc_t test( const test::test_args_t& args );
   }
 }
 
diff --git a/cwObject.cpp b/cwObject.cpp
index 60682f8..f5382db 100644
--- a/cwObject.cpp
+++ b/cwObject.cpp
@@ -5,6 +5,7 @@
 #include "cwCommonImpl.h"
 #include "cwMem.h"
 #include "cwFile.h"
+#include "cwTest.h"
 #include "cwLex.h"
 #include "cwText.h"
 #include "cwNumericConvert.h"
@@ -152,37 +153,37 @@ namespace cw
   void _objTypePrintIndent( const char* text, unsigned indent, const char* indentStr=" " )
   {
     for(unsigned i=0; i<indent; ++i)
-      printf("%s",indentStr);
-    printf("%s",text); 
+      cwLogPrint("%s",indentStr);
+    cwLogPrint("%s",text); 
   }
 
   void _objTypePrintChild( const object_t* o, print_ctx_t& c, const char* eolStr=",\n", const char* indentStr=" " )
   {
     _objTypePrintIndent(" ",c.indent,indentStr);
     o->type->print(o,c);
-    printf("%s",eolStr);
+    cwLogPrint("%s",eolStr);
   }
   
-  void _objTypePrintNull(   const object_t* o, print_ctx_t& c ) { printf("NULL "); }
-  void _objTypePrintError(  const object_t* o, print_ctx_t& c ) { printf("Error "); }
-  void _objTypePrintChar(   const object_t* o, print_ctx_t& c ) { printf("%c",o->u.c); }
-  void _objTypePrintInt8(   const object_t* o, print_ctx_t& c ) { printf("%i",o->u.i8); }
-  void _objTypePrintUInt8(  const object_t* o, print_ctx_t& c ) { printf("%i",o->u.u8); }
-  void _objTypePrintInt16(  const object_t* o, print_ctx_t& c ) { printf("%i",o->u.i16); }
-  void _objTypePrintUInt16( const object_t* o, print_ctx_t& c ) { printf("%i",o->u.u16); }
-  void _objTypePrintInt32(  const object_t* o, print_ctx_t& c ) { printf("%i",o->u.i32); }
-  void _objTypePrintUInt32( const object_t* o, print_ctx_t& c ) { printf("%i",o->u.u32); }
-  void _objTypePrintInt64(  const object_t* o, print_ctx_t& c ) { printf("%lli", o->u.i64); }
-  void _objTypePrintUInt64( const object_t* o, print_ctx_t& c ) { printf("%lli", o->u.u64); }
-  void _objTypePrintBool(   const object_t* o, print_ctx_t& c ) { printf("%s",o->u.b ? "true" : "false"); }
-  void _objTypePrintFloat(  const object_t* o, print_ctx_t& c ) { printf("%f",o->u.f); }
-  void _objTypePrintDouble( const object_t* o, print_ctx_t& c ) { printf("%f",o->u.d); }
-  void _objTypePrintString( const object_t* o, print_ctx_t& c ) { printf("%s",o->u.str); }
-  void _objTypePrintVect(   const object_t* o, print_ctx_t& c ) { printf("<vect>"); }
+  void _objTypePrintNull(   const object_t* o, print_ctx_t& c ) { cwLogPrint("NULL "); }
+  void _objTypePrintError(  const object_t* o, print_ctx_t& c ) { cwLogPrint("Error "); }
+  void _objTypePrintChar(   const object_t* o, print_ctx_t& c ) { cwLogPrint("%c",o->u.c); }
+  void _objTypePrintInt8(   const object_t* o, print_ctx_t& c ) { cwLogPrint("%i",o->u.i8); }
+  void _objTypePrintUInt8(  const object_t* o, print_ctx_t& c ) { cwLogPrint("%i",o->u.u8); }
+  void _objTypePrintInt16(  const object_t* o, print_ctx_t& c ) { cwLogPrint("%i",o->u.i16); }
+  void _objTypePrintUInt16( const object_t* o, print_ctx_t& c ) { cwLogPrint("%i",o->u.u16); }
+  void _objTypePrintInt32(  const object_t* o, print_ctx_t& c ) { cwLogPrint("%i",o->u.i32); }
+  void _objTypePrintUInt32( const object_t* o, print_ctx_t& c ) { cwLogPrint("%i",o->u.u32); }
+  void _objTypePrintInt64(  const object_t* o, print_ctx_t& c ) { cwLogPrint("%lli", o->u.i64); }
+  void _objTypePrintUInt64( const object_t* o, print_ctx_t& c ) { cwLogPrint("%lli", o->u.u64); }
+  void _objTypePrintBool(   const object_t* o, print_ctx_t& c ) { cwLogPrint("%s",o->u.b ? "true" : "false"); }
+  void _objTypePrintFloat(  const object_t* o, print_ctx_t& c ) { cwLogPrint("%f",o->u.f); }
+  void _objTypePrintDouble( const object_t* o, print_ctx_t& c ) { cwLogPrint("%f",o->u.d); }
+  void _objTypePrintString( const object_t* o, print_ctx_t& c ) { cwLogPrint("%s",o->u.str); }
+  void _objTypePrintVect(   const object_t* o, print_ctx_t& c ) { cwLogPrint("<vect>"); }
   void _objTypePrintPair(   const object_t* o, print_ctx_t& c )
   {
     o->u.children->type->print(o->u.children,c);
-    printf(": ");
+    cwLogPrint(": ");
     o->u.children->sibling->type->print(o->u.children->sibling,c);    
   }
   
@@ -1013,4 +1014,118 @@ cw::rc_t cw::objectToFile( const char* fn, const object_t* obj )
   return rc;
 }
 
+namespace cw
+{
+  rc_t _object_test_basic( const test::test_args_t& args )
+  {
+    rc_t          rc   = kOkRC;  
+    cw::object_t* o    = nullptr;
+    const char    s [] = "{ a:1, b:2, c:[ 1.23, 4.56 ], d:true, e:false, f:true }";
+
+    int a = 0;
+    int b = 0;
+    const cw::object_t* c = nullptr;
+    bool d,e,f;
+
+    const unsigned bufN = 128;
+    char buf[bufN];
+
+    unsigned i = 0;
+
+    cw::object_t* oo = nullptr;
+  
+    if((rc = cw::objectFromString(s,o)) != kOkRC )
+      goto errLabel;
+
+    int v;
+    if((rc = o->get("b",v)) != kOkRC )
+      goto errLabel;
+  
+    cwLogPrint("value:%i\n",v);
+  
+    o->print();
+
+  
+    if((rc = o->getv("a",a,"b",b)) != kOkRC )
+      goto errLabel;
+  
+    cwLogPrint("G: %i %i\n",a,b);
+
+
+    if((rc = o->readv("a",0,a,
+                      "b",0,b,
+                      "c",cw::kOptFl | cw::kListTId,c,
+                      "d",0,d,
+                      "e",0,e,
+                      "f",0,f)) != kOkRC )
+    {
+      goto errLabel;
+    }
+  
+    cwLogPrint("R: %i %i : %i %i %i\n",a,b,d,e,f);
+
+  
+    i = o->to_string(buf,bufN);
+    cwLogPrint("%i : %s\n",i, buf);
+  
+    oo = o->duplicate();
+
+    oo->print();
+  
+    oo->free();
+  
+    
+    o->free();
+
+  errLabel:
+    return rc;
+  }
+
+  rc_t _object_test_to_json( const test::test_args_t& args )
+  {
+    double   v0[] = {1.23,2.34,3.45};
+    unsigned v0N  = sizeof(v0)/sizeof(v0[0]);
+    int      v1[] = {-1,0,1,2,3,4};
+    unsigned v1N  = sizeof(v1)/sizeof(v1[0]);
+  
+    cw::object_t* d = cw::newDictObject();
+
+    d->putv("A","Abc","B",1.234);
+    d->put_numeric_list("v0",v0,v0N);
+    d->put_numeric_list("v1",v1,v1N);
+
+    char* s = d->to_string();
+    cwLogPrint("%s\n",s);
+    cw::mem::release(s);
+
+    d->free();
+
+    return kOkRC;
+  
+  }
+
+}
+
+
+cw::rc_t cw::object_test( const test::test_args_t& args )
+{
+  rc_t rc = kOkRC;
+
+  if( textIsEqual(args.test_label,"basic") )
+  {
+    rc = _object_test_basic(args);
+    goto errLabel;
+  }
+  
+  if( textIsEqual(args.test_label,"to_json") )
+  {
+    rc = _object_test_to_json(args);
+    goto errLabel;
+  }
+
+  rc = cwLogError(kInvalidArgRC,"Unknown test case module:%s test:%s.",args.module_label,args.test_label);
+  
+errLabel:
+  return cw::kOkRC;
+}
 
diff --git a/cwObject.h b/cwObject.h
index ed1a6ad..3b937fa 100644
--- a/cwObject.h
+++ b/cwObject.h
@@ -460,6 +460,8 @@ namespace cw
 
   rc_t objectToFile( const char* fn, const object_t* obj );
 
+  rc_t object_test( const test::test_args_t& args );
+
 
 }
 
diff --git a/cwTime.cpp b/cwTime.cpp
index ef7f211..7fd5658 100644
--- a/cwTime.cpp
+++ b/cwTime.cpp
@@ -1,6 +1,7 @@
 #include "cwCommon.h"
 #include "cwLog.h"
 #include "cwCommonImpl.h"
+#include "cwTest.h"
 #include "cwTime.h"
 
 #ifdef OS_OSX
@@ -399,7 +400,7 @@ unsigned cw::time::formatDateTime( char* buffer, unsigned bufN, bool includeDate
   return (unsigned)n;
 }
 
-cw::rc_t cw::time::test()
+cw::rc_t cw::time::test(const test::test_args_t& test )
 {
 
   spec_t t0,t1;
@@ -410,15 +411,15 @@ cw::rc_t cw::time::test()
 
   unsigned dMs = elapsedMs(t0,t1);
 
-  printf("dMs:%i : GTE:%i LTE:%i\n",dMs, isGTE(t0,t1), isLTE(t0,t1) );
+  cwLogPrint("dMs:%i : GTE:%i LTE:%i\n",dMs, isGTE(t0,t1), isLTE(t0,t1) );
 
   
   microsecondsToSpec( t0, 2500000 );        // 2.5 seconds
-  printf("%li %li\n",t0.tv_sec,t0.tv_nsec);
+  cwLogPrint("%li %li\n",t0.tv_sec,t0.tv_nsec);
   subtractMicros( t0, 750000 );             // subtract .75 seconds
-  printf("%li %li\n",t0.tv_sec,t0.tv_nsec);
+  cwLogPrint("%li %li\n",t0.tv_sec,t0.tv_nsec);
   subtractMicros( t0, 500000 );             // subtract .5 seconds
-  printf("%li %li\n",t0.tv_sec,t0.tv_nsec);
+  cwLogPrint("%li %li\n",t0.tv_sec,t0.tv_nsec);
 
 
   time::get(t0);
@@ -429,11 +430,11 @@ cw::rc_t cw::time::test()
   
   int usec = time::elapsedMicros(t0,t1);
 
-  printf("usec:%i\n",usec);
+  cwLogPrint("usec:%i\n",usec);
 
   t0 = current_time();
   sleepMs(1000);
-  printf("sleep %i ms\n",elapsedMs(t0));
+  cwLogPrint("sleep %i ms\n",elapsedMs(t0));
 
 
   return kOkRC;
diff --git a/cwTime.h b/cwTime.h
index 7f1a3ed..5c4d9b7 100644
--- a/cwTime.h
+++ b/cwTime.h
@@ -85,7 +85,7 @@ namespace cw
     // Return count of bytes in in buf[]
     unsigned formatDateTime( char* buf, unsigned bufN, bool includeDateFl=false );
 
-    rc_t test();
+    rc_t test( const test::test_args_t& test );
 
     //)
 
diff --git a/cwVectOps.cpp b/cwVectOps.cpp
new file mode 100644
index 0000000..c8288b8
--- /dev/null
+++ b/cwVectOps.cpp
@@ -0,0 +1,15 @@
+#include "cwCommon.h"
+#include "cwLog.h"
+#include "cwCommonImpl.h"
+#include "cwTest.h"
+#include "cwVectOps.h"
+
+cw::rc_t cw::vop::test( const test::test_args_t& args )
+{
+  int v1[] = { 1,2,1,2,1,2,1,2,1,2 };
+  int v0[ 10 ];
+  
+  cw::vop::deinterleave( v0, v1, 5, 2 );
+  cw::vop::print(v0,10,"%i ");
+  return cw::kOkRC;
+}
diff --git a/cwVectOps.h b/cwVectOps.h
index 277ec11..bc8f087 100644
--- a/cwVectOps.h
+++ b/cwVectOps.h
@@ -17,10 +17,10 @@ namespace cw
       
       if( label != nullptr )
       {
-        printf("%s : ",label);
+        cwLogPrint("%s : ",label);
         if( colN && n > colN )
         {
-          printf("\n");
+          cwLogPrint("\n");
           newline_fl = true;
         }
       }
@@ -30,19 +30,19 @@ namespace cw
       
       for(unsigned i=0; i<n; ++i)
       {
-        printf(fmt,v0[i]);
+        cwLogPrint(fmt,v0[i]);
 
         newline_fl = false;
         
         if( (n+1) % colN == 0 )
         {
-          printf("\n");
+          cwLogPrint("\n");
           newline_fl = true;
         }
       }
 
       if( !newline_fl )
-        printf("\n");
+        cwLogPrint("\n");
     }
 
 
@@ -545,8 +545,7 @@ namespace cw
   
     }
     
-    
-
+    rc_t test( const test::test_args_t& args );
     
   }
 }