@diagrammo/dgmo 0.2.28 → 0.3.1

package/docs/language-reference.md

@@ -44,6 +44,41 @@ Set via CLI: `dgmo diagram.dgmo --palette catppuccin --theme dark`
 
 Text fields support: `*italic*`, `**bold**`, `` `code` ``, `[link text](url)`. Bare URLs are auto-linked.
 
+### Multi-line Values
+
+Properties that accept comma-separated lists (`series`, `columns`, `rows`, `x-axis`, `y-axis`) also accept an indented multi-line format. Leave the value after the colon empty and list each value on its own indented line:
+
+```
+// Single-line (still works)
+series: Rum, Spices, Silk, Gold
+
+// Multi-line equivalent
+series:
+  Rum
+  Spices
+  Silk
+  Gold
+```
+
+Multi-line blocks support blank lines and `//` comments within the block. Trailing commas on values are stripped for convenience.
+
+```
+series:
+  Rum (red)
+  Spices (green)
+  // gold last
+  Gold (yellow)
+```
+
+Works with `columns:` and `rows:` in heatmaps:
+
+```
+columns:
+  January
+  February
+  March
+```
+
 ---
 
 ## Chart Types
@@ -441,7 +476,10 @@ Animal
   + speak(): void
 
 Dog extends Animal
+  + breed: string
+
 Cat extends Animal
+  + indoor: boolean
 ```
 
 Full example:
@@ -453,38 +491,37 @@ title: Type Hierarchy
 Printable [interface]
   + print(): void
 
-Shape [abstract]
+Shape implements Printable [abstract]
   # x: number
   # y: number
   + area(): number
-  {static} count: number
+  count: number {static}
 
-Circle
+Circle extends Shape
   - radius: number
   + area(): number
 
-Rectangle
+Rectangle extends Shape
   - width: number
   - height: number
 
-Circle extends Shape
-Rectangle extends Shape
-Shape implements Printable
 Shape *-- Circle : contains
 ```
 
 **Class modifiers**: `[abstract]`, `[interface]`, `[enum]`
 
+**Inheritance**: `ClassName extends Parent` or `ClassName implements Interface` — declared inline in the class header. Members are indented below.
+
 **Member visibility**: `+` public, `#` protected, `-` private. Static: `{static}`.
 
-**Relationships** (keyword or arrow):
-- Inheritance: `A extends B` or `A --|> B`
-- Implementation: `A implements B` or `A ..|> B`
-- Composition: `A contains B` or `A *-- B`
-- Aggregation: `A has B` or `A o-- B`
-- Dependency: `A uses B` or `A ..> B`
+**Relationships** (arrow syntax):
+- Inheritance: `A --|> B`
+- Implementation: `A ..|> B`
+- Composition: `A *-- B`
+- Aggregation: `A o-- B`
+- Dependency: `A ..> B`
 - Association: `A -> B`
-- Optional label: `A extends B : description`
+- Optional label: `A *-- B : description`
 
 ### er
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.2.28",
+  "version": "0.3.1",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "type": "module",
@@ -50,11 +50,11 @@
     "d3-scale": "^4.0.2",
     "d3-selection": "^3.0.0",
     "d3-shape": "^3.2.0",
-    "echarts": "^5.6.0",
+    "echarts": "^6.0.0",
     "lz-string": "^1.5.0"
   },
   "optionalDependencies": {
-    "jsdom": "^26.0.0"
+    "jsdom": "^28.1.0"
   },
   "devDependencies": {
     "@types/d3-array": "^3.2.1",
@@ -63,11 +63,11 @@
     "@types/d3-scale": "^4.0.8",
     "@types/d3-selection": "^3.0.11",
     "@types/d3-shape": "^3.1.7",
-    "@types/dagre": "^0.7.53",
-    "@types/jsdom": "^21.1.7",
+    "@types/dagre": "^0.7.54",
+    "@types/jsdom": "^28.0.0",
     "jscpd": "^4.0.8",
     "tsup": "^8.5.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.0"
+    "vitest": "^4.0.18"
   }
 }

package/src/chart.ts

