@diagrammo/dgmo 0.4.0 → 0.4.1

package/docs/language-reference.md

@@ -369,8 +369,8 @@ Minimal example:
 ```
 User -login-> API
 API -findUser-> DB
-API <-user- DB
-User <-token- API
+DB -user-> API
+API -token-> User
 ```
 
 Full example:
@@ -387,23 +387,23 @@ NotifyQueue is a queue aka Notifications
 
 User -Login request-> API
 API -Find user by email-> DB
-API <-user record- DB
+DB -user record-> API
 note on DB:
   Indexed lookup on email column
 
 if credentials valid
   API -Create session-> DB
-  API <-session token- DB
+  DB -session token-> API
   API ~session.created~> NotifyQueue
-  User <-200 OK + token- API
+  API -200 OK + token-> User
 else
-  User <-401 Unauthorized- API
+  API -401 Unauthorized-> User
 
 == Logout ==
 
 User -Logout-> API
 API -Delete session-> DB
-User <-200 OK- API
+API -200 OK-> User
 ```
 
 **Participants**: Auto-inferred from message names. Declare explicitly for type/positioning:
@@ -412,10 +412,8 @@ User <-200 OK- API
 - `Name at position 2` — manual left-to-right ordering (0-based; negative from right)
 
 **Messages**:
-- Sync call: `A -label-> B` or `A -> B` (unlabeled)
+- Sync call: `A -label-> B` or `A -> B` (unlabeled) — always left-to-right
 - Async call: `A ~label~> B` or `A ~> B` (unlabeled)
-- Sync return: `A <-label- B` or `A <- B` (unlabeled) — dashed arrow from B to A
-- Async return: `A <~label~ B` or `A <~ B` (unlabeled)
 
 **Blocks** (indentation-scoped):
 - `if condition` ... `else` ... (no explicit `end` needed — indentation closes blocks)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "type": "module",

package/src/sequence/parser.ts

@@ -60,8 +60,6 @@ export interface SequenceMessage {
   label: string;
   lineNumber: number;
   async?: boolean;
-  /** Standalone return — the message itself IS a return (dashed arrow, no call). */
-  standaloneReturn?: boolean;
 }
 
 /**
@@ -462,7 +460,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
-    // ---- Labeled arrows: -label->, ~label~>, <-label->, <~label~> ----
+    // ---- Labeled arrows: -label->, ~label~> ----
     // Must be checked BEFORE plain arrow patterns to avoid partial matches
     const labeledArrow = parseArrow(trimmed);
     if (labeledArrow && 'error' in labeledArrow) {
@@ -471,7 +469,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     }
     if (labeledArrow) {
       contentStarted = true;
-      const { from, to, label, async: isAsync, isReturn } = labeledArrow;
+      const { from, to, label, async: isAsync } = labeledArrow;
       lastMsgFrom = from;
 
       const msg: SequenceMessage = {
@@ -480,7 +478,6 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
         label,
         lineNumber,
         ...(isAsync ? { async: true } : {}),
-        ...(isReturn ? { standaloneReturn: true } : {}),
       };
       result.messages.push(msg);
       currentContainer().push(msg);
@@ -538,43 +535,17 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
-    // ---- Bare (unlabeled) return arrows: A <- B, A <~ B ----
+    // ---- Deprecated bare return arrows: A <- B, A <~ B ----
     const bareReturnSync = trimmed.match(/^(\S+)\s+<-\s+(\S+)$/);
     const bareReturnAsync = trimmed.match(/^(\S+)\s+<~\s+(\S+)$/);
     const bareReturn = bareReturnSync || bareReturnAsync;
     if (bareReturn) {
-      contentStarted = true;
-      const to = bareReturn[1];   // left side = receiver
-      const from = bareReturn[2]; // right side = sender
-      lastMsgFrom = from;
-
-      const msg: SequenceMessage = {
-        from,
-        to,
-        label: '',
+      const to = bareReturn[1];
+      const from = bareReturn[2];
+      pushError(
         lineNumber,
-        standaloneReturn: true,
-        ...(bareReturnAsync ? { async: true } : {}),
-      };
-      result.messages.push(msg);
-      currentContainer().push(msg);
-
-      if (!result.participants.some((p) => p.id === from)) {
-        result.participants.push({
-          id: from,
-          label: from,
-          type: inferParticipantType(from),
-          lineNumber,
-        });
-      }
-      if (!result.participants.some((p) => p.id === to)) {
-        result.participants.push({
-          id: to,
-          label: to,
-          type: inferParticipantType(to),
-          lineNumber,
-        });
-      }
+        `Left-pointing arrows are no longer supported. Write '${from} -> ${to}' instead`
+      );
       continue;
     }
 

package/src/sequence/renderer.ts

@@ -569,28 +569,6 @@ 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/arrows.ts

@@ -2,38 +2,35 @@
 // Shared Arrow Parsing Utility
 // ============================================================
 //
-// Labeled arrow syntax:
-//   Forward: `-label->`, `~label~>`
-//   Return:  `<-label-`, `<~label~`
+// Labeled arrow syntax (always left-to-right):
+//   Sync:  `-label->`
+//   Async: `~label~>`
 
 export interface ParsedArrow {
   from: string;
   to: string;
   label: string;
   async: boolean;
-  isReturn: boolean;
 }
 
 // Forward (call) patterns
 const SYNC_LABELED_RE = /^(\S+)\s+-(.+)->\s+(\S+)$/;
 const ASYNC_LABELED_RE = /^(\S+)\s+~(.+)~>\s+(\S+)$/;
 
-// Return patterns — A <-msg- B means from=B, to=A
+// Deprecated patterns — produce errors
 const RETURN_SYNC_LABELED_RE = /^(\S+)\s+<-(.+)-\s+(\S+)$/;
 const RETURN_ASYNC_LABELED_RE = /^(\S+)\s+<~(.+)~\s+(\S+)$/;
-
-// Bidi detection (for error messages only)
 const BIDI_SYNC_RE = /^(\S+)\s+<-(.+)->\s+(\S+)$/;
 const BIDI_ASYNC_RE = /^(\S+)\s+<~(.+)~>\s+(\S+)$/;
 
-const ARROW_CHARS = ['->', '~>', '<-', '<~'];
+const ARROW_CHARS = ['->', '~>'];
 
 /**
  * Try to parse a labeled arrow from a trimmed line.
  *
  * Returns:
  *  - `ParsedArrow` if matched and valid
- *  - `{ error: string }` if matched but invalid (bidi, or arrow chars in label)
+ *  - `{ error: string }` if matched but invalid (deprecated syntax)
  *  - `null` if not a labeled arrow (caller should fall through to bare patterns)
  */
 export function parseArrow(
@@ -47,18 +44,28 @@ export function parseArrow(
     };
   }
 
+  // Check deprecated return arrow patterns — return error
+  if (RETURN_SYNC_LABELED_RE.test(line) || RETURN_ASYNC_LABELED_RE.test(line)) {
+    const m =
+      line.match(RETURN_SYNC_LABELED_RE) ??
+      line.match(RETURN_ASYNC_LABELED_RE);
+    const from = m![3];
+    const to = m![1];
+    const label = m![2].trim();
+    return {
+      error: `Left-pointing arrows are no longer supported. Write '${from} -${label}-> ${to}' instead`,
+    };
+  }
+
   const patterns: {
     re: RegExp;
     async: boolean;
-    isReturn: boolean;
   }[] = [
-    { re: RETURN_SYNC_LABELED_RE, async: false, isReturn: true },
-    { re: RETURN_ASYNC_LABELED_RE, async: true, isReturn: true },
-    { re: SYNC_LABELED_RE, async: false, isReturn: false },
-    { re: ASYNC_LABELED_RE, async: true, isReturn: false },
+    { re: SYNC_LABELED_RE, async: false },
+    { re: ASYNC_LABELED_RE, async: true },
   ];
 
-  for (const { re, async: isAsync, isReturn } of patterns) {
+  for (const { re, async: isAsync } of patterns) {
     const m = line.match(re);
     if (!m) continue;
 
@@ -71,28 +78,16 @@ export function parseArrow(
     for (const arrow of ARROW_CHARS) {
       if (label.includes(arrow)) {
         return {
-          error: 'Arrow characters (->, ~>, <-, <~) are not allowed inside labels',
+          error: 'Arrow characters (->, ~>) are not allowed inside labels',
         };
       }
     }
 
-    if (isReturn) {
-      // Return arrow: A <-msg- B → from=B (source), to=A (destination)
-      return {
-        from: m[3],
-        to: m[1],
-        label,
-        async: isAsync,
-        isReturn: true,
-      };
-    }
-
     return {
       from: m[1],
       to: m[3],
       label,
       async: isAsync,
-      isReturn: false,
     };
   }