@zombie-mermaid/ascii-renderer 2.2.1 → 3.0.0

package/src/__tests__/testdata/ascii/er_attributes.txt

@@ -10,12 +10,12 @@ erDiagram
   }
   CUSTOMER ||--o{ ORDER : places
 ---
-+-----------------+        +------------------+    
-| CUSTOMER        |        | ORDER            |    
-+-----------------+        +------------------+    
-| PK string name  |-|----o<| PK int id        |    
-| UK string email | places |    string status |    
-|    int age      |        +------------------+    
-+-----------------+                                
-                                                   
-                                                   
++-----------------+        +---------------+    
+| CUSTOMER        |        | ORDER         |    
++-----------------+        +---------------+    
+| string name PK  |-|----o<| int id PK     |    
+| string email UK | places | string status |    
+| int age         |        +---------------+    
++-----------------+                             
+                                                
+                                                

package/src/__tests__/testdata/ascii/er_identifying.txt

@@ -8,11 +8,11 @@ erDiagram
     string city
   }
 ---
-+----------------+          +------------------+    
-| PERSON         |          | ADDRESS          |    
-+----------------+-|------o<+------------------+    
-| PK string name | lives_at |    string street |    
-+----------------+          |    string city   |    
-                            +------------------+    
-                                                    
-                                                    
++----------------+          +---------------+    
+| PERSON         |          | ADDRESS       |    
++----------------+-|------o<+---------------+    
+| string name PK | lives_at | string street |    
++----------------+          | string city   |    
+                            +---------------+    
+                                                 
+                                                 

package/src/__tests__/testdata/unicode/er_attributes.txt

@@ -10,12 +10,12 @@ erDiagram
   }
   CUSTOMER ||--o{ ORDER : places
 ---
-┌─────────────────┐        ┌──────────────────┐    
-│ CUSTOMER        │        │ ORDER            │    
-├─────────────────┤        ├──────────────────┤    
-│ PK string name  │─│────○╟│ PK int id        │    
-│ UK string email │ places │    string status │    
-│    int age      │        └──────────────────┘    
-└─────────────────┘                                
-                                                   
-                                                   
+┌─────────────────┐        ┌───────────────┐    
+│ CUSTOMER        │        │ ORDER         │    
+├─────────────────┤        ├───────────────┤    
+│ string name PK  │─│────○╟│ int id PK     │    
+│ string email UK │ places │ string status │    
+│ int age         │        └───────────────┘    
+└─────────────────┘                             
+                                                
+                                                

package/src/__tests__/testdata/unicode/er_identifying.txt

@@ -8,11 +8,11 @@ erDiagram
     string city
   }
 ---
-┌────────────────┐          ┌──────────────────┐    
-│ PERSON         │          │ ADDRESS          │    
-├────────────────┤─│──────○╟├──────────────────┤    
-│ PK string name │ lives_at │    string street │    
-└────────────────┘          │    string city   │    
-                            └──────────────────┘    
-                                                    
-                                                    
+┌────────────────┐          ┌───────────────┐    
+│ PERSON         │          │ ADDRESS       │    
+├────────────────┤─│──────○╟├───────────────┤    
+│ string name PK │ lives_at │ string street │    
+└────────────────┘          │ string city   │    
+                            └───────────────┘    
+                                                 
+                                                 

package/src/{validate.ts → __tests__/validate.ts}

