@diagrammo/dgmo 0.15.1 → 0.17.0

package/src/raci/parser.ts

@@ -24,6 +24,7 @@ import {
   measureIndent,
   parseFirstLine,
   parsePipeMetadata,
+  peelTrailingColorName,
   OPTION_NOCOLON_RE,
   tryParseSharedOption,
 } from '../utils/parsing';
@@ -82,10 +83,10 @@ const KNOWN_BOOLEANS = new Set<string>([
   ...Object.keys(VARIANT_LOCK_DIRECTIVES),
 ]);
 
-// Allow optional trailing `| key: value, ...` after the bracket,
-// e.g. `[Voyage] | color: blue` — matches the modern dgmo idiom
-// (cycle / pyramid / ring / journey-map / boxes-and-lines).
-const PHASE_RE = /^\[(.+?)\]\s*(?:\|\s*(.+))?\s*$/;
+// Allow optional trailing color shortcut and/or pipe metadata after the
+// bracket: `[Voyage] blue | desc: …` (per §1.5 universal trailing-token
+// rule + the modern cycle/pyramid/ring/journey-map/b&l idiom).
+const PHASE_RE = /^\[(.+?)\](?:\s+(\S+))?(?:\s*\|\s*(.+))?\s*$/;
 const ROLE_ASSIGNMENT_RE = /^([^:]+):\s*(.*)$/;
 
 /**
@@ -177,7 +178,7 @@ export function parseRaci(
     result.diagnostics.push(makeDgmoError(line, message, 'error', code));
   };
 
-  if (!content || !content.trim()) {
+  if (!content?.trim()) {
     return fail(0, 'No content provided');
   }
 
@@ -382,10 +383,10 @@ export function parseRaci(
           // Strip a possible trailing comma (user habit tolerance,
           // matches `collectIndentedValues`).
           const stripped = nextTrim.replace(/,\s*$/, '');
-          // Optional pipe metadata: `Cap | color: blue` — matches
-          // every modern chart-type's per-element styling form.
+          // Optional pipe metadata: `Cap | color: blue` — long form.
+          // Optional trailing-token shortcut: `Cap blue` — short form (§1.5).
           const segments = stripped.split('|').map((s) => s.trim());
-          const roleLabel = segments[0] ?? '';
+          let roleLabel = segments[0] ?? '';
           let roleColor: string | undefined;
           if (segments.length > 1) {
             const meta = parsePipeMetadata(segments);
@@ -398,6 +399,20 @@ export function parseRaci(
               );
             }
           }
+          // Apply shortcut only when pipe metadata didn't already set color.
+          if (!roleColor) {
+            const { label: stripLabel, colorName: shortcutColor } =
+              peelTrailingColorName(roleLabel);
+            if (shortcutColor) {
+              roleColor = resolveColorWithDiagnostic(
+                shortcutColor,
+                j + 1,
+                result.diagnostics,
+                palette
+              );
+              roleLabel = stripLabel;
+            }
+          }
           if (roleLabel) getOrAddRole(roleLabel, j + 1, roleColor);
         }
         i = j - 1; // outer loop's i++ lands on the first non-block line
@@ -469,10 +484,13 @@ export function parseRaci(
           errorAt(lineNumber, 'Phase label is empty.');
           continue;
         }
-        // Optional pipe metadata: `[Voyage] | color: blue`.
+        // PHASE_RE captures: 1=label, 2=optional trailing-token color, 3=pipe meta.
+        // Long pipe form (`[Voyage] | color: blue`) wins over the shortcut.
         let phaseColor: string | undefined;
-        if (phaseMatch[2]) {
-          const meta = parsePipeMetadata(['', phaseMatch[2]]);
+        const trailingToken = phaseMatch[2];
+        const pipeMeta = phaseMatch[3];
+        if (pipeMeta) {
+          const meta = parsePipeMetadata(['', pipeMeta]);
           if (meta['color']) {
             phaseColor = resolveColorWithDiagnostic(
               meta['color'],
@@ -482,6 +500,18 @@ export function parseRaci(
             );
           }
         }
+        if (!phaseColor && trailingToken) {
+          // Trailing token must be a recognized color word, or it's a parse error.
+          const { colorName } = peelTrailingColorName(`x ${trailingToken}`);
+          if (colorName) {
+            phaseColor = resolveColorWithDiagnostic(
+              colorName,
+              lineNumber,
+              result.diagnostics,
+              palette
+            );
+          }
+        }
         currentPhase = {
           id: normalizeName(display),
           displayName: display,
@@ -594,7 +624,7 @@ export function parseRaci(
           // detect by whether it was declared before `bodyStarted`.
           // We piggyback the `declaredLine` we recorded.
           const entry = roleStore.get(roleId);
-          if (entry && entry.declaredLine === lineNumber) {
+          if (entry?.declaredLine === lineNumber) {
             const candidates = result.roleDisplayNames.filter(
               (n) => n !== entry.displayName
             );

package/src/raci/renderer.ts

@@ -602,7 +602,8 @@ export function renderRaci(
   parsed.roles.forEach((roleId, i) => {
     const cx = roleX(i) + COLUMN_INSET;
     const cw = roleColW - 2 * COLUMN_INSET;
-    // Per-role color from `Cap(blue)` syntax. When the user provides
+    // Per-role color from `Cap blue` trailing-token (or `Cap | color: blue`)
+    // syntax. When the user provides
     // one, it wins; otherwise rotate through marker-safe accents so
     // each column has a subtle visual identity instead of every column
     // reading as the same neutral gray.

package/src/raci/types.ts

@@ -67,9 +67,10 @@ export interface ParsedRaci {
   /** Display name for each role (parallel to `roles`). */
   roleDisplayNames: string[];
   /**
-   * Optional per-role palette color from `Cap(blue)` suffix in the
-   * roles block. Parallel to `roles`; entries default to `undefined`
-   * (renderer falls back to the neutral column tint).
+   * Optional per-role palette color from the `Cap blue` trailing-token
+   * suffix in the roles block (or the long pipe form `Cap | color: blue`).
+   * Parallel to `roles`; entries default to `undefined` (renderer falls
+   * back to the neutral column tint).
    */
   roleColors: Array<string | undefined>;
   phases: RaciPhase[];

