Fix truncate: slice by runes not bytes to avoid invalid UTF-8 (#98)

truncate() was using s[:max-1] (byte slice) to shorten strings before
embedding in SVG. For multi-byte UTF-8 characters (é, Ñ, Ü, 日, etc.)
the slice position could fall inside a character's byte sequence,
producing invalid UTF-8 in the generated SVG.

Fix: convert to []rune, truncate by rune count, convert back.

Reproducer: truncate("Über", 2) returned "\xc3…" (invalid UTF-8);
now returns "Ü…".

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: greynewell

internal/archdocs/pssg/render/shareimage.go

@@ -25,12 +25,13 @@ func svgEscape(s string) string {
 	return s
 }
 
-// truncate limits string length with ellipsis.
+// truncate limits string length (in runes) with ellipsis.
 func truncate(s string, max int) string {
-	if len(s) <= max {
+	runes := []rune(s)
+	if len(runes) <= max {
 		return s
 	}
-	return s[:max-1] + "\u2026"
+	return string(runes[:max-1]) + "\u2026"
 }
 
 // svgScaffold wraps content in the standard share image scaffold.

internal/archdocs/pssg/render/shareimage_test.go

@@ -0,0 +1,61 @@
+package render
+
+import (
+	"testing"
+	"unicode/utf8"
+)
+
+func TestTruncateASCII(t *testing.T) {
+	cases := []struct {
+		input string
+		max   int
+		want  string
+	}{
+		{"hello", 10, "hello"},       // short — no truncation
+		{"hello", 5, "hello"},        // exactly max — no truncation
+		{"hello world", 6, "hello…"}, // truncated to 5 runes + ellipsis
+		{"", 5, ""},                  // empty string
+	}
+	for _, c := range cases {
+		got := truncate(c.input, c.max)
+		if got != c.want {
+			t.Errorf("truncate(%q, %d) = %q, want %q", c.input, c.max, got, c.want)
+		}
+	}
+}
+
+// TestTruncateMultiByte verifies that truncate does not slice inside a multi-byte
+// UTF-8 character sequence, which would produce invalid UTF-8 in the SVG output.
+// Before the fix, truncate used byte-based slicing: s[:max-1].
+// For a string like "Ñandú" (6 runes but 8 bytes), truncating at max=3 would
+// compute s[:2] = [0xC3, 0x9C] — the first 2 bytes of "Ñ" — yielding "Ñ"
+// rather than the expected "Ña". The important invariant is that the output is
+// always valid UTF-8 and has exactly min(len(runes), max) rune-units.
+func TestTruncateMultiByte(t *testing.T) {
+	cases := []struct {
+		input string
+		max   int
+		want  string
+	}{
+		// "Über" is 4 runes, 6 bytes (Ü = 2 bytes)
+		{"Über", 10, "Über"}, // no truncation
+		{"Über", 4, "Über"},  // exactly max runes — no truncation
+		{"Über", 3, "Üb…"},   // 2 runes + ellipsis
+		{"Über", 2, "Ü…"},    // 1 rune + ellipsis
+
+		// "Ñandú" is 5 runes, 7 bytes
+		{"Ñandú", 4, "Ñan…"}, // 3 runes + ellipsis
+
+		// "日本語" is 3 runes, 9 bytes (each char = 3 bytes)
+		{"日本語テスト", 4, "日本語…"}, // 3 runes + ellipsis
+	}
+	for _, c := range cases {
+		got := truncate(c.input, c.max)
+		if got != c.want {
+			t.Errorf("truncate(%q, %d) = %q, want %q", c.input, c.max, got, c.want)
+		}
+		if !utf8.ValidString(got) {
+			t.Errorf("truncate(%q, %d) = %q — result is not valid UTF-8", c.input, c.max, got)
+		}
+	}
+}