@diagrammo/dgmo 0.16.0 → 0.17.0

package/src/sequence/parser.ts

@@ -11,6 +11,7 @@ import {
   NAME_DIAGNOSTIC_CODES,
   nameMergedMessage,
   akaRemovedMessage,
+  participantTypeRemovedMessage,
 } from '../diagnostics';
 import { normalizeName, displayName } from '../utils/name-normalize';
 import { parseArrow, parseInArrowLabel } from '../utils/arrows';
@@ -60,29 +61,40 @@ const KNOWN_SEQ_BOOLEANS = new Set(['activations', 'solid-fill', 'no-title']);
 
 /**
  * Participant types that can be declared via "Name is a type" syntax.
+ *
+ * The 0.16.0 trim retained only the types whose shapes carry semantic
+ * weight at a glance: stick figure (actor), cylinder (database),
+ * dashed cylinder (cache), horizontal pipe (queue), plus the default
+ * rectangle. The legacy `service`/`frontend`/`networking`/`gateway`/
+ * `external` keywords are rejected at parse time via
+ * `E_PARTICIPANT_TYPE_REMOVED`.
  */
 export type ParticipantType =
   | 'default'
-  | 'service'
   | 'database'
   | 'actor'
   | 'queue'
-  | 'cache'
-  | 'gateway'
-  | 'external'
-  | 'networking'
-  | 'frontend';
+  | 'cache';
 
 const VALID_PARTICIPANT_TYPES: ReadonlySet<string> = new Set([
-  'service',
   'database',
   'actor',
   'queue',
   'cache',
+]);
+
+/**
+ * Participant-type keywords that were removed in 0.16.0. Used to
+ * gate `is a X` declarations with a hard parse error rather than
+ * silent fall-through to default — aligns with the pre-1.0
+ * break-and-bump policy (see `E_AKA_REMOVED` precedent).
+ */
+const REMOVED_PARTICIPANT_TYPES: ReadonlySet<string> = new Set([
+  'service',
+  'frontend',
+  'networking',
   'gateway',
   'external',
-  'networking',
-  'frontend',
 ]);
 
 /**
@@ -205,9 +217,9 @@ export interface ParsedSequenceDgmo {
   error: string | null;
 }
 
-// "Name is a type" pattern — e.g. "Auth Server is a service"
+// "Name is a type" pattern — e.g. "Auth Server is a database"
 // Participant names may contain spaces; [^:]+? stops at colons so that
-// note lines like "note right of A: this is a service" are not falsely matched.
+// note lines like "note right of A: this is an actor" are not falsely matched.
 // Remainder after type is parsed separately for `position N` modifier.
 const IS_A_PATTERN = /^([^:]+?)\s+is\s+an?\s+(\w+)(?:\s+(.+))?$/i;
 
@@ -480,7 +492,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     result.diagnostics.push(makeDgmoError(line, message, 'warning'));
   };
 
-  if (!content || !content.trim()) {
+  if (!content?.trim()) {
     return fail(0, 'Empty content');
   }
 
@@ -494,7 +506,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
     const fl = lines[fi].trim();
     if (!fl || fl.startsWith('//')) continue;
     const parsed = parseFirstLine(fl);
-    if (parsed && parsed.chartType === 'sequence') {
+    if (parsed?.chartType === 'sequence') {
       hasExplicitChart = true;
       firstLineIndex = fi;
       if (parsed.title) {
@@ -936,6 +948,23 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       const typeStr = isAMatch[2].toLowerCase();
       let remainder = isAMatch[3]?.trim() || '';
 
+      // Reject the 5 removed-type keywords with a hard parse error
+      // (per Decision #2 / break-and-bump policy). Skip participant
+      // registration for the bad line — downstream message references
+      // will surface a "participant not declared" diagnostic, which
+      // is the intended behavior.
+      if (REMOVED_PARTICIPANT_TYPES.has(typeStr)) {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNumber,
+            participantTypeRemovedMessage(typeStr),
+            'error',
+            NAME_DIAGNOSTIC_CODES.PARTICIPANT_TYPE_REMOVED
+          )
+        );
+        continue;
+      }
+
       const participantType: ParticipantType = VALID_PARTICIPANT_TYPES.has(
         typeStr
       )
@@ -957,7 +986,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       // register it. Order on the line is `Name is a TYPE [position N] as <alias>`.
       // The leading `(.*?)\s*\b` allows the remainder to be just
       // `as <alias>` (empty prefix) — the canonical example writes
-      // `Alice is a service as a` where the entire remainder is `as a`.
+      // `Alice is an actor as a` where the entire remainder is `as a`.
       const asInRemainder = remainder.match(
         /^(.*?)\s*\bas\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/
       );
@@ -1316,6 +1345,29 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
+    // 'elif <label>' → suggest 'else if <label>'
+    const elifMatch = trimmed.match(/^elif\b\s*(.*)$/i);
+    if (elifMatch) {
+      const tailRaw = elifMatch[1].trim();
+      const tail = tailRaw ? ' ' + tailRaw : '';
+      pushError(
+        lineNumber,
+        `'elif' is not a keyword. Did you mean 'else if${tail}'?`
+      );
+      continue;
+    }
+
+    // 'else <text>' (where text isn't 'if …') → suggest 'else if <text>'
+    const elseLabelMatch = trimmed.match(/^else\s+(.+)$/i);
+    if (elseLabelMatch) {
+      const tail = elseLabelMatch[1].trim();
+      pushError(
+        lineNumber,
+        `'else' does not take a label. Did you mean 'else if ${tail}'?`
+      );
+      continue;
+    }
+
     // ---- Note parsing (space-separated only) ----
     // Strategy:
     // 1. Try bare note: `note text` — position defaults, text is everything after `note`

package/src/sequence/participant-inference.ts

@@ -3,9 +3,14 @@
 // ============================================================
 //
 // Data-driven rules table that infers participant type from name.
-// First match wins. Infrastructure overrides come before suffix
-// rules to prevent false positives (e.g. "Router" → networking,
-// not actor despite the "-er" suffix).
+// First match wins. Conflict overrides come before suffix rules
+// to prevent false positives within the surviving 4-type taxonomy.
+//
+// Surviving types: actor, database, cache, queue (plus default).
+// Removed in 0.16.0: service, frontend, networking, gateway, external.
+// Names that previously inferred to a removed type fall through to
+// default (sharp rectangle). Inference is intentionally conservative
+// — narrow product/name lists, no broad suffix catch-alls.
 // ============================================================
 
 import type { ParticipantType } from './parser';
@@ -23,95 +28,17 @@ interface InferenceRule {
  *
  * Priority order:
  * 0. Conflict overrides (prevent misclassification by general patterns)
- * 1. Infrastructure overrides (prevent false actor matches)
- * 2. Networking patterns
- * 3. Database patterns
- * 4. Cache patterns
- * 5. Queue/Messaging patterns
- * 6. Actor patterns (suffix + exact)
- * 7. Frontend patterns
- * 8. Service patterns
- * 9. External patterns
+ * 1. Database patterns
+ * 2. Cache patterns
+ * 3. Queue/Messaging patterns
+ * 4. Actor patterns (suffix + exact)
  */
 const PARTICIPANT_RULES: readonly InferenceRule[] = [
   // ── 0. Conflict overrides ────────────────────────────────
   // Names that would incorrectly match general patterns in later groups
   { pattern: /^KeyDB$/i, type: 'cache' }, // not database (DB$ suffix)
-  { pattern: /Webhook/i, type: 'external' }, // not frontend (Web contains)
-  { pattern: /^Upstream$/i, type: 'external' }, // not queue (Stream$ suffix)
-  { pattern: /^Downstream$/i, type: 'external' }, // not queue (Stream$ suffix)
-
-  // ── 1. Infrastructure overrides ─────────────────────────
-  // These names end in -er/-or but are NOT actors
-  { pattern: /^.*Router$/i, type: 'networking' },
-  { pattern: /^.*Scheduler$/i, type: 'service' },
-  { pattern: /^.*Dispatcher$/i, type: 'service' },
-  { pattern: /^.*Balancer$/i, type: 'networking' },
-  { pattern: /^.*Controller$/i, type: 'service' },
-  { pattern: /^.*Handler$/i, type: 'service' },
-  { pattern: /^.*Processor$/i, type: 'service' },
-  { pattern: /^.*Connector$/i, type: 'service' },
-  { pattern: /^.*Adapter$/i, type: 'service' },
-  { pattern: /^.*Provider$/i, type: 'service' },
-  { pattern: /^.*Manager$/i, type: 'service' },
-  { pattern: /^.*Orchestrator$/i, type: 'service' },
-  { pattern: /^.*Monitor$/i, type: 'service' },
-  { pattern: /^.*Resolver$/i, type: 'service' },
-  { pattern: /^.*Logger$/i, type: 'service' },
-  { pattern: /^.*Server$/i, type: 'service' },
-  { pattern: /^.*Broker$/i, type: 'queue' },
-  { pattern: /^.*Worker$/i, type: 'service' },
-  { pattern: /^.*Consumer$/i, type: 'service' },
-  { pattern: /^.*Producer$/i, type: 'service' },
-  { pattern: /^.*Publisher$/i, type: 'service' },
-  { pattern: /^.*Subscriber$/i, type: 'service' },
-  { pattern: /^.*Listener$/i, type: 'service' },
-  // New -er/-or suffixes that are services, not actors
-  { pattern: /^.*Watcher$/i, type: 'service' },
-  { pattern: /^.*Executor$/i, type: 'service' },
-  { pattern: /^.*Aggregator$/i, type: 'service' },
-  { pattern: /^.*Collector$/i, type: 'service' },
-  { pattern: /^.*Transformer$/i, type: 'service' },
-  { pattern: /^.*Validator$/i, type: 'service' },
-  { pattern: /^.*Generator$/i, type: 'service' },
-  { pattern: /^.*Indexer$/i, type: 'service' },
-  { pattern: /^.*Crawler$/i, type: 'service' },
-  { pattern: /^.*Scanner$/i, type: 'service' },
-  { pattern: /^.*Parser$/i, type: 'service' },
-  { pattern: /^.*Emitter$/i, type: 'service' },
-  { pattern: /^.*Exporter$/i, type: 'service' },
-  { pattern: /^.*Importer$/i, type: 'service' },
-  { pattern: /^.*Loader$/i, type: 'service' },
-  { pattern: /^.*Renderer$/i, type: 'service' },
-  { pattern: /^.*Checker$/i, type: 'service' },
-  { pattern: /^.*Inspector$/i, type: 'service' },
-  { pattern: /^.*Encoder$/i, type: 'service' },
-  { pattern: /^.*Decoder$/i, type: 'service' },
-  { pattern: /^.*Notifier$/i, type: 'service' },
-
-  // ── 2. Networking patterns ──────────────────────────────
-  { pattern: /Gateway/i, type: 'networking' },
-  { pattern: /GW$/i, type: 'networking' },
-  { pattern: /Proxy/i, type: 'networking' },
-  { pattern: /LB$/i, type: 'networking' },
-  { pattern: /LoadBalancer/i, type: 'networking' },
-  { pattern: /CDN/i, type: 'networking' },
-  { pattern: /Firewall/i, type: 'networking' },
-  { pattern: /WAF$/i, type: 'networking' },
-  { pattern: /DNS/i, type: 'networking' },
-  { pattern: /Ingress/i, type: 'networking' },
-  // Named products & patterns
-  { pattern: /Nginx/i, type: 'networking' },
-  { pattern: /Traefik/i, type: 'networking' },
-  { pattern: /Envoy/i, type: 'networking' },
-  { pattern: /Istio/i, type: 'networking' },
-  { pattern: /Kong/i, type: 'networking' },
-  { pattern: /Akamai/i, type: 'networking' },
-  { pattern: /Cloudflare/i, type: 'networking' },
-  { pattern: /Mesh$/i, type: 'networking' },
-  { pattern: /ServiceMesh/i, type: 'networking' },
 
-  // ── 3. Database patterns ────────────────────────────────
+  // ── 1. Database patterns ────────────────────────────────
   { pattern: /DB$/i, type: 'database' },
   { pattern: /Database/i, type: 'database' },
   { pattern: /Datastore/i, type: 'database' },
@@ -146,17 +73,16 @@ const PARTICIPANT_RULES: readonly InferenceRule[] = [
   { pattern: /Presto/i, type: 'database' },
   { pattern: /Table$/i, type: 'database' },
 
-  // ── 4. Cache patterns ──────────────────────────────────
+  // ── 2. Cache patterns ──────────────────────────────────
   { pattern: /Cache/i, type: 'cache' },
   { pattern: /Redis/i, type: 'cache' },
   { pattern: /Memcache/i, type: 'cache' },
-  // CDN already matched by networking above
   // Named products
   { pattern: /Dragonfly/i, type: 'cache' },
   { pattern: /Hazelcast/i, type: 'cache' },
   { pattern: /Valkey/i, type: 'cache' },
 
-  // ── 5. Queue/Messaging patterns ─────────────────────────
+  // ── 3. Queue/Messaging patterns ─────────────────────────
   { pattern: /Queue/i, type: 'queue' },
   { pattern: /MQ$/i, type: 'queue' },
   { pattern: /SQS/i, type: 'queue' },
@@ -169,6 +95,7 @@ const PARTICIPANT_RULES: readonly InferenceRule[] = [
   { pattern: /Stream$/i, type: 'queue' },
   { pattern: /SNS/i, type: 'queue' },
   { pattern: /PubSub/i, type: 'queue' },
+  { pattern: /Broker$/i, type: 'queue' },
   // Named products & patterns
   { pattern: /NATS/i, type: 'queue' },
   { pattern: /Pulsar/i, type: 'queue' },
@@ -180,7 +107,7 @@ const PARTICIPANT_RULES: readonly InferenceRule[] = [
   { pattern: /EventHub/i, type: 'queue' },
   { pattern: /Channel$/i, type: 'queue' },
 
-  // ── 6. Actor patterns ──────────────────────────────────
+  // ── 4. Actor patterns ──────────────────────────────────
   // Exact matches first
   { pattern: /^Admin$/i, type: 'actor' },
   { pattern: /^User$/i, type: 'actor' },
@@ -199,101 +126,11 @@ const PARTICIPANT_RULES: readonly InferenceRule[] = [
   { pattern: /^Fan$/i, type: 'actor' },
   { pattern: /^Purchaser$/i, type: 'actor' },
   { pattern: /^Reviewer$/i, type: 'actor' },
-  // Suffix rules (after infrastructure overrides filtered above)
+  // Suffix rules
   { pattern: /User$/i, type: 'actor' },
   { pattern: /Actor$/i, type: 'actor' },
   { pattern: /Analyst$/i, type: 'actor' },
   { pattern: /Staff$/i, type: 'actor' },
-
-  // ── 7. Frontend patterns ────────────────────────────────
-  { pattern: /App$/i, type: 'frontend' },
-  { pattern: /Application/i, type: 'frontend' },
-  { pattern: /Mobile/i, type: 'frontend' },
-  { pattern: /iOS/i, type: 'frontend' },
-  { pattern: /Android/i, type: 'frontend' },
-  { pattern: /Web/i, type: 'frontend' },
-  { pattern: /Browser/i, type: 'frontend' },
-  { pattern: /Frontend/i, type: 'frontend' },
-  { pattern: /UI$/i, type: 'frontend' },
-  { pattern: /Dashboard/i, type: 'frontend' },
-  { pattern: /CLI$/i, type: 'frontend' },
-  { pattern: /Terminal/i, type: 'frontend' },
-  // Frameworks & patterns
-  { pattern: /React/i, type: 'frontend' },
-  { pattern: /^Vue$/i, type: 'frontend' },
-  { pattern: /Angular/i, type: 'frontend' },
-  { pattern: /Svelte/i, type: 'frontend' },
-  { pattern: /NextJS/i, type: 'frontend' },
-  { pattern: /Nuxt/i, type: 'frontend' },
-  { pattern: /Remix/i, type: 'frontend' },
-  { pattern: /Electron/i, type: 'frontend' },
-  { pattern: /Tauri/i, type: 'frontend' },
-  { pattern: /Widget$/i, type: 'frontend' },
-  { pattern: /Portal/i, type: 'frontend' },
-  { pattern: /Console$/i, type: 'frontend' },
-  { pattern: /^SPA$/i, type: 'frontend' },
-  { pattern: /^PWA$/i, type: 'frontend' },
-
-  // ── 8. Service patterns ─────────────────────────────────
-  { pattern: /Service/i, type: 'service' },
-  { pattern: /Svc$/i, type: 'service' },
-  { pattern: /API$/i, type: 'service' },
-  { pattern: /Lambda/i, type: 'service' },
-  { pattern: /Function$/i, type: 'service' },
-  { pattern: /Fn$/i, type: 'service' },
-  { pattern: /Job$/i, type: 'service' },
-  { pattern: /Cron/i, type: 'service' },
-  { pattern: /Microservice/i, type: 'service' },
-  // Auth
-  { pattern: /^Auth$/i, type: 'service' },
-  { pattern: /^AuthN$/i, type: 'service' },
-  { pattern: /^AuthZ$/i, type: 'service' },
-  { pattern: /^SSO$/i, type: 'service' },
-  { pattern: /OAuth/i, type: 'service' },
-  { pattern: /^OIDC$/i, type: 'service' },
-  // SaaS
-  { pattern: /Stripe/i, type: 'service' },
-  { pattern: /Twilio/i, type: 'service' },
-  { pattern: /SendGrid/i, type: 'service' },
-  { pattern: /Mailgun/i, type: 'service' },
-  // Cloud/infra
-  { pattern: /^S3$/i, type: 'service' },
-  { pattern: /^Blob$/i, type: 'service' },
-  { pattern: /Vercel/i, type: 'service' },
-  { pattern: /Netlify/i, type: 'service' },
-  { pattern: /Heroku/i, type: 'service' },
-  { pattern: /Docker/i, type: 'service' },
-  { pattern: /Kubernetes/i, type: 'service' },
-  { pattern: /K8s/i, type: 'service' },
-  { pattern: /Terraform/i, type: 'service' },
-  // Security
-  { pattern: /Vault/i, type: 'service' },
-  { pattern: /^HSM$/i, type: 'service' },
-  { pattern: /KMS/i, type: 'service' },
-  { pattern: /^IAM$/i, type: 'service' },
-  // AI/ML
-  { pattern: /^LLM$/i, type: 'service' },
-  { pattern: /GPT/i, type: 'service' },
-  { pattern: /^Claude$/i, type: 'service' },
-  { pattern: /Embedding/i, type: 'service' },
-  { pattern: /Inference/i, type: 'service' },
-  // Suffixes & patterns
-  { pattern: /Pipeline$/i, type: 'service' },
-  { pattern: /Registry/i, type: 'service' },
-  { pattern: /Engine$/i, type: 'service' },
-  { pattern: /Daemon/i, type: 'service' },
-
-  // ── 9. External patterns ────────────────────────────────
-  { pattern: /External/i, type: 'external' },
-  { pattern: /Ext$/i, type: 'external' },
-  { pattern: /ThirdParty/i, type: 'external' },
-  { pattern: /3P$/i, type: 'external' },
-  { pattern: /Vendor/i, type: 'external' },
-  // Named products & patterns
-  { pattern: /Callback/i, type: 'external' },
-  { pattern: /^AWS$/i, type: 'external' },
-  { pattern: /^GCP$/i, type: 'external' },
-  { pattern: /Azure/i, type: 'external' },
 ];
 
 /**

package/src/sequence/renderer.ts

@@ -49,7 +49,6 @@ const PARTICIPANT_BOX_HEIGHT = 50;
 const TOP_MARGIN = 20;
 const TITLE_HEIGHT = 30;
 const PARTICIPANT_Y_OFFSET = 10;
-const SERVICE_BORDER_RADIUS = 10;
 const MESSAGE_START_OFFSET = 30;
 const LIFELINE_TAIL = 30;
 const ARROWHEAD_SIZE = 8;
@@ -180,25 +179,6 @@ function renderRectParticipant(
     .attr('stroke-width', SW);
 }
 
-function renderServiceParticipant(
-  g: d3Selection.Selection<SVGGElement, unknown, null, undefined>,
-  palette: PaletteColors,
-  isDark: boolean,
-  color?: string,
-  solid?: boolean
-): void {
-  g.append('rect')
-    .attr('x', -W / 2)
-    .attr('y', 0)
-    .attr('width', W)
-    .attr('height', H)
-    .attr('rx', SERVICE_BORDER_RADIUS)
-    .attr('ry', SERVICE_BORDER_RADIUS)
-    .attr('fill', fill(palette, isDark, color, solid))
-    .attr('stroke', stroke(palette, color))
-    .attr('stroke-width', SW);
-}
-
 function renderActorParticipant(
   g: d3Selection.Selection<SVGGElement, unknown, null, undefined>,
   palette: PaletteColors,
@@ -443,99 +423,6 @@ function renderCacheParticipant(
     .attr('stroke-dasharray', dash);
 }
 
-function renderNetworkingParticipant(
-  g: d3Selection.Selection<SVGGElement, unknown, null, undefined>,
-  palette: PaletteColors,
-  isDark: boolean,
-  color?: string,
-  solid?: boolean
-): void {
-  // Hexagon fitting within W x H
-  const inset = 16;
-  const points = [
-    `${-W / 2 + inset},0`,
-    `${W / 2 - inset},0`,
-    `${W / 2},${H / 2}`,
-    `${W / 2 - inset},${H}`,
-    `${-W / 2 + inset},${H}`,
-    `${-W / 2},${H / 2}`,
-  ].join(' ');
-  g.append('polygon')
-    .attr('points', points)
-    .attr('fill', fill(palette, isDark, color, solid))
-    .attr('stroke', stroke(palette, color))
-    .attr('stroke-width', SW);
-}
-
-function renderFrontendParticipant(
-  g: d3Selection.Selection<SVGGElement, unknown, null, undefined>,
-  palette: PaletteColors,
-  isDark: boolean,
-  color?: string,
-  solid?: boolean
-): void {
-  // Monitor shape fitting within W x H
-  const screenH = H - 10;
-  const s = stroke(palette, color);
-  g.append('rect')
-    .attr('x', -W / 2)
-    .attr('y', 0)
-    .attr('width', W)
-    .attr('height', screenH)
-    .attr('rx', 3)
-    .attr('ry', 3)
-    .attr('fill', fill(palette, isDark, color, solid))
-    .attr('stroke', s)
-    .attr('stroke-width', SW);
-  // Stand
-  g.append('line')
-    .attr('x1', 0)
-    .attr('y1', screenH)
-    .attr('x2', 0)
-    .attr('y2', H - 2)
-    .attr('stroke', s)
-    .attr('stroke-width', SW);
-  // Base
-  g.append('line')
-    .attr('x1', -14)
-    .attr('y1', H - 2)
-    .attr('x2', 14)
-    .attr('y2', H - 2)
-    .attr('stroke', s)
-    .attr('stroke-width', SW);
-}
-
-function renderExternalParticipant(
-  g: d3Selection.Selection<SVGGElement, unknown, null, undefined>,
-  palette: PaletteColors,
-  isDark: boolean,
-  color?: string,
-  solid?: boolean
-): void {
-  // Dashed border rectangle
-  g.append('rect')
-    .attr('x', -W / 2)
-    .attr('y', 0)
-    .attr('width', W)
-    .attr('height', H)
-    .attr('rx', 2)
-    .attr('ry', 2)
-    .attr('fill', fill(palette, isDark, color, solid))
-    .attr('stroke', stroke(palette, color))
-    .attr('stroke-width', SW)
-    .attr('stroke-dasharray', '6 3');
-}
-
-function renderGatewayParticipant(
-  g: d3Selection.Selection<SVGGElement, unknown, null, undefined>,
-  palette: PaletteColors,
-  isDark: boolean,
-  color?: string,
-  _solid?: boolean
-): void {
-  renderRectParticipant(g, palette, isDark, color);
-}
-
 // ============================================================
 // Collapsible Section Support
 // ============================================================
@@ -1528,7 +1415,7 @@ export function renderSequenceDiagram(
   // Ensure contentBottomY accounts for all note extents
   const lastStep = renderSteps[renderSteps.length - 1];
   const lastIsSelfCall =
-    lastStep && lastStep.type === 'call' && lastStep.from === lastStep.to;
+    lastStep?.type === 'call' && lastStep.from === lastStep.to;
   const lastStepTrailing = lastIsSelfCall ? SELF_CALL_HEIGHT + 25 : stepSpacing;
   let contentBottomY =
     renderSteps.length > 0
@@ -1968,6 +1855,13 @@ export function renderSequenceDiagram(
   // FRAME_PADDING_TOP declared earlier (near BLOCK_HEADER_SPACE)
   const FRAME_PADDING_BOTTOM = 15;
   const FRAME_LABEL_HEIGHT = 18;
+  // Self-loop projects ACTIVATION_WIDTH/2 + SELF_CALL_WIDTH (=35) past the
+  // lifeline; FRAME_PADDING_X (=30) leaves no breathing room. When a block
+  // contains a self-arrow, extend the frame on the loop's side so the loop
+  // sits comfortably inside.
+  const SELF_ARROW_PROJECTION = ACTIVATION_WIDTH / 2 + SELF_CALL_WIDTH;
+  const SELF_ARROW_FRAME_PAD = 10;
+  const frameRightmostX = Math.max(...Array.from(participantX.values()));
 
   // Collect message indices from an element subtree
   const collectMsgIndices = (els: SequenceElement[]): number[] => {
@@ -2063,14 +1957,46 @@ export function renderSequenceDiagram(
         }
       }
 
-      const frameX = minPX - FRAME_PADDING_X;
+      // Self-arrow geometry: extend frame on the loop's side so loops sit
+      // comfortably inside, and extend vertically if the block's last step
+      // is a self-call (whose loop drops SELF_CALL_HEIGHT below stepY).
+      let extraLeft = 0;
+      let extraRight = 0;
+      let maxStepIsSelfCall = false;
+      for (const mi of allIndices) {
+        const m = messages[mi];
+        if (m.from === m.to) {
+          const px = participantX.get(m.from);
+          if (px !== undefined) {
+            const flipLeft = px === frameRightmostX;
+            if (flipLeft) {
+              const loopMin = px - SELF_ARROW_PROJECTION;
+              const need =
+                minPX - FRAME_PADDING_X - loopMin + SELF_ARROW_FRAME_PAD;
+              if (need > 0) extraLeft = Math.max(extraLeft, need);
+            } else {
+              const loopMax = px + SELF_ARROW_PROJECTION;
+              const need =
+                loopMax - (maxPX + FRAME_PADDING_X) + SELF_ARROW_FRAME_PAD;
+              if (need > 0) extraRight = Math.max(extraRight, need);
+            }
+          }
+          if (msgToLastStep.get(mi) === maxStep) {
+            maxStepIsSelfCall = true;
+          }
+        }
+      }
+
+      const frameX = minPX - FRAME_PADDING_X - extraLeft;
       const frameY = stepY(minStep) - FRAME_PADDING_TOP;
-      const frameW = maxPX - minPX + FRAME_PADDING_X * 2;
+      const frameW =
+        maxPX - minPX + FRAME_PADDING_X * 2 + extraLeft + extraRight;
       const frameH =
         stepY(maxStep) -
         stepY(minStep) +
         FRAME_PADDING_TOP +
-        FRAME_PADDING_BOTTOM;
+        FRAME_PADDING_BOTTOM +
+        (maxStepIsSelfCall ? SELF_CALL_HEIGHT : 0);
 
       // Frame border
       svg
@@ -2093,7 +2019,7 @@ export function renderSequenceDiagram(
         x: frameX + 6,
         y: frameY + FRAME_LABEL_HEIGHT - 4,
         text: `${el.type} ${el.label}`,
-        bold: true,
+        bold: false,
         italic: false,
         blockLine: el.lineNumber,
       });
@@ -2121,7 +2047,7 @@ export function renderSequenceDiagram(
               y: dividerY + 14,
               text: `else if ${branchData.label}`,
               bold: false,
-              italic: true,
+              italic: false,
               blockLine: branchData.lineNumber,
             });
           }
@@ -2150,7 +2076,7 @@ export function renderSequenceDiagram(
             y: dividerY + 14,
             text: 'else',
             bold: false,
-            italic: true,
+            italic: false,
             blockLine: el.elseLineNumber,
           });
         }
@@ -2292,7 +2218,7 @@ export function renderSequenceDiagram(
 
   // Render section dividers
   const leftmostX = Math.min(...Array.from(participantX.values()));
-  const rightmostX = Math.max(...Array.from(participantX.values()));
+  const rightmostX = frameRightmostX;
   const sectionLineX1 = leftmostX - PARTICIPANT_BOX_WIDTH / 2 - 10;
   const sectionLineX2 = rightmostX + PARTICIPANT_BOX_WIDTH / 2 + 10;
 
@@ -2853,27 +2779,12 @@ function renderParticipant(
     case 'database':
       renderDatabaseParticipant(g, palette, isDark, color, solid);
       break;
-    case 'service':
-      renderServiceParticipant(g, palette, isDark, color, solid);
-      break;
     case 'queue':
       renderQueueParticipant(g, palette, isDark, color, solid);
       break;
     case 'cache':
       renderCacheParticipant(g, palette, isDark, color, solid);
       break;
-    case 'networking':
-      renderNetworkingParticipant(g, palette, isDark, color, solid);
-      break;
-    case 'frontend':
-      renderFrontendParticipant(g, palette, isDark, color, solid);
-      break;
-    case 'external':
-      renderExternalParticipant(g, palette, isDark, color, solid);
-      break;
-    case 'gateway':
-      renderGatewayParticipant(g, palette, isDark, color, solid);
-      break;
     default:
       renderRectParticipant(g, palette, isDark, color, solid);
       break;

package/src/sitemap/parser.ts

@@ -162,7 +162,7 @@ export function parseSitemap(
     result.diagnostics.push(makeDgmoError(line, message, 'warning'));
   };
 
-  if (!content || !content.trim()) {
+  if (!content?.trim()) {
     return fail(0, 'No content provided');
   }