@@ -1,8 +1,7 @@
 /**
- * ASCII Rendering Validation Utilities
- *
- * Provides validation functions for ASCII diagram output,
- * including diagonal line detection to ensure orthogonal-only routing.
+ * ASCII rendering validation helpers used by the test suite to sanity-check
+ * rendered output (diagonal-line and orphaned-junction detection).
+ * Test-only — not part of the package's public render path.
  */
 
 /**
@@ -100,32 +99,6 @@ export function findDiagonalLines(asciiOutput: string): DiagonalPosition[] {
   return positions
 }
 
-/**
- * Assert that ASCII output contains no diagonal lines.
- * Throws an error with detailed position information if diagonals are found.
- *
- * @param asciiOutput - The rendered ASCII diagram string
- * @param context - Optional context string for error message (e.g., diagram name)
- * @throws Error if diagonal characters are present
- */
-export function assertNoDiagonals(asciiOutput: string, context?: string): void {
-  if (!hasDiagonalLines(asciiOutput)) {
-    return
-  }
-
-  const positions = findDiagonalLines(asciiOutput)
-  const contextStr = context ? ` in "${context}"` : ''
-  const positionStr = positions
-    .map((p) => `  Line ${p.line}, Col ${p.col}: '${p.char}'`)
-    .join('\n')
-
-  throw new Error(
-    `Diagonal lines detected${contextStr}. ` +
-      `Edges must use orthogonal Manhattan routing (90° bends only).\n` +
-      `Found ${positions.length} diagonal character(s):\n${positionStr}`,
-  )
-}
-
 /**
  * Position of an orphaned tee/junction character in ASCII output.
  */
@@ -177,13 +150,3 @@ export function findOrphanedJunctions(
 
   return positions
 }
-
-/**
- * Check if ASCII output contains any orphaned tee/junction characters.
- * Returns true if any are found (which is an error condition).
- *
- * @param asciiOutput - The rendered ASCII diagram string
- */
-export function hasOrphanedJunctions(asciiOutput: string): boolean {
-  return findOrphanedJunctions(asciiOutput).length > 0
-}

package/src/draw-boxes.ts