package/src/ring/parser.ts

@@ -8,6 +8,7 @@ import {
   measureIndent,
   parseFirstLine,
   parsePipeMetadata,
+  peelTrailingColorName,
   tryParseSharedOption,
   PIPE_KEY_VALUE_PREFIX_RE,
   PIPE_LIKELY_STRUCTURED_TAIL_RE,
@@ -73,7 +74,7 @@ export function parseRing(content: string): ParsedRing {
     // ── First line: chart type declaration ──
     if (!headerParsed) {
       const firstLineResult = parseFirstLine(trimmed);
-      if (firstLineResult && firstLineResult.chartType === 'ring') {
+      if (firstLineResult?.chartType === 'ring') {
         result.title = firstLineResult.title ?? '';
         result.titleLineNumber = lineNum;
         headerParsed = true;
@@ -175,6 +176,17 @@ export function parseRing(content: string): ParsedRing {
         continue;
       }
 
+      // Universal trailing-token shortcut: `Label color` equivalent to
+      // `Label | color: <name>` when color is not already set (§1.5).
+      if (!color) {
+        const { label: stripped, colorName: shortcutColor } =
+          peelTrailingColorName(label);
+        if (shortcutColor) {
+          color = shortcutColor;
+          label = stripped;
+        }
+      }
+
       currentLayer = {
         label,
         lineNumber: lineNum,

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;
 
@@ -215,7 +227,10 @@ const IS_A_PATTERN = /^([^:]+?)\s+is\s+an?\s+(\w+)(?:\s+(.+))?$/i;
 const POSITION_ONLY_PATTERN = /^([^:]+?)\s+position\s+(-?\d+)$/i;
 
 // Colored participant declaration — e.g. "Tapin2(green)", "API(blue)"
-const COLORED_PARTICIPANT_PATTERN = /^(\S+?)\(([^)]+)\)\s*$/;
+// Scoped to recognized 11-name palette colors only (§1.5) so legitimate
+// `funcCall(arg)` lines don't trigger the legacy-color diagnostic.
+const COLORED_PARTICIPANT_PATTERN =
+  /^(\S+?)\((red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\)\s*$/;
 
 // Group heading pattern — "[Backend]", "[Backend] | t: Product"
 // Group 1: name (no ] or | inside brackets), Group 2: color in parens, Group 3: after-bracket text
@@ -477,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');
   }
 
@@ -491,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) {
@@ -678,7 +693,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       if (groupColor) {
         pushWarning(
           lineNumber,
-          `(${groupColor}) color syntax removed from sequence diagrams — use 'tag:' groups for coloring`
+          `'(${groupColor})' parens-color syntax removed from sequence diagrams — use 'tag:' groups for coloring`
         );
       }
       contentStarted = true;
@@ -765,7 +780,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
-    // Tag group entries (indented Value(color) under tag heading)
+    // Tag group entries (indented Value color under tag heading)
     // First entry is the default unless another is marked `default`
     if (currentTagGroup && !contentStarted && measureIndent(raw) > 0) {
       const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
@@ -778,7 +793,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       if (!color) {
         pushError(
           lineNumber,
-          `Expected 'Value(color)' in tag group '${currentTagGroup.name}'`
+          `Expected 'Value color' in tag group '${currentTagGroup.name}'`
         );
         continue;
       }
@@ -807,11 +822,14 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
         blockStack.pop();
       }
       const labelRaw = sectionMatch[1].trim();
-      const colorMatch = labelRaw.match(/^(.+?)\(([^)]+)\)$/);
+      // Scoped to recognized 11-name palette colors only (§1.5).
+      const colorMatch = labelRaw.match(
+        /^(.+?)\((red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white)\)$/
+      );
       if (colorMatch) {
         pushWarning(
           lineNumber,
-          `(${colorMatch[2].trim()}) color syntax removed from sequence diagrams — use 'tag:' groups for coloring`
+          `'(${colorMatch[2]})' parens-color syntax removed from sequence diagrams — use 'tag:' groups for coloring`
         );
       }
       contentStarted = true;
@@ -930,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
       )
@@ -951,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*$/
       );
@@ -1016,8 +1051,8 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       continue;
     }
 
-    // Colored participant declaration — "Name(color)" at any level
-    // Color syntax is deprecated — emit warning and register without color
+    // Legacy `Name(color)` participant declaration at any level (§1.5 hard
+    // break). Scoped to the 11-name palette so `funcCall(arg)` doesn't trip.
     const { core: colorCore, meta: colorMeta } = splitPipe(trimmed, lineNumber);
     const coloredMatch = colorCore.match(COLORED_PARTICIPANT_PATTERN);
     if (coloredMatch && !ARROW_PATTERN.test(colorCore)) {
@@ -1025,7 +1060,7 @@ export function parseSequenceDgmo(content: string): ParsedSequenceDgmo {
       const color = coloredMatch[2].trim();
       pushError(
         lineNumber,
-        `'${id}(${color})' syntax is no longer supported — use 'tag:' groups for coloring`
+        `'${id}(${color})' parens-color syntax is no longer supported — use 'tag:' groups for coloring`
       );
       contentStarted = true;
       const key = addParticipant(id, lineNumber, { metadata: colorMeta });
@@ -1310,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' },
 ];
 
 /**