@@ -47,6 +47,7 @@ export interface ParsedChart {
 import { resolveColor } from './colors';
 import type { PaletteColors } from './palettes';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
+import { collectIndentedValues } from './utils/parsing';
 
 // ============================================================
 // Parser
@@ -181,12 +182,17 @@ export function parseChart(
     }
 
     if (key === 'series') {
-      result.series = value;
-      // Parse comma-separated series names for multi-series chart types
-      const rawNames = value
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean);
+      // Parse series names — comma-separated on one line, or indented multi-line
+      let rawNames: string[];
+      if (value) {
+        result.series = value;
+        rawNames = value.split(',').map((s) => s.trim()).filter(Boolean);
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        rawNames = collected.values;
+        result.series = rawNames.join(', ');
+      }
       const names: string[] = [];
       const nameColors: (string | undefined)[] = [];
       for (const raw of rawNames) {

package/src/class/layout.ts

@@ -87,7 +87,7 @@ function computeNodeDimensions(node: ClassNode): {
   const headerHeight = HEADER_BASE + (node.modifier ? MODIFIER_BADGE : 0);
 
   // Fields compartment
-  let fieldsHeight = 0;
+  let fieldsHeight: number;
   if (isEnum) {
     // Enum values go in fields compartment
     const enumValues = node.members; // all members are enum values
@@ -96,6 +96,8 @@ function computeNodeDimensions(node: ClassNode): {
         COMPARTMENT_PADDING_Y * 2 +
         enumValues.length * MEMBER_LINE_HEIGHT +
         SEPARATOR_HEIGHT;
+    } else {
+      fieldsHeight = SEPARATOR_HEIGHT + COMPARTMENT_PADDING_Y;
     }
   } else {
     if (fields.length > 0) {
@@ -103,24 +105,27 @@ function computeNodeDimensions(node: ClassNode): {
         COMPARTMENT_PADDING_Y * 2 +
         fields.length * MEMBER_LINE_HEIGHT +
         SEPARATOR_HEIGHT;
+    } else {
+      // UML: always show attributes compartment
+      fieldsHeight = SEPARATOR_HEIGHT + COMPARTMENT_PADDING_Y;
     }
   }
 
   // Methods compartment (not for enums)
   let methodsHeight = 0;
-  if (!isEnum && methods.length > 0) {
-    methodsHeight =
-      COMPARTMENT_PADDING_Y * 2 +
-      methods.length * MEMBER_LINE_HEIGHT +
-      SEPARATOR_HEIGHT;
+  if (!isEnum) {
+    if (methods.length > 0) {
+      methodsHeight =
+        COMPARTMENT_PADDING_Y * 2 +
+        methods.length * MEMBER_LINE_HEIGHT +
+        SEPARATOR_HEIGHT;
+    } else {
+      // UML: always show methods compartment
+      methodsHeight = SEPARATOR_HEIGHT + COMPARTMENT_PADDING_Y;
+    }
   }
 
-  // If no members at all, add minimal padding
-  const height =
-    headerHeight +
-    fieldsHeight +
-    methodsHeight +
-    (fieldsHeight === 0 && methodsHeight === 0 ? 4 : 0);
+  const height = headerHeight + fieldsHeight + methodsHeight;
 
   return { width, height, headerHeight, fieldsHeight, methodsHeight };
 }

package/src/class/parser.ts

@@ -6,7 +6,6 @@ import type {
   ParsedClassDiagram,
   ClassNode,
   ClassMember,
-  ClassRelationship,
   ClassModifier,
   MemberVisibility,
   RelationshipType,
@@ -24,14 +23,9 @@ function classId(name: string): string {
 // Regex patterns
 // ============================================================
 
-// Class declaration: ClassName [modifier] (color)
+// Class declaration: ClassName [extends|implements ParentClass] [modifier] (color)
 const CLASS_DECL_RE =
-  /^([A-Z][A-Za-z0-9_]*)(?:\s+\[(abstract|interface|enum)\])?(?:\s+\(([^)]+)\))?\s*$/;
-
-// Relationship — keyword syntax:
-// ClassName extends|implements|contains|has|uses TargetClass : label
-const REL_KEYWORD_RE =
-  /^([A-Z][A-Za-z0-9_]*)\s+(extends|implements|contains|has|uses)\s+([A-Z][A-Za-z0-9_]*)(?:\s*:\s*(.+))?$/;
+  /^([A-Z][A-Za-z0-9_]*)(?:\s+(extends|implements)\s+([A-Z][A-Za-z0-9_]*))?(?:\s+\[(abstract|interface|enum)\])?(?:\s+\(([^)]+)\))?\s*$/;
 
 // Relationship — arrow syntax:
 // ClassName --|> TargetClass : label
@@ -45,14 +39,6 @@ const STATIC_SUFFIX_RE = /\{static\}\s*$/;
 const METHOD_RE = /^(.+?)\(([^)]*)\)(?:\s*:\s*(.+))?$/;
 const FIELD_RE = /^(.+?)\s*:\s*(.+)$/;
 
-const KEYWORD_TO_TYPE: Record<string, RelationshipType> = {
-  extends: 'extends',
-  implements: 'implements',
-  contains: 'composes',
-  has: 'aggregates',
-  uses: 'depends',
-};
-
 const ARROW_TO_TYPE: Record<string, RelationshipType> = {
   '--|>': 'extends',
   '..|>': 'implements',
@@ -257,28 +243,6 @@ export function parseClassDiagram(
     currentClass = null;
     contentStarted = true;
 
-    // Try relationship — keyword syntax
-    const relKeyword = trimmed.match(REL_KEYWORD_RE);
-    if (relKeyword) {
-      const sourceName = relKeyword[1];
-      const keyword = relKeyword[2].toLowerCase();
-      const targetName = relKeyword[3];
-      const label = relKeyword[4]?.trim();
-
-      // Ensure both classes exist
-      getOrCreateClass(sourceName, lineNumber);
-      getOrCreateClass(targetName, lineNumber);
-
-      result.relationships.push({
-        source: classId(sourceName),
-        target: classId(targetName),
-        type: KEYWORD_TO_TYPE[keyword],
-        ...(label && { label }),
-        lineNumber,
-      });
-      continue;
-    }
-
     // Try relationship — arrow syntax
     const relArrow = trimmed.match(REL_ARROW_RE);
     if (relArrow) {
@@ -305,8 +269,10 @@ export function parseClassDiagram(
     const classDecl = trimmed.match(CLASS_DECL_RE);
     if (classDecl) {
       const name = classDecl[1];
-      const modifier = classDecl[2] as ClassModifier | undefined;
-      const colorName = classDecl[3]?.trim();
+      const relKeyword = classDecl[2] as 'extends' | 'implements' | undefined;
+      const parentName = classDecl[3];
+      const modifier = classDecl[4] as ClassModifier | undefined;
+      const colorName = classDecl[5]?.trim();
       const color = colorName ? resolveColor(colorName, palette) : undefined;
 
       const node = getOrCreateClass(name, lineNumber);
@@ -315,6 +281,17 @@ export function parseClassDiagram(
       // Update line number to the declaration line (may have been created by relationship)
       node.lineNumber = lineNumber;
 
+      // Inline extends/implements creates a relationship
+      if (relKeyword && parentName) {
+        getOrCreateClass(parentName, lineNumber);
+        result.relationships.push({
+          source: classId(name),
+          target: classId(parentName),
+          type: relKeyword as RelationshipType,
+          lineNumber,
+        });
+      }
+
       currentClass = node;
       continue;
     }
@@ -376,9 +353,10 @@ export function looksLikeClassDiagram(content: string): boolean {
         hasModifier = true;
         hasClassDecl = true;
       }
-      // Check for relationship keywords
-      if (REL_KEYWORD_RE.test(trimmed)) {
+      // Check for inline extends/implements in class declaration
+      if (/^[A-Z][A-Za-z0-9_]*\s+(extends|implements)\s+[A-Z]/.test(trimmed)) {
         hasRelationship = true;
+        hasClassDecl = true;
       }
       // Check for relationship arrows
       if (REL_ARROW_RE.test(trimmed)) {

package/src/class/renderer.ts

@@ -406,43 +406,42 @@ export function renderClassDiagram(
     const methods = node.members.filter((m) => m.isMethod);
 
     if (isEnum) {
-      // Enum: all members as values
-      if (node.members.length > 0) {
-        // Separator
-        nodeG.append('line')
-          .attr('x1', -w / 2)
-          .attr('y1', yPos)
-          .attr('x2', w / 2)
-          .attr('y2', yPos)
-          .attr('stroke', stroke)
-          .attr('stroke-width', 0.5)
-          .attr('stroke-opacity', 0.5);
-
-        let memberY = yPos + COMPARTMENT_PADDING_Y;
-        for (const member of node.members) {
-          nodeG.append('text')
-            .attr('x', -w / 2 + MEMBER_PADDING_X)
-            .attr('y', memberY + MEMBER_LINE_HEIGHT / 2)
-            .attr('dominant-baseline', 'central')
-            .attr('fill', palette.text)
-            .attr('font-size', MEMBER_FONT_SIZE)
-            .text(member.name);
-          memberY += MEMBER_LINE_HEIGHT;
-        }
+      // Enum: single values compartment
+      // Separator
+      nodeG.append('line')
+        .attr('x1', -w / 2)
+        .attr('y1', yPos)
+        .attr('x2', w / 2)
+        .attr('y2', yPos)
+        .attr('stroke', stroke)
+        .attr('stroke-width', 0.5)
+        .attr('stroke-opacity', 0.5);
+
+      let memberY = yPos + COMPARTMENT_PADDING_Y;
+      for (const member of node.members) {
+        nodeG.append('text')
+          .attr('x', -w / 2 + MEMBER_PADDING_X)
+          .attr('y', memberY + MEMBER_LINE_HEIGHT / 2)
+          .attr('dominant-baseline', 'central')
+          .attr('fill', palette.text)
+          .attr('font-size', MEMBER_FONT_SIZE)
+          .text(member.name);
+        memberY += MEMBER_LINE_HEIGHT;
       }
     } else {
-      // Fields compartment
-      if (fields.length > 0) {
-        // Separator
-        nodeG.append('line')
-          .attr('x1', -w / 2)
-          .attr('y1', yPos)
-          .attr('x2', w / 2)
-          .attr('y2', yPos)
-          .attr('stroke', stroke)
-          .attr('stroke-width', 0.5)
-          .attr('stroke-opacity', 0.5);
+      // UML 3-compartment layout: always show both separators
+
+      // Fields separator
+      nodeG.append('line')
+        .attr('x1', -w / 2)
+        .attr('y1', yPos)
+        .attr('x2', w / 2)
+        .attr('y2', yPos)
+        .attr('stroke', stroke)
+        .attr('stroke-width', 0.5)
+        .attr('stroke-opacity', 0.5);
 
+      if (fields.length > 0) {
         let memberY = yPos + COMPARTMENT_PADDING_Y;
         for (const field of fields) {
           const vis = visibilitySymbol(field.visibility);
@@ -463,21 +462,20 @@ export function renderClassDiagram(
 
           memberY += MEMBER_LINE_HEIGHT;
         }
-        yPos += node.fieldsHeight;
       }
+      yPos += node.fieldsHeight;
+
+      // Methods separator
+      nodeG.append('line')
+        .attr('x1', -w / 2)
+        .attr('y1', yPos)
+        .attr('x2', w / 2)
+        .attr('y2', yPos)
+        .attr('stroke', stroke)
+        .attr('stroke-width', 0.5)
+        .attr('stroke-opacity', 0.5);
 
-      // Methods compartment
       if (methods.length > 0) {
-        // Separator
-        nodeG.append('line')
-          .attr('x1', -w / 2)
-          .attr('y1', yPos)
-          .attr('x2', w / 2)
-          .attr('y2', yPos)
-          .attr('stroke', stroke)
-          .attr('stroke-width', 0.5)
-          .attr('stroke-opacity', 0.5);
-
         let memberY = yPos + COMPARTMENT_PADDING_Y;
         for (const method of methods) {
           const vis = visibilitySymbol(method.visibility);

package/src/d3.ts

@@ -180,6 +180,7 @@ import type { PaletteColors } from './palettes';
 import { getSeriesColors } from './palettes';
 import type { DgmoError } from './diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
+import { collectIndentedValues } from './utils/parsing';
 
 // ============================================================
 // Timeline Date Helper
@@ -517,10 +518,18 @@ export function parseD3(content: string, palette?: PaletteColors): ParsedD3 {
 
     // Quadrant-specific parsing
     if (result.type === 'quadrant') {
-      // x-axis: Low, High
-      const xAxisMatch = line.match(/^x-axis\s*:\s*(.+)/i);
+      // x-axis: Low, High  — or indented multi-line
+      const xAxisMatch = line.match(/^x-axis\s*:\s*(.*)/i);
       if (xAxisMatch) {
-        const parts = xAxisMatch[1].split(',').map((s) => s.trim());
+        const val = xAxisMatch[1].trim();
+        let parts: string[];
+        if (val) {
+          parts = val.split(',').map((s) => s.trim());
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          parts = collected.values;
+        }
         if (parts.length >= 2) {
           result.quadrantXAxis = [parts[0], parts[1]];
           result.quadrantXAxisLineNumber = lineNumber;
@@ -528,10 +537,18 @@ export function parseD3(content: string, palette?: PaletteColors): ParsedD3 {
         continue;
       }
 
-      // y-axis: Low, High
-      const yAxisMatch = line.match(/^y-axis\s*:\s*(.+)/i);
+      // y-axis: Low, High  — or indented multi-line
+      const yAxisMatch = line.match(/^y-axis\s*:\s*(.*)/i);
       if (yAxisMatch) {
-        const parts = yAxisMatch[1].split(',').map((s) => s.trim());
+        const val = yAxisMatch[1].trim();
+        let parts: string[];
+        if (val) {
+          parts = val.split(',').map((s) => s.trim());
+        } else {
+          const collected = collectIndentedValues(lines, i);
+          i = collected.newIndex;
+          parts = collected.values;
+        }
         if (parts.length >= 2) {
           result.quadrantYAxis = [parts[0], parts[1]];
           result.quadrantYAxisLineNumber = lineNumber;

package/src/echarts.ts

@@ -88,6 +88,7 @@ import { getSeriesColors, getSegmentColors } from './palettes';
 import { parseChart } from './chart';
 import type { ParsedChart } from './chart';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
+import { collectIndentedValues } from './utils/parsing';
 
 // ============================================================
 // Parser
@@ -193,11 +194,16 @@ export function parseEChart(
     }
 
     if (key === 'series') {
-      result.series = value;
-      const rawNames = value
-        .split(',')
-        .map((s) => s.trim())
-        .filter(Boolean);
+      let rawNames: string[];
+      if (value) {
+        result.series = value;
+        rawNames = value.split(',').map((s) => s.trim()).filter(Boolean);
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        rawNames = collected.values;
+        result.series = rawNames.join(', ');
+      }
       const names: string[] = [];
       const nameColors: (string | undefined)[] = [];
       for (const raw of rawNames) {
@@ -241,12 +247,24 @@ export function parseEChart(
 
     // Heatmap columns and rows headers
     if (key === 'columns') {
-      result.columns = value.split(',').map((s) => s.trim());
+      if (value) {
+        result.columns = value.split(',').map((s) => s.trim());
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        result.columns = collected.values;
+      }
       continue;
     }
 
     if (key === 'rows') {
-      result.rows = value.split(',').map((s) => s.trim());
+      if (value) {
+        result.rows = value.split(',').map((s) => s.trim());
+      } else {
+        const collected = collectIndentedValues(lines, i);
+        i = collected.newIndex;
+        result.rows = collected.values;
+      }
       continue;
     }
 

package/src/sequence/parser.ts

@@ -63,6 +63,8 @@ export interface SequenceMessage {
   lineNumber: number;
   async?: boolean;
   bidirectional?: boolean;
+  /** Standalone return — the message itself IS a return (dashed arrow, no call). */
+  standaloneReturn?: boolean;
 }
 
 /**
@@ -184,10 +186,20 @@ const NOTE_MULTI = /^note(?:\s+(right|left)\s+of\s+([^\s:]+))?\s*:?\s*$/i;
 function parseReturnLabel(rawLabel: string): {
   label: string;
   returnLabel?: string;
+  standaloneReturn?: boolean;
 } {
   if (!rawLabel) return { label: '' };
 
-  // Check <- syntax first
+  // Standalone return: label starts with `<-` (no forward label)
+  const standaloneMatch = rawLabel.match(/^<-\s*(.*)$/);
+  if (standaloneMatch) {
+    return {
+      label: standaloneMatch[1].trim(),
+      standaloneReturn: true,
+    };
+  }
+
+  // Check <- syntax first (separates forward label from return label)
   const arrowReturn = rawLabel.match(ARROW_RETURN_PATTERN);
   if (arrowReturn) {
     return { label: arrowReturn[1].trim(), returnLabel: arrowReturn[2].trim() };
@@ -620,8 +632,8 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       const rawLabel = arrowMatch[3]?.trim() || '';
 
       // Extract return label — skip for async messages
-      const { label, returnLabel } = isAsync
-        ? { label: rawLabel, returnLabel: undefined }
+      const { label, returnLabel, standaloneReturn } = isAsync
+        ? { label: rawLabel, returnLabel: undefined, standaloneReturn: undefined }
         : parseReturnLabel(rawLabel);
 
       const msg: SequenceMessage = {
@@ -631,6 +643,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
         returnLabel,
         lineNumber,
         ...(isAsync ? { async: true } : {}),
+        ...(standaloneReturn ? { standaloneReturn: true } : {}),
       };
       result.messages.push(msg);
       currentContainer().push(msg);

package/src/sequence/renderer.ts

@@ -571,6 +571,28 @@ export function buildRenderSequence(messages: SequenceMessage[]): RenderStep[] {
       });
     }
 
+    // Standalone return: emit as a return step directly (no call, no stack).
+    // Also pop the matching pending call from the stack so it doesn't
+    // generate a duplicate empty return later.
+    if (msg.standaloneReturn) {
+      // Find and remove the stack entry this return satisfies
+      // (the pending call where from→to matches to→from of this return)
+      for (let si = stack.length - 1; si >= 0; si--) {
+        if (stack[si].from === msg.to && stack[si].to === msg.from) {
+          stack.splice(si, 1);
+          break;
+        }
+      }
+      steps.push({
+        type: 'return',
+        from: msg.from,
+        to: msg.to,
+        label: msg.label,
+        messageIndex: mi,
+      });
+      continue;
+    }
+
     // Emit call
     steps.push({
       type: 'call',

package/src/utils/parsing.ts

@@ -44,6 +44,37 @@ export const TITLE_RE = /^title\s*:\s*(.+)/i;
 /** Matches `option: value` header lines. */
 export const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
 
+/**
+ * Collect indented continuation lines as individual values.
+ * Used when a property like `series:` has an empty value — subsequent
+ * indented lines each become one value entry.
+ *
+ * - Skips blank lines and `//` comment lines within the block
+ * - Stops at first non-indented non-empty line (or EOF)
+ * - Strips trailing commas from values (user habit tolerance)
+ * - Returns `newIndex` so caller does `i = newIndex` and the loop's `i++` lands correctly
+ */
+export function collectIndentedValues(
+  lines: string[],
+  startIndex: number,
+): { values: string[]; newIndex: number } {
+  const values: string[] = [];
+  let j = startIndex + 1;
+  for (; j < lines.length; j++) {
+    const raw = lines[j];
+    const trimmed = raw.trim();
+    // Skip blank lines within the block
+    if (!trimmed) continue;
+    // Skip comment lines within the block
+    if (trimmed.startsWith('//')) continue;
+    // Stop at non-indented lines (first char is not whitespace)
+    if (raw[0] !== ' ' && raw[0] !== '\t') break;
+    // Strip trailing comma and collect
+    values.push(trimmed.replace(/,\s*$/, ''));
+  }
+  return { values, newIndex: j - 1 };
+}
+
 /** Parse pipe-delimited metadata from segments after the first (name) segment. */
 export function parsePipeMetadata(
   segments: string[],