@@ -99,6 +99,20 @@ function drawBoxWithGridDimensions(node: AsciiNode, graph: AsciiGraph): Canvas {
   write(box, from.x, to.y, effectiveCorners.bl)
   write(box, to.x, to.y, effectiveCorners.br)
 
+  // Cylinder (database) gets a rim line just inside its top and bottom
+  // border — the ellipse-pinch that makes it read as a cylinder rather than
+  // a plain rounded box, which otherwise uses the identical corner glyphs
+  // (see corners.ts's SHAPE_CORNERS.cylinder). getShapeDimensions already
+  // reserves the extra 2 rows of height this needs (see the cylinder branch
+  // of shapes/special.ts's getDimensions) — issue #1119.
+  if (node.shape === 'cylinder' && to.y - from.y >= 4) {
+    for (const rimY of [from.y + 1, to.y - 1]) {
+      for (let x = from.x + 1; x < to.x; x++) write(box, x, rimY, hChar)
+      write(box, from.x, rimY, vChar)
+      write(box, to.x, rimY, vChar)
+    }
+  }
+
   // Center the multi-line display label inside the box
   const label = node.displayLabel
   const lines = splitLines(label)

package/src/er-diagram.ts

@@ -42,10 +42,22 @@ import { DEFAULT_PADDING_X, DEFAULT_PADDING_Y, paddingOffset } from './types.ts'
 // Entity box content
 // ============================================================================
 
-/** Format an attribute line: "PK type name" or "FK type name" etc. */
+/**
+ * Format an attribute line as "type name" or "type name PK" etc.
+ *
+ * Real mermaid's SVG lays attribute columns out left-to-right as
+ * type/name/keys (confirmed against `attribute-type`/`attribute-name`/
+ * `attribute-keys` x-coordinates in the form-judge report on issue #1119) —
+ * so the key column trails here too, rather than leading with a fixed-width
+ * prefix like the pre-#1134 "PK type name" order did. Nothing else in this
+ * file assumes a fixed-width key column: box width is just the widest
+ * rendered line (see measureMultiBox in draw-boxes.ts), so a trailing,
+ * unpadded key suffix sizes the box correctly with no extra alignment logic
+ * needed.
+ */
 function formatAttribute(attr: ErAttribute): string {
-  const keyStr = attr.keys.length > 0 ? attr.keys.join(',') + ' ' : '   '
-  return `${keyStr}${attr.type} ${attr.name}`
+  const keySuffix = attr.keys.length > 0 ? ' ' + attr.keys.join(',') : ''
+  return `${attr.type} ${attr.name}${keySuffix}`
 }
 
 /** Build sections for an entity box: [header], [attributes] */
@@ -532,6 +544,7 @@ export function renderErAscii(
     y: number,
     minX: number,
     maxX: number,
+    avoidForeignLines: boolean,
   ): boolean {
     for (let i = 0; i < cells.length; i++) {
       const x = startX + i
@@ -539,6 +552,31 @@ export function renderErAscii(
       if (isProtected(x, y) || rc[x]?.[y] === 'arrow') return false
       if (boxCells.has(`${x},${y}`)) return false
     }
+    if (!avoidForeignLines) return true
+    // A cell already holding a *different* relationship's line reads as
+    // free above (isProtected only tracks text/border), so without this
+    // check the search below would happily park this relationship's label
+    // right beside someone else's line — visually implying the label
+    // describes that line's solid/dashed style instead of its own (issue
+    // #1119). currentRelLineCells (see setCGuarded) is this relationship's
+    // own line cells, drawn moments earlier in this same iteration — those
+    // stay allowed, matching the "label wins over the line beneath it" doc
+    // comment above. Checked a cell wider than the label's own text on each
+    // side (not just cells.length) so a foreign line stem passing just
+    // outside the label's own span doesn't end up flush against it either —
+    // narrower than that and the existing single-cell post-placement
+    // cleanup below can't fully clear it. Only enforced on this first
+    // (strict) search pass — see the two-pass loop below — a dense diagram
+    // with no foreign-line-free row anywhere in range falls back to the
+    // old, permissive check rather than dropping the label outright (a
+    // worse information loss than the visual ambiguity this guards
+    // against).
+    for (let x = startX - 2; x <= startX + cells.length; x++) {
+      if (x < minX - 2 || x > maxX + 1) continue
+      if (rc[x]?.[y] === 'line' && !currentRelLineCells.has(`${x},${y}`)) {
+        return false
+      }
+    }
     return true
   }
 
@@ -595,7 +633,38 @@ export function renderErAscii(
     // the same silent-corruption shape as issue #350, just between two
     // relationships instead of a relationship and a box.
     if (role !== 'text' && rc[x]?.[y] === 'text') return
+    // A same-family crossing (solid-over-solid, dashed-over-dashed, or
+    // either meeting a direction-agnostic corner/marker glyph — see
+    // lineStyleFamily) is always allowed to overwrite: two relationship
+    // lines crossing is normal, expected ER layout (see the doc comment
+    // above), and same-style glyphs look identical regardless of which
+    // relationship drew them. A *dashed* write landing on an already-drawn
+    // *solid* glyph is the one combination refused: without this, whichever
+    // relationship simply happened to be declared (and so drawn) later
+    // always won a shared cell regardless of which one it visually belongs
+    // to, so an identifying relationship's own solid line could end up
+    // showing a dashed glyph purely from draw order when it shared layout
+    // space with a non-identifying relationship (issue #1145). Solid takes
+    // precedence over dashed wherever they'd otherwise collide — not
+    // "whichever wrote first", which would just swap one order dependency
+    // for another — so the outcome is the same regardless of which
+    // relationship is declared first, mirroring how a label always wins
+    // over the line beneath it (the isProtected/canPlaceLabelLine guards
+    // above): a solid write always goes through, including over an
+    // existing dashed glyph.
+    if (
+      lineStyleFamily(ch) === 'dashed' &&
+      lineStyleFamily(canvas[x]?.[y]) === 'solid'
+    ) {
+      return
+    }
     setC(x, y, ch, role)
+    // Track this relationship's own line cells (see currentRelLineCells,
+    // reset per relationship below) so a later label-placement search can
+    // tell "sits on my own line" (fine) apart from "sits on a *different*
+    // relationship's line" (issue #1119 — a relocated label landing next to
+    // an unrelated line reads as describing that line's style instead).
+    if (role === 'line') currentRelLineCells.add(`${x},${y}`)
   }
 
   /**
@@ -710,6 +779,25 @@ export function renderErAscii(
   const dashH = useAscii ? '.' : '╌'
   const dashV = useAscii ? ':' : '┊'
 
+  /**
+   * Family a straight relationship-line glyph belongs to — 'solid' for an
+   * identifying relationship's H/V glyphs, 'dashed' for a non-identifying
+   * relationship's dashH/dashV glyphs, or undefined for anything else
+   * (corner glyphs from getCornerChar, crow's-foot markers, box borders,
+   * label text). Corners and markers are direction/role glyphs, not style
+   * glyphs — they look identical regardless of which relationship's style
+   * drew them, so they're deliberately excluded here rather than folded
+   * into either family; see setCGuarded's use of this for why that
+   * exclusion matters (issue #1145).
+   */
+  function lineStyleFamily(
+    ch: string | undefined,
+  ): 'solid' | 'dashed' | undefined {
+    if (ch === H || ch === V) return 'solid'
+    if (ch === dashH || ch === dashV) return 'dashed'
+    return undefined
+  }
+
   /**
    * Character for the single cell where a routed relationship's path turns
    * — a vertical segment and a horizontal segment meeting at a right angle
@@ -822,7 +910,12 @@ export function renderErAscii(
     return entity.x + margin + Math.round(idx * step)
   }
 
+  // This relationship's own line cells, reset each iteration — see
+  // setCGuarded and canPlaceLabelLineAvoidingMarkers above.
+  let currentRelLineCells = new Set<string>()
+
   for (const rel of diagram.relationships) {
+    currentRelLineCells = new Set<string>()
     const e1 = placed.get(rel.entity1)
     const e2 = placed.get(rel.entity2)
     if (!e1 || !e2) continue
@@ -1419,37 +1512,47 @@ export function renderErAscii(
         // legitimately run its label past a box that never touched
         // startY/endY's naive band (#350). It also means clear of markers,
         // not just text/borders (#392) — before giving up.
+        // Two passes: first strict (also dodging a *different*
+        // relationship's own line — #1119), then permissive (the pre-#1119
+        // check) if nothing in range clears the strict bar. A dense diagram
+        // where every candidate row touches some other relationship's line
+        // would otherwise drop the label entirely — worse than the visual
+        // ambiguity the strict pass exists to avoid.
         let placedAtY: number | null = null
-        for (
-          let offset = 0;
-          offset <= endY - startY && placedAtY === null;
-          offset++
-        ) {
-          const candidates =
-            offset === 0
-              ? [naturalStartY]
-              : [naturalStartY + offset, naturalStartY - offset]
-          for (const candidateStart of candidates) {
-            if (
-              candidateStart < startY ||
-              candidateStart + blockHeight - 1 > endY
-            ) {
-              continue
-            }
-            const fits = cellsPerLine.every((cells, lineIdx) =>
-              canPlaceLabelLineAvoidingMarkers(
-                cells,
-                labelX,
-                candidateStart + lineIdx,
-                0,
-                lastLx,
-              ),
-            )
-            if (fits) {
-              placedAtY = candidateStart
-              break
+        for (const avoidForeignLines of [true, false]) {
+          for (
+            let offset = 0;
+            offset <= endY - startY && placedAtY === null;
+            offset++
+          ) {
+            const candidates =
+              offset === 0
+                ? [naturalStartY]
+                : [naturalStartY + offset, naturalStartY - offset]
+            for (const candidateStart of candidates) {
+              if (
+                candidateStart < startY ||
+                candidateStart + blockHeight - 1 > endY
+              ) {
+                continue
+              }
+              const fits = cellsPerLine.every((cells, lineIdx) =>
+                canPlaceLabelLineAvoidingMarkers(
+                  cells,
+                  labelX,
+                  candidateStart + lineIdx,
+                  0,
+                  lastLx,
+                  avoidForeignLines,
+                ),
+              )
+              if (fits) {
+                placedAtY = candidateStart
+                break
+              }
             }
           }
+          if (placedAtY !== null) break
         }
 
         if (placedAtY !== null) {

package/src/sequence.ts

@@ -96,6 +96,12 @@ export function renderSequenceAscii(
   const JB = useAscii ? '+' : '┴' // bottom junction on lifeline
   const JL = useAscii ? '+' : '├' // left junction
   const JR = useAscii ? '+' : '┤' // right junction
+  // Activation bar: the double-line glyph a lifeline gets while a
+  // participant is actively processing a call (issue #1133), overlaid in
+  // place of the plain lifeline `V`. Same Unicode/ASCII pairing draw-boxes.ts
+  // already uses for a double border (`║`/`‖` — see its `isDoubleBox`
+  // branch), reused here rather than inventing a second one.
+  const ACT = useAscii ? '‖' : '║'
 
   // ---- LAYOUT: compute lifeline X positions ----
 
@@ -850,10 +856,90 @@ export function renderSequenceAscii(
   }
   const lifelineBottom = (i: number) => destroyRow.get(i) ?? footerY
 
+  // ---- LAYOUT: activation intervals (rows where a lifeline is "active") ----
+  //
+  // Ports svg-renderer's layout.ts activation algorithm (its
+  // startActivation/endActivation/applyActivationEvents, ~lines 288-345) to
+  // row indices instead of y-pixels: a per-actor LIFO stack of open
+  // activations (start row pushed on `activate`, popped and closed into an
+  // interval on the matching `deactivate`), fed by both the standalone
+  // `activations` list and each message's inline `activate`/`deactivate`,
+  // plus a final pass closing anything still open at diagram end
+  // (unbalanced input) — same as the SVG layout's closing pass.
+  //
+  // Nesting depth (the SVG renderer's `depth`, used there to horizontally
+  // offset nested activation rects) isn't tracked here: the stack's LIFO
+  // order alone is enough to pair activate/deactivate correctly, and
+  // `isActiveAt` below only distinguishes "some activation covers this row"
+  // from "idle" — see the ACT-glyph comment there for why nesting doesn't
+  // get its own glyph.
+  const activationIntervals = new Map<
+    string,
+    Array<{ topRow: number; bottomRow: number }>
+  >()
+  const activationStacks = new Map<string, number[]>()
+
+  function startActivation(actorId: string, row: number): void {
+    const stack = activationStacks.get(actorId) ?? []
+    activationStacks.set(actorId, stack)
+    stack.push(row)
+  }
+  function endActivation(actorId: string, row: number): void {
+    const stack = activationStacks.get(actorId)
+    const startRow = stack?.pop()
+    if (startRow === undefined) return
+    const list = activationIntervals.get(actorId) ?? []
+    activationIntervals.set(actorId, list)
+    list.push({ topRow: startRow, bottomRow: row })
+  }
+
+  const activationEventsByAfterIndex = new Map<
+    number,
+    typeof diagram.activations
+  >()
+  for (const event of diagram.activations) {
+    const list = activationEventsByAfterIndex.get(event.afterIndex) ?? []
+    list.push(event)
+    activationEventsByAfterIndex.set(event.afterIndex, list)
+  }
+  function applyActivationEvents(afterIndex: number, row: number): void {
+    for (const event of activationEventsByAfterIndex.get(afterIndex) ?? []) {
+      if (event.kind === 'start') startActivation(event.actorId, row)
+      else endActivation(event.actorId, row)
+    }
+  }
+
+  applyActivationEvents(-1, headerBottom)
+  for (let m = 0; m < diagram.messages.length; m++) {
+    const msg = diagram.messages[m]!
+    const row = msgArrowY[m]!
+    if (msg.activate) startActivation(msg.to, row)
+    if (msg.deactivate) endActivation(msg.from, row)
+    applyActivationEvents(m, row)
+  }
+  // Unbalanced `activate` with no matching `deactivate`: close at the
+  // actor's own lifeline end, mirroring svg-renderer's layout.ts closing
+  // pass at the bottom of the message area.
+  for (const [actorId, stack] of activationStacks) {
+    if (stack.length === 0) continue
+    const bottomRow = lifelineBottom(actorIndexOf(actorId))
+    const list = activationIntervals.get(actorId) ?? []
+    activationIntervals.set(actorId, list)
+    for (const startRow of stack) list.push({ topRow: startRow, bottomRow })
+  }
+
+  /** Whether `actorId`'s lifeline is inside any activation at row `y`. */
+  function isActiveAt(actorId: string, y: number): boolean {
+    const intervals = activationIntervals.get(actorId)
+    if (!intervals) return false
+    return intervals.some((iv) => y >= iv.topRow && y <= iv.bottomRow)
+  }
+
   for (let i = 0; i < diagram.actors.length; i++) {
     const x = llX[i]!
+    const actorId = diagram.actors[i]!.id
     for (let y = lifelineTop(i); y <= lifelineBottom(i); y++) {
-      setC(x, y, V, 'line')
+      setC(x, y, isActiveAt(actorId, y) ? ACT : V, 'line')
     }
   }
 

package/src/shapes/index.ts

@@ -16,13 +16,15 @@ import type {
 } from './types.ts'
 
 // Import all shape renderers
-import { rectangleRenderer } from './rectangle.ts'
-import { diamondRenderer } from './diamond.ts'
-import { circleRenderer } from './circle.ts'
+import {
+  rectangleRenderer,
+  getBoxDimensions,
+  renderBox,
+  getBoxAttachmentPoint,
+} from './rectangle.ts'
+import { getCorners } from './corners.ts'
 import { stateStartRenderer, stateEndRenderer } from './state.ts'
-import { roundedRenderer } from './rounded.ts'
 import { stadiumRenderer } from './stadium.ts'
-import { hexagonRenderer } from './hexagon.ts'
 import {
   subroutineRenderer,
   doublecircleRenderer,
@@ -42,6 +44,46 @@ export type {
   ShapeRegistry,
 }
 
+/**
+ * Corner-decorated shape renderers — circle, diamond, rounded, hexagon.
+ * Each one renders a rectangle (`getBoxDimensions`/`renderBox`/
+ * `getBoxAttachmentPoint`) with a different corner-marker set pulled from
+ * corners.ts's `SHAPE_CORNERS`, instead of drawing curves or diagonals:
+ *
+ *   circle  (◯)       — circle markers indicate circular shape semantics
+ *   diamond (◇)       — diamond markers indicate decision node semantics
+ *   rounded (╭╮╰╯)    — rounded markers indicate soft edges
+ *   hexagon (⌜⌝⌞⌟)    — crop-corner markers indicate process node semantics;
+ *     not the hexagon glyph ⬡ (U+2B21) earlier docs here used to claim —
+ *     JetBrains Mono NL has no glyph for ⬡ at all, and the renderer hasn't
+ *     actually emitted it since corners.ts moved to the monospace-safe
+ *     crop-corner style. See issue #1062.
+ *
+ * Each renders as (TL/TR/BL/BR = that shape's four corner markers above):
+ *   TL─────────TR
+ *   │  Label  │
+ *   BL─────────BR
+ */
+function createCornerShapeRenderer(
+  shape: 'circle' | 'diamond' | 'rounded' | 'hexagon',
+): ShapeRenderer {
+  return {
+    getDimensions: getBoxDimensions,
+
+    render(label, dimensions, options) {
+      const corners = getCorners(shape, options.useAscii)
+      return renderBox(label, dimensions, corners, options.useAscii)
+    },
+
+    getAttachmentPoint: getBoxAttachmentPoint,
+  }
+}
+
+export const circleRenderer = createCornerShapeRenderer('circle')
+export const diamondRenderer = createCornerShapeRenderer('diamond')
+export const roundedRenderer = createCornerShapeRenderer('rounded')
+export const hexagonRenderer = createCornerShapeRenderer('hexagon')
+
 /**
  * Global shape registry — maps shape types to their renderers.
  * Rectangle is the default fallback for unregistered shapes.

package/src/shapes/circle.ts

@@ -1,31 +0,0 @@
-// ============================================================================
-// Circle shape renderer — uses corner decorators instead of curves
-// ============================================================================
-
-import type { ShapeRenderer } from './types.ts'
-import {
-  getBoxDimensions,
-  renderBox,
-  getBoxAttachmentPoint,
-} from './rectangle.ts'
-import { getCorners } from './corners.ts'
-
-/**
- * Circle shape renderer.
- * Uses circle markers (◯) at corners to indicate circular shape semantics.
- *
- * Renders as:
- *   ◯─────────◯
- *   │  Label  │
- *   ◯─────────◯
- */
-export const circleRenderer: ShapeRenderer = {
-  getDimensions: getBoxDimensions,
-
-  render(label, dimensions, options) {
-    const corners = getCorners('circle', options.useAscii)
-    return renderBox(label, dimensions, corners, options.useAscii)
-  },
-
-  getAttachmentPoint: getBoxAttachmentPoint,
-}

package/src/shapes/diamond.ts

@@ -1,31 +0,0 @@
-// ============================================================================
-// Diamond shape renderer — uses corner decorators instead of diagonals
-// ============================================================================
-
-import type { ShapeRenderer } from './types.ts'
-import {
-  getBoxDimensions,
-  renderBox,
-  getBoxAttachmentPoint,
-} from './rectangle.ts'
-import { getCorners } from './corners.ts'
-
-/**
- * Diamond shape renderer.
- * Uses diamond markers (◇) at corners to indicate decision node semantics.
- *
- * Renders as:
- *   ◇─────────◇
- *   │  Label  │
- *   ◇─────────◇
- */
-export const diamondRenderer: ShapeRenderer = {
-  getDimensions: getBoxDimensions,
-
-  render(label, dimensions, options) {
-    const corners = getCorners('diamond', options.useAscii)
-    return renderBox(label, dimensions, corners, options.useAscii)
-  },
-
-  getAttachmentPoint: getBoxAttachmentPoint,
-}

package/src/shapes/hexagon.ts

@@ -1,35 +0,0 @@
-// ============================================================================
-// Hexagon shape renderer — uses corner decorators instead of diagonals
-// ============================================================================
-
-import type { ShapeRenderer } from './types.ts'
-import {
-  getBoxDimensions,
-  renderBox,
-  getBoxAttachmentPoint,
-} from './rectangle.ts'
-import { getCorners } from './corners.ts'
-
-/**
- * Hexagon shape renderer.
- * Uses crop-corner markers (⌜⌝⌞⌟, see corners.ts's `SHAPE_CORNERS.hexagon`)
- * to indicate process node semantics — not the hexagon glyph ⬡ (U+2B21)
- * this comment used to claim: JetBrains Mono NL has no glyph for ⬡ at all,
- * and the renderer hasn't actually emitted it since corners.ts moved to
- * the monospace-safe crop-corner style. See issue #1062.
- *
- * Renders as:
- *   ⌜─────────⌝
- *   │  Label  │
- *   ⌞─────────⌟
- */
-export const hexagonRenderer: ShapeRenderer = {
-  getDimensions: getBoxDimensions,
-
-  render(label, dimensions, options) {
-    const corners = getCorners('hexagon', options.useAscii)
-    return renderBox(label, dimensions, corners, options.useAscii)
-  },
-
-  getAttachmentPoint: getBoxAttachmentPoint,
-}