Index: libcfa/src/collections/string_res.cfa
===================================================================
--- libcfa/src/collections/string_res.cfa	(revision bc547d37653baaa8e7fac63a33cc9fe1fd2a3b0f)
+++ libcfa/src/collections/string_res.cfa	(revision b7cacebf2e258ce0d8b68e6a73756be899d6b8de)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May  7 13:14:45 2026
-// Update Count     : 135
+// Last Modified On : Mon May 25 16:22:58 2026
+// Update Count     : 316
 //
 
@@ -29,6 +29,20 @@
 //######################### VbyteHeap "header" #########################
 
-#ifdef VbyteDebug
-HandleNode *HeaderPtr;
+//#define VbyteDebug
+#ifdef VbyteDebug
+HandleNode * HeaderPtr;
+
+void printHandleList( HandleNode & s ) with(s) {
+	printf( "HandleList: Header %p\n", HeaderPtr );
+	for ( HandleNode * ni = HeaderPtr;; ) {				// print header node
+		printf( "\tnode:%p lnth:%u s:%p, \"", ni, ni->lnth, ni->s );
+		for ( i; ni->lnth ) {
+			printf( "%c", ni->s[i] );
+		} // for
+		printf( "\" flink:%p blink:%p\n", ni->flink, ni->blink );
+		ni = ni->flink;
+	  if ( ni == HeaderPtr ) break;
+	} // for
+}
 #endif // VbyteDebug
 
@@ -40,7 +54,7 @@
 	int InitSize;										// initial number of bytes in the byte-string area
 	int CurrSize;										// current number of bytes in the byte-string area
-	char *StartVbyte;									// pointer to the `st byte of the start of the byte-string area
-	char *EndVbyte;										// pointer to the next byte after the end of the currently used portion of byte-string area
-	void *ExtVbyte;										// pointer to the next byte after the end of the byte-string area
+	char * StartVbyte;									// pointer to the `st byte of the start of the byte-string area
+	char * EndVbyte;									// pointer to the next byte after the end of the currently used portion of byte-string area
+	void * ExtVbyte;									// pointer to the next byte after the end of the byte-string area
 
 	HandleNode Header;									// header node for handle list
@@ -62,5 +76,5 @@
 static void AddThisAfter( HandleNode &, HandleNode & );
 static void DeleteNode( HandleNode & );
-static void MoveThisAfter( HandleNode &, const HandleNode & ); // move current handle after parameter handle
+static void MoveThisAfter( HandleNode &, HandleNode & ); // move current handle after parameter handle
 
 
@@ -69,5 +83,5 @@
 static void ?{}( VbyteHeap & s, size_t Size ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:VbyteHeap::VbyteHeap, s:" | &s | " Size:" | Size;
+	printf( "enter:VbyteHeap::VbyteHeap, s:%p Size:%zd\n", &s, Size );
 #endif // VbyteDebug
 	NoOfCompactions = NoOfExtensions = NoOfReductions = 0;
@@ -77,7 +91,10 @@
 	Header.flink = Header.blink = &Header;
 	Header.ulink = &s;
+	// Should be unnecessary to initialize.
+	// Header.s = 0p;
+	// Header.lnth = 0;
 #ifdef VbyteDebug
 	HeaderPtr = &Header;
-	serr | "exit:VbyteHeap::VbyteHeap, s:" | &s;
+	printf( "exit:VbyteHeap::VbyteHeap, s:%p\n", &s );
 #endif // VbyteDebug
 } // VbyteHeap
@@ -99,10 +116,11 @@
 static void ?{}( HandleNode & s ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:HandleNode::HandleNode, s:" | &s;
-#endif // VbyteDebug
-	s = 0;
-	lnth = 0;
-#ifdef VbyteDebug
-	serr | "exit:HandleNode::HandleNode, s:" | &s;
+	printf( "enter:HandleNode::HandleNode, s:%p\n", &s );
+#endif // VbyteDebug
+	// Should be unnecessary to initialize.
+	// s = 0p;
+	// lnth = 0;
+#ifdef VbyteDebug
+	printf( "exit:HandleNode::HandleNode, s:%p\n", &s );
 #endif // VbyteDebug
 } // HandleNode
@@ -114,5 +132,5 @@
 static void ?{}( HandleNode & s, VbyteHeap & vh ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:HandleNode::HandleNode, s:" | &s;
+	printf( "enter:HandleNode::HandleNode, s:%p\n", &s );
 #endif // VbyteDebug
 	s = 0;
@@ -121,5 +139,5 @@
 	AddThisAfter( s, *vh.Header.blink );
 #ifdef VbyteDebug
-	serr | "exit:HandleNode::HandleNode, s:" | &s;
+	printf( "exit:HandleNode::HandleNode, s:%p\n", &s );
 #endif // VbyteDebug
 } // HandleNode
@@ -131,13 +149,11 @@
 static void ^?{}( HandleNode & s ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:HandleNode::~HandleNode, s:" | & s;
+	printf( "enter:HandleNode::~HandleNode, s:%p\n", &s );
 	{
-		serr | nlOff;
-		serr | " lnth:" | lnth | " s:" | (void *)s | ",\"";
+		printf( " lnth:%u s:%p,\"", lnth, (void *)s );
 		for ( i; lnth ) {
-			serr | s[i];
+			printf( "%c", s[i] );
 		} // for
-		serr | "\" flink:" | flink | " blink:" | blink | nl;
-		serr | nlOn;
+		printf( "\" flink:%p blink:%p\n", flink, blink );
 	}
 #endif // VbyteDebug
@@ -176,5 +192,5 @@
 
 VbyteHeap * DEBUG_string_heap() {
-	assert( ambient_string_sharectx->activeHeap && "No sharing context is active" );
+//	assert( ambient_string_sharectx->activeHeap && "No sharing context is active" );
 	return ambient_string_sharectx->activeHeap;
 }
@@ -330,5 +346,5 @@
 	s.shareSet_prev = &s;
 	s.shareSet_next = &s;
-		}
+}
 
 static void eagerCopyCtorHelper(string_res & s, const char * rhs, size_t rhslnth) with(s) {
@@ -340,5 +356,5 @@
 		(shareSet_owns_ulink){ true };
 	}
-	Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
+	Handle.s = VbyteAlloc( *Handle.ulink, rhslnth );
 	Handle.lnth = rhslnth;
 	memmove( Handle.s, rhs, rhslnth );
@@ -392,5 +408,5 @@
 void ?{}( string_res & s, VbyteHeap & heap, const char * rhs, size_t rhslnth ) with(s) {
 	(Handle){ heap };
-	Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
+	Handle.s = VbyteAlloc( *Handle.ulink, rhslnth );
 	Handle.lnth = rhslnth;
 	(s.shareSet_owns_ulink){ false };
@@ -398,4 +414,8 @@
 	s.shareSet_prev = &s;
 	s.shareSet_next = &s;
+#ifdef VbyteDebug
+	printHandleList( s.Handle );
+	printf( "exit:constructor, s:%p\n", &s );
+#endif // VbyteDebug
 }
 
@@ -535,4 +555,9 @@
 
 static string_res & assign_(string_res & s, const char * buffer, size_t bsize, const string_res & valSrc) {
+#ifdef VbyteDebug
+	printf( "enter:assign_\n" );
+	printHandleList( s.Handle );
+#endif // VbyteDebug
+
 	string_res * shareSetStartPeer;
 	string_res * shareSetEndPeer;
@@ -614,4 +639,9 @@
 	}
 
+#ifdef VbyteDebug
+	printHandleList( s.Handle );
+	printf( "exit:assign_\n" );
+#endif // VbyteDebug
+
 	return s;
 }
@@ -708,9 +738,14 @@
 
 void append(string_res & str1, const char * buffer, size_t bsize) {
+#ifdef VbyteDebug
+	printf( "enter append %p %p %zd\n", &str1, buffer, bsize );
+	printHandleList( str1.Handle );
+#endif // VbyteDebug
 	size_t clnth = str1.Handle.lnth + bsize;
 	if ( str1.Handle.s + str1.Handle.lnth == buffer ) { // already juxtapose ?
 		// no-op
 	} else {											// must copy some text
-		if ( str1.Handle.s + str1.Handle.lnth == VbyteAlloc(*str1.Handle.ulink, 0) ) { // str1 at end of string area ?
+//		if ( str1.Handle.s + str1.Handle.lnth == VbyteAlloc(*str1.Handle.ulink, 0) ) { // str1 at end of string area ?
+		if ( str1.Handle.s + str1.Handle.lnth == str1.Handle.ulink->EndVbyte ) { // str1 at end of string area ?
 			VbyteAlloc( *str1.Handle.ulink, bsize );	// create room for 2nd part at the end of string area
 		} else {										// copy the two parts
@@ -723,4 +758,8 @@
 	} // if
 	str1.Handle.lnth = clnth;
+#ifdef VbyteDebug
+	printHandleList( str1.Handle );
+	printf( "exit append\n" );
+#endif // VbyteDebug
 }
 
@@ -938,5 +977,5 @@
 static void AddThisAfter( HandleNode & s, HandleNode & n ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:AddThisAfter, s:" | &s | " n:" | &n;
+	printf( "enter:AddThisAfter, s:%p n:%p\n", &s, &n );
 #endif // VbyteDebug
 	// Performance note: we are on the critical path here. MB has ensured that the verifies don't contribute to runtime (are compiled away, like they're supposed to be).
@@ -948,17 +987,6 @@
 	n.flink = &s;
 #ifdef VbyteDebug
-	{
-		serr | "HandleList:";
-		serr | nlOff;
-		for ( HandleNode *ni = HeaderPtr->flink; ni != HeaderPtr; ni = ni->flink ) {
-			serr | "\tnode:" | ni | " lnth:" | ni->lnth | " s:" | (void *)ni->s | ",\"";
-			for ( i; ni->lnth ) {
-				serr | ni->s[i];
-			} // for
-			serr | "\" flink:" | ni->flink | " blink:" | ni->blink | nl;
-		} // for
-		serr | nlOn;
-	}
-	serr | "exit:AddThisAfter";
+	printHandleList( s );
+	printf( "exit:AddThisAfter\n" );
 #endif // VbyteDebug
 } // AddThisAfter
@@ -969,10 +997,12 @@
 static void DeleteNode( HandleNode & s ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:DeleteNode, s:" | &s;
+	printf( "enter:DeleteNode, s:%p\n", &s );
+	printHandleList( s );
 #endif // VbyteDebug
 	flink->blink = blink;
 	blink->flink = flink;
 #ifdef VbyteDebug
-	serr | "exit:DeleteNode";
+	printHandleList( s );
+	printf( "exit:DeleteNode\n" );
 #endif // VbyteDebug
 } //  DeleteNode
@@ -984,5 +1014,5 @@
 static char * VbyteAlloc( VbyteHeap & s, int size ) with(s) {
 #ifdef VbyteDebug
-	serr | "enter:VbyteAlloc, size:" | size;
+	printf( "enter:VbyteAlloc, size:%d\n", size );
 #endif // VbyteDebug
 	uintptr_t NoBytes;
@@ -997,5 +1027,5 @@
 	EndVbyte += size;
 #ifdef VbyteDebug
-	serr | "exit:VbyteAlloc, r:" | (void *)r | " EndVbyte:" | (void *)EndVbyte | " ExtVbyte:" | ExtVbyte;
+	printf( "exit:VbyteAlloc, r:%p EndVbyte:%p ExtVbyte:%p\n", (void *)r, (void *)EndVbyte, ExtVbyte );
 #endif // VbyteDebug
 	return r;
@@ -1029,40 +1059,24 @@
 
 
-// Move an existing HandleNode node h somewhere after the current HandleNode node so that it is in ascending order by
-// the address in the byte string area.
-
-static void MoveThisAfter( HandleNode & s, const HandleNode  & h ) with(s) {
-#ifdef VbyteDebug
-	serr | "enter:MoveThisAfter, s:" | & s | " h:" | & h;
+// Move HandleNode node s somewhere after the HandleNode node h so that it is in ascending order by the address in the
+// byte string area.
+
+static void MoveThisAfter( HandleNode & s, HandleNode & h ) with(s) {
+#ifdef VbyteDebug
+	printf( "enter:MoveThisAfter, s:%p h:%p\n", &s, &h );
 #endif // VbyteDebug
 	verify( h.ulink != 0p );
 	verify( s.ulink == h.ulink );
-	if ( s < h.s ) {					// check argument values
-		// serr | "VbyteSM: Error - Cannot move byte string starting at:" | s | " after byte string starting at:"
-		//	  | ( h->s ) | " and keep handles in ascending order";
-		// exit(-1 );
-		verify( 0 && "VbyteSM: Error - Cannot move byte strings as requested and keep handles in ascending order");
-	} // if
+	verify( s < h.s && "VbyteSM: Error - Cannot move byte strings as requested and keep handles in ascending order" );
 
 	HandleNode *i;
-	for ( i = h.flink; i->s != 0 && s > ( i->s ); i = i->flink ); // find the position for this node after h
-	if ( & s != i->blink ) {
+	for ( i = h.flink; i != &s.ulink->Header && s > i->s; i = i->flink ); // find the position for this node after h
+	if ( &s != i->blink ) {								// s just after h ? => nothing to move
 		DeleteNode( s );
 		AddThisAfter( s, *i->blink );
 	} // if
 #ifdef VbyteDebug
-	{
-		serr | "HandleList:";
-		serr | nlOff;
-		for ( HandleNode *n = HeaderPtr->flink; n != HeaderPtr; n = n->flink ) {
-			serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
-			for ( i; n->lnth ) {
-				serr | n->s[i];
-			} // for
-			serr | "\" flink:" | n->flink | " blink:" | n->blink | nl;
-		} // for
-		serr | nlOn;
-	}
-	serr | "exit:MoveThisAfter";
+	printHandleList( s );
+	printf( "exit:MoveThisAfter\n" );
 #endif // VbyteDebug
 } // MoveThisAfter
@@ -1079,5 +1093,5 @@
 int ByteCmp( char *Src1, int Src1Start, int Src1Lnth, char *Src2, int Src2Start, int Src2Lnth )  {
 #ifdef VbyteDebug
-	serr | "enter:ByteCmp, Src1Start:" | Src1Start | " Src1Lnth:" | Src1Lnth | " Src2Start:" | Src2Start | " Src2Lnth:" | Src2Lnth;
+	printf( "enter:ByteCmp, Src1Start:%d Src1Lnth:%d Src2Start:%d Src2Lnth:%d", Src1Start, Src1Lnth, Src2Start, Src2Lnth );
 #endif // VbyteDebug
 	int cmp;
@@ -1115,5 +1129,5 @@
 	} // for
 #ifdef VbyteDebug
-	serr | "exit:ByteCmp, cmp:" | cmp;
+	printf( "exit:ByteCmp, cmp:%d\n", cmp );
 #endif // VbyteDebug
 	return cmp;
@@ -1126,12 +1140,14 @@
 // the containing string has been moved. Hence, they only require that their string pointers be adjusted.
 
-void compaction(VbyteHeap & s) with(s) {
-	HandleNode *h;
-	char *obase, *nbase, *limit;
+void compaction( VbyteHeap & s ) with(s) {
+#ifdef VbyteDebug
+	printf( "enter compaction\n" );
+	printHandleList( Header );
+#endif // VbyteDebug
+	char * obase, * nbase, * limit;
 	
 	NoOfCompactions += 1;
 	EndVbyte = StartVbyte;
-	h = Header.flink;					// ignore header node
-	for () {
+	for ( HandleNode * h = Header.flink; h != &Header; ) {
 		memmove( EndVbyte, h->s, h->lnth );
 		obase = h->s;
@@ -1141,15 +1157,14 @@
 		limit = obase + h->lnth;
 		h = h->flink;
-		
 		// check if any substrings are allocated within a string
-		
-		for () {
-			if ( h == &Header ) break;			// end of header list ?
-			if ( h->s >= limit ) break;			// outside of current string ?
+		for ( ; h != &Header; h = h->flink ) {
+			if ( h->s >= limit )  break;				// outside of current string ?
 			h->s = nbase + (( uintptr_t )h->s - ( uintptr_t )obase );
-			h = h->flink;
 		} // for
-		if ( h == &Header ) break;			// end of header list ?
 	} // for
+#ifdef VbyteDebug
+	printHandleList( Header );
+	printf( "exit compaction\n" );
+#endif // VbyteDebug
 } // compaction
 
@@ -1166,19 +1181,8 @@
 // the heap.  The heap is then compacted in the existing heap or into the newly allocated heap.
 
-void garbage(VbyteHeap & s, int minreq ) with(s) {
-#ifdef VbyteDebug
-	serr | "enter:garbage";
-	{
-		serr | "HandleList:";
-		for ( HandleNode *n = Header.flink; n != &Header; n = n->flink ) {
-			serr | nlOff;
-			serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
-			for ( i; n->lnth ) {
-				serr | n->s[i];
-			} // for
-			serr | nlOn;
-			serr | "\" flink:" | n->flink | " blink:" | n->blink;
-		} // for
-	}
+void garbage( VbyteHeap & s, int minreq ) with(s) {
+#ifdef VbyteDebug
+	printf( "enter:garbage\n" );
+	printHandleList( Header );
 #endif // VbyteDebug
 	int AmountUsed, AmountFree;
@@ -1204,22 +1208,8 @@
 	}// if
 #ifdef VbyteDebug
-	{
-		serr | "HandleList:";
-		for ( HandleNode *n = Header.flink; n != &Header; n = n->flink ) {
-			serr | nlOff;
-			serr | "\tnode:" | n | " lnth:" | n->lnth | " s:" | (void *)n->s | ",\"";
-			for ( i; n->lnth ) {
-				serr | n->s[i];
-			} // for
-			serr | nlOn;
-			serr | "\" flink:" | n->flink | " blink:" | n->blink;
-		} // for
-	}
-	serr | "exit:garbage";
+	printHandleList( Header );
+	printf( "exit:garbage\n" );
 #endif // VbyteDebug
 } // garbage
-
-#undef VbyteDebug
-
 
 
@@ -1229,5 +1219,5 @@
 void extend( VbyteHeap & s, int size ) with (s) {
 #ifdef VbyteDebug
-	serr | "enter:extend, size:" | size;
+	printf( "enter:extend, size:%d", size );
 #endif // VbyteDebug
 	char *OldStartVbyte;
@@ -1242,5 +1232,5 @@
 	free( OldStartVbyte );				// release old heap
 #ifdef VbyteDebug
-	serr | "exit:extend, CurrSize:" | CurrSize;
+	printf( "exit:extend, CurrSize: %d\n", CurrSize );
 #endif // VbyteDebug
 } // extend
@@ -1248,5 +1238,4 @@
 //WIP
 #if 0
-
 // Extend the size of the byte-string area by creating a new area and copying the old area into it. The old byte-string
 // area is deleted.
@@ -1254,5 +1243,5 @@
 void VbyteHeap::reduce( int size ) {
 #ifdef VbyteDebug
-	serr | "enter:reduce, size:" | size;
+	printf( "enter:reduce, size: %d", size );
 #endif // VbyteDebug
 	char *OldStartVbyte;
@@ -1267,8 +1256,6 @@
 	delete  OldStartVbyte;				// release old heap
 #ifdef VbyteDebug
-	!serr | "exit:reduce, CurrSize:" | CurrSize;
+	printf( "exit:reduce, CurrSize: %d", CurrSize );
 #endif // VbyteDebug
 } // reduce
-
-
-#endif
+#endif // 0
Index: libcfa/src/collections/string_res.hfa
===================================================================
--- libcfa/src/collections/string_res.hfa	(revision bc547d37653baaa8e7fac63a33cc9fe1fd2a3b0f)
+++ libcfa/src/collections/string_res.hfa	(revision b7cacebf2e258ce0d8b68e6a73756be899d6b8de)
@@ -10,6 +10,6 @@
 // Created On       : Fri Sep 03 11:00:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May  7 13:14:04 2026
-// Update Count     : 83
+// Last Modified On : Mon May 11 18:56:08 2026
+// Update Count     : 84
 //
 
@@ -31,5 +31,5 @@
 
 	char * s;											// pointer to byte string
-	unsigned int lnth;									// length of byte string
+	size_t lnth;										// length of byte string
 }; // HandleNode