@likec4/generators 1.52.0 → 1.53.0

package/likec4/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/likec4/index.d.mts",
+  "module": "../dist/likec4/index.mjs"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/generators",
-  "version": "1.52.0",
+  "version": "1.53.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -30,6 +30,14 @@
         "import": "./dist/index.mjs",
         "default": "./dist/index.mjs"
       }
+    },
+    "./likec4": {
+      "sources": "./src/likec4/index.ts",
+      "default": {
+        "types": "./dist/likec4/index.d.mts",
+        "import": "./dist/likec4/index.mjs",
+        "default": "./dist/likec4/index.mjs"
+      }
     }
   },
   "publishConfig": {
@@ -40,18 +48,24 @@
     "langium": "3.5.0",
     "pako": "^2.1.0",
     "remeda": "^2.33.6",
+    "immer": "^11.1.4",
     "json5": "^2.2.3",
-    "@likec4/core": "1.52.0",
-    "@likec4/log": "1.52.0"
+    "type-fest": "^4.41.0",
+    "indent-string": "^5.0.0",
+    "strip-indent": "^4.1.1",
+    "zod": "^3.25.76",
+    "@likec4/core": "1.53.0",
+    "@likec4/log": "1.53.0",
+    "@likec4/config": "1.53.0"
   },
   "devDependencies": {
-    "@types/node": "~22.19.11",
+    "@types/node": "~22.19.15",
     "@types/pako": "^2.0.4",
     "typescript": "5.9.3",
-    "obuild": "^0.4.31",
-    "vitest": "4.0.18",
-    "@likec4/tsconfig": "1.52.0",
-    "@likec4/devops": "1.42.0"
+    "obuild": "0.4.31",
+    "vitest": "4.1.0",
+    "@likec4/devops": "1.42.0",
+    "@likec4/tsconfig": "1.53.0"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",

package/src/drawio/generate-drawio.ts

@@ -438,6 +438,39 @@ function buildLikec4StyleForNode(params: NodeLikec4StyleParams): string {
   return parts.length > 0 ? parts.join(';') + ';' : ''
 }
 
+/** Bridge-managed style parts for profile 'leanix': likec4Id, likec4Kind, likec4ViewId, likec4ProjectId, bridgeManaged, optional leanixFactSheetType. */
+function buildBridgeManagedStyleForNode(
+  nodeId: string,
+  nodeKind: string,
+  viewId: string,
+  options: GenerateDrawioOptions | undefined,
+): string {
+  if (options?.profile !== 'leanix') return ''
+  const parts = [
+    'bridgeManaged=true',
+    `likec4Id=${encodeURIComponent(nodeId)}`,
+    `likec4Kind=${encodeURIComponent(nodeKind)}`,
+    `likec4ViewId=${encodeURIComponent(viewId)}`,
+  ]
+  if (options.projectId != null && options.projectId !== '') {
+    parts.push(`likec4ProjectId=${encodeURIComponent(options.projectId)}`)
+  }
+  const factSheetType = options.leanixFactSheetTypeByKind?.[nodeKind]
+  if (factSheetType != null && factSheetType !== '') {
+    parts.push(`leanixFactSheetType=${encodeURIComponent(factSheetType)}`)
+  }
+  return parts.join(';') + ';'
+}
+
+/** Bridge-managed style parts for edge when profile is 'leanix': likec4RelationId, bridgeManaged. */
+function buildBridgeManagedStyleForEdge(
+  relationId: string,
+  options: GenerateDrawioOptions | undefined,
+): string {
+  if (options?.profile !== 'leanix') return ''
+  return `bridgeManaged=true;likec4RelationId=${encodeURIComponent(relationId)};`
+}
+
 /** Build mxUserObject XML from customData for round-trip; returns empty string when customData is missing or empty. */
 function buildMxUserObjectXml(customData: Record<string, string> | undefined): string {
   if (
@@ -508,12 +541,13 @@ function buildEdgeGeometryXml(
   return `<mxGeometry relative="1" as="geometry">${pointsXml}</mxGeometry>`
 }
 
-/** Full edge style string for mxCell (arrows, anchors, stroke, dash, label, likec4 roundtrip). */
+/** Full edge style string for mxCell (arrows, anchors, stroke, dash, label, likec4 roundtrip, optional bridge-managed). */
 function buildEdgeStyleString(
   edge: Edge,
   layout: DiagramLayoutState,
   viewmodel: DrawioViewModelLike,
   label: string,
+  options: GenerateDrawioOptions | undefined,
 ): string {
   const { bboxes, fontFamily } = layout
   const sourceBbox = bboxes.get(edge.source)
@@ -550,13 +584,14 @@ function buildEdgeStyleString(
     edgeLinksJson,
     edgeMetadataJson,
   })
+  const edgeBridgeStyle = buildBridgeManagedStyleForEdge(edge.id, options)
   const edgeLabelColors = getEdgeLabelColors(viewmodel, edge.color)
   const edgeLabelStyle = label === ''
     ? ''
     : `fontColor=${edgeLabelColors.font};fontSize=12;align=center;verticalAlign=middle;labelBackgroundColor=none;fontFamily=${
       encodeURIComponent(fontFamily)
     };`
-  return `endArrow=${endArrow};startArrow=${startArrow};html=1;rounded=0;${anchorStyle}strokeColor=${strokeColor};strokeWidth=2;${dashStyle}${edgeLabelStyle}${edgeLikec4Style}`
+  return `endArrow=${endArrow};startArrow=${startArrow};html=1;rounded=0;${anchorStyle}strokeColor=${strokeColor};strokeWidth=2;${dashStyle}${edgeLabelStyle}${edgeLikec4Style}${edgeBridgeStyle}`
 }
 
 /** Build a single edge mxCell XML (orchestrator: label + geometry + style + assembly). */
@@ -573,7 +608,7 @@ function buildEdgeCellXml(
   const targetId = getCellId(edge.target)
   const label = buildEdgeLabelValue(edge)
   const edgeGeometryXml = buildEdgeGeometryXml(edge, options?.edgeWaypoints)
-  const styleStr = buildEdgeStyleString(edge, layout, viewmodel, label)
+  const styleStr = buildEdgeStyleString(edge, layout, viewmodel, label, options)
   const edgeCustomData = edgeOptionalFields.getCustomData(edge)
   const edgeUserObjectXml = buildMxUserObjectXml(edgeCustomData)
   return `<mxCell id="${edgeCellId}" value="${label}" style="${styleStr}" edge="1" parent="${defaultParentId}" source="${sourceId}" target="${targetId}">
@@ -650,6 +685,7 @@ function computeNodeStylePartsAndValue(
   const strokeColorByNodeId = options?.strokeColorByNodeId
   const strokeWidthByNodeId = options?.strokeWidthByNodeId
   const isContainer = containerNodeIds.has(node.id)
+  const nodeKind = (node as Node & { kind?: string }).kind ?? ''
   const title = node.title
   const desc = toExportString(node.description)
   const tech = toExportString(node.technology)
@@ -659,8 +695,11 @@ function computeNodeStylePartsAndValue(
   const navTo = toNonEmptyString(nodeOptionalFields.getNavigateTo(node))
   const iconName = toNonEmptyString(nodeOptionalFields.getIcon(node))
 
+  const isActor = nodeKind === 'actor' || node.shape === 'person'
   const shapeStyle = isContainer
     ? 'shape=rectangle;rounded=0;container=1;collapsible=0;startSize=0;'
+    : isActor
+    ? 'shape=actor;'
     : drawioShape(node.shape)
   const strokeColorOverride = strokeColorByNodeId?.[node.id]
   const strokeWidthOverride = strokeWidthByNodeId?.[node.id]
@@ -713,6 +752,8 @@ function computeNodeStylePartsAndValue(
     strokeHex,
     nodeNotation,
   })
+  const bridgeStyle = buildBridgeManagedStyleForNode(node.id, nodeKind, layout.view.id, options)
+  const likec4StyleWithBridge = likec4Style + bridgeStyle
 
   const nodeCustomData = nodeOptionalFields.getCustomData(node)
   const userObjectXml = buildMxUserObjectXml(nodeCustomData)
@@ -726,7 +767,7 @@ function computeNodeStylePartsAndValue(
 
   // vertexTextStyle already includes html=1; for both container and non-container
   const styleStr =
-    `${vertexTextStyle}${shapeStyle}${colorStyle}${strokeWidthStyle}${containerDashed}${fillOpacityStyle}${navLinkStyle}${likec4Style}`
+    `${vertexTextStyle}${shapeStyle}${colorStyle}${strokeWidthStyle}${containerDashed}${fillOpacityStyle}${navLinkStyle}${likec4StyleWithBridge}`
 
   return {
     value,
@@ -850,20 +891,32 @@ function getViewDescriptionString(view: View): string {
   return ''
 }
 
-/** Build root cell style string from view metadata (title, description, notation) for round-trip. */
-function buildRootCellStyle(view: View): string {
+/** Returns draw.io style tokens for the leanix profile (bridgeManaged, likec4ViewId, likec4ProjectId). Each token ends with ";". */
+function getLeanixRootStyleParts(view: View, options: GenerateDrawioOptions): string[] {
+  const parts = ['bridgeManaged=true;', `likec4ViewId=${encodeURIComponent(view.id)};`]
+  if (options.projectId != null && options.projectId !== '') {
+    parts.push(`likec4ProjectId=${encodeURIComponent(options.projectId)};`)
+  }
+  return parts
+}
+
+/** Build root cell style string from view metadata (title, description, notation) for round-trip; when profile is 'leanix' adds likec4ViewId, likec4ProjectId, bridgeManaged. */
+function buildRootCellStyle(view: View, options: GenerateDrawioOptions | undefined): string {
   const viewTitle = getViewTitle(view)
   const viewDesc = getViewDescriptionString(view)
   const viewDescEnc = viewDesc.trim() !== '' ? encodeURIComponent(viewDesc.trim()) : ''
   const viewNotationRaw = (view as unknown as { notation?: unknown }).notation
   const viewNotation = typeof viewNotationRaw === 'string' && viewNotationRaw !== '' ? viewNotationRaw : undefined
   const viewNotationEnc = viewNotation != null ? encodeURIComponent(viewNotation) : ''
-  const rootParts = [
+  const rootParts: string[] = [
     'rounded=1;whiteSpace=wrap;html=1;fillColor=none;strokeColor=none;',
     `likec4ViewTitle=${encodeURIComponent(viewTitle ?? view.id)};`,
     viewDescEnc !== '' ? `likec4ViewDescription=${viewDescEnc};` : '',
     viewNotationEnc !== '' ? `likec4ViewNotation=${viewNotationEnc};` : '',
   ]
+  if (options?.profile === 'leanix') {
+    rootParts.push(...getLeanixRootStyleParts(view, options))
+  }
   return rootParts.join('')
 }
 
@@ -892,6 +945,9 @@ function drawioArrow(arrow: string | undefined | null): string {
   }
 }
 
+/** Draw.io export profile: default (round-trip) or leanix (bridge-managed metadata for LeanIX interoperability). */
+export type DrawioExportProfile = 'default' | 'leanix'
+
 /** Optional overrides for round-trip (e.g. from parsed comment blocks). Keys are node/edge ids from the view. */
 export type GenerateDrawioOptions = {
   /** Node id -> bbox to use instead of viewmodel layout */
@@ -912,6 +968,15 @@ export type GenerateDrawioOptions = {
    * Set for deterministic output (e.g. tests, content-addressable storage).
    */
   modified?: string
+  /**
+   * Export profile. When 'leanix', adds bridge-managed metadata (likec4Id, likec4Kind, likec4ViewId,
+   * likec4ProjectId, likec4RelationId, bridgeManaged) for round-trip and LeanIX interoperability.
+   */
+  profile?: DrawioExportProfile
+  /** Project id (included when profile is 'leanix' as likec4ProjectId). */
+  projectId?: string
+  /** Optional mapping of element kind -> LeanIX fact sheet type (included when profile is 'leanix' as leanixFactSheetType on vertices). */
+  leanixFactSheetTypeByKind?: Record<string, string>
 }
 
 /** Result of layout phase: bboxes, offsets, and shared styling so cell-building phase stays readable. */
@@ -1202,7 +1267,7 @@ function generateDiagramContent(
     )
   }
 
-  const rootCellStyle = buildRootCellStyle(view)
+  const rootCellStyle = buildRootCellStyle(view, options)
 
   const allCells = [
     `<mxCell id="${defaultParentId}" value="" style="${rootCellStyle}" vertex="1" parent="${rootId}">

package/src/drawio/index.ts

@@ -1,6 +1,7 @@
 export {
   buildDrawioExportOptionsForViews,
   buildDrawioExportOptionsFromSource,
+  type DrawioExportProfile,
   type DrawioViewModelLike,
   generateDrawio,
   generateDrawioEditUrl,

package/src/drawio/parse-drawio.ts

@@ -89,10 +89,16 @@ export interface DrawioCell {
   notation?: string
   /** From style likec4Metadata (edge; JSON object for relation metadata block) */
   metadata?: string
+  /** From style likec4Id (vertex; bridge-managed element id for round-trip) */
+  likec4Id?: string
+  /** From style likec4RelationId (edge; bridge-managed relation id for round-trip) */
+  likec4RelationId?: string
   /** From mxUserObject/data keys not mapped to fields above (JSON object for round-trip comment) */
   customData?: string
   /** From mxGeometry Array/mxPoint (edge waypoints; JSON array of [x,y][]) */
   edgePoints?: string
+  /** From style key "shape" (e.g. actor, person) for kind/shape inference when raw style string is unavailable */
+  shapeFromStyle?: string
 }
 
 /** Edge cell with required source and target; use after filtering with isEdgeWithEndpoints. */
@@ -132,6 +138,77 @@ function getAttr(attrs: string, name: string): string | undefined {
   return undefined
 }
 
+/**
+ * Fallback to extract style value from attrs when getAttr(attrs, 'style') returns undefined (e.g. spacing like "style =\"").
+ * Looks for style="..." (case-insensitive, optional spaces before '=') and returns the quoted value so the cell gets style when present in XML.
+ */
+function extractStyleFromAttrsFallback(attrs: string): string | undefined {
+  const lower = attrs.toLowerCase()
+  let i = lower.indexOf('style')
+  while (i !== -1) {
+    const prev = i === 0 ? ' ' : (attrs[i - 1] ?? ' ')
+    if (!isAttrBoundaryChar(prev)) {
+      i = lower.indexOf('style', i + 1)
+      continue
+    }
+    let j = i + 5 // after "style"
+    while (j < attrs.length && isAttrBoundaryChar(attrs[j] ?? '')) j += 1
+    if (j < attrs.length && attrs[j] === '=') {
+      j += 1
+      while (j < attrs.length && isAttrBoundaryChar(attrs[j] ?? '')) j += 1
+      if (j < attrs.length && attrs[j] === '"') {
+        const valueStart = j + 1
+        const valueEnd = attrs.indexOf('"', valueStart)
+        if (valueEnd !== -1) return attrs.slice(valueStart, valueEnd)
+      }
+    }
+    i = lower.indexOf('style', i + 1)
+  }
+  return undefined
+}
+
+/** Extract style value from full open tag (e.g. from fullTag.slice(0, fullTag.indexOf('>'))). Use when attrs-based extraction missed it. */
+function extractStyleFromOpenTag(fullTag: string): string | undefined {
+  const gt = fullTag.indexOf('>')
+  if (gt === -1) return undefined
+  return getAttr(fullTag.slice(7, gt), 'style') ?? extractStyleFromAttrsFallback(fullTag.slice(7, gt))
+}
+
+/** Max fullTag length to run style re-extraction (avoids scanning huge strings). */
+const MAX_FULLTAG_LENGTH_FOR_STYLE_SCAN = 10_000
+/** Characters to scan for style=" or style=' when re-extracting from tag (covers open tag). */
+const STYLE_VALUE_SCAN_CHARS = 1500
+
+/**
+ * Re-extract style attribute value from tag content when getAttr missed it.
+ * Scans the first maxScan chars for style="..." or style='...'.
+ */
+function extractStyleFromTagContent(fullTag: string, maxScan = STYLE_VALUE_SCAN_CHARS): string | undefined {
+  const scan = fullTag.slice(0, maxScan)
+  const styleDq = scan.toLowerCase().indexOf('style="')
+  const styleSq = scan.toLowerCase().indexOf('style=\'')
+  const useDq = styleDq !== -1 && (styleSq === -1 || styleDq <= styleSq)
+  const styleIdx = useDq ? styleDq : styleSq
+  const quote = styleIdx !== -1 ? (useDq ? '"' : '\'') : ''
+  if (styleIdx === -1 || !quote) return undefined
+  const valueStart = styleIdx + 7
+  const valueEnd = scan.indexOf(quote, valueStart)
+  return valueEnd !== -1 ? scan.slice(valueStart, valueEnd) : undefined
+}
+
+/** True when style or fullTag (lowercased) indicates actor/person shape. */
+function styleOrTagIndicatesActor(style: string | undefined, fullTagLower: string): boolean {
+  const s = style?.toLowerCase() ?? ''
+  return (
+    s.includes('shape=actor') ||
+    s.includes('shape=person') ||
+    s.includes('umlactor') ||
+    fullTagLower.includes('shape=actor') ||
+    fullTagLower.includes('shape=person') ||
+    fullTagLower.includes('umlactor')
+  )
+}
+
 /** Find end of XML open tag (first unquoted '>'). Handles both single- and double-quoted attributes. Avoids regex for S5852. */
 function findOpenTagEnd(xml: string, start: number): number {
   let quoteChar = ''
@@ -338,6 +415,8 @@ function buildCellOptionalFields(params: {
   const relationshipKind = getDecodedStyle(styleMap, 'likec4relationshipkind')
   const notation = getDecodedStyle(styleMap, 'likec4notation')
   const metadata = getDecodedStyle(styleMap, 'likec4metadata')
+  const likec4Id = getDecodedStyle(styleMap, 'likec4id')
+  const likec4RelationId = getDecodedStyle(styleMap, 'likec4relationid')
   const optional: Partial<DrawioCell> = {}
   if (params.valueRaw != null && params.valueRaw !== '') {
     optional.value = decodeXmlEntities(params.valueRaw)
@@ -346,6 +425,10 @@ function buildCellOptionalFields(params: {
   if (params.source != null && params.source !== '') optional.source = params.source
   if (params.target != null && params.target !== '') optional.target = params.target
   if (params.style != null && params.style !== '') optional.style = params.style
+  else if (params.styleMap.has('shape')) {
+    // Fallback: raw style string may be missing from attrs (e.g. parsing path); ensure kind/shape inference can run
+    optional.style = `shape=${params.styleMap.get('shape')};`
+  }
   if (x !== undefined) optional.x = x
   if (y !== undefined) optional.y = y
   if (width !== undefined) optional.width = width
@@ -376,6 +459,16 @@ function buildCellOptionalFields(params: {
   if (relationshipKind != null) optional.relationshipKind = relationshipKind
   if (notation != null) optional.notation = notation
   if (metadata != null && edge) optional.metadata = metadata
+  if (likec4Id != null && vertex) optional.likec4Id = likec4Id
+  if (likec4RelationId != null && edge) optional.likec4RelationId = likec4RelationId
+  let shapeFromStyle = params.styleMap.get('shape')?.trim()
+  const fullTagLower = params.fullTag.toLowerCase()
+  if (
+    (shapeFromStyle == null || shapeFromStyle === '') && vertex && styleOrTagIndicatesActor(params.style, fullTagLower)
+  ) {
+    shapeFromStyle = 'actor'
+  }
+  if (shapeFromStyle != null && shapeFromStyle !== '' && vertex) optional.shapeFromStyle = shapeFromStyle
   if (userData.customData != null) optional.customData = userData.customData
   if (edge) {
     const pts = parseEdgePoints(fullTag)
@@ -399,9 +492,19 @@ function buildCellFromMxCell(
   if (!id) return null
   const vertex = getAttr(attrs, 'vertex') === '1'
   const edge = getAttr(attrs, 'edge') === '1'
-  const style = getAttr(attrs, 'style')
+  let style = getAttr(attrs, 'style') ??
+    extractStyleFromAttrsFallback(attrs) ??
+    extractStyleFromOpenTag(fullTag)
+  const styleMissing = !style || style.trim() === ''
+  const tagHasActor = fullTag.length < MAX_FULLTAG_LENGTH_FOR_STYLE_SCAN &&
+    fullTag.toLowerCase().includes('shape=actor')
+  const needLastResort = styleMissing || (tagHasActor && !style?.toLowerCase().includes('shape=actor'))
+  if (needLastResort && fullTag.length < MAX_FULLTAG_LENGTH_FOR_STYLE_SCAN) {
+    const reExtracted = extractStyleFromTagContent(fullTag)
+    if (reExtracted != null) style = reExtracted
+  }
   const geomStr = extractMxGeometryOpenTag(fullTag)
-  const styleMap = parseStyle(style ?? undefined)
+  const styleMap = parseStyle(style?.trim() || undefined)
   const userData = parseUserData(inner)
   const navigateTo = overrides?.navigateTo ?? getDecodedStyle(styleMap, 'likec4navigateto')
   const optional = buildCellOptionalFields({
@@ -409,7 +512,7 @@ function buildCellFromMxCell(
     parent: getAttr(attrs, 'parent'),
     source: getAttr(attrs, 'source'),
     target: getAttr(attrs, 'target'),
-    style: getAttr(attrs, 'style'),
+    style,
     styleMap,
     userData,
     geomStr,
@@ -418,7 +521,7 @@ function buildCellFromMxCell(
     edge,
     navigateTo,
   })
-  return { id, vertex, edge, ...optional } as DrawioCell
+  return { id, vertex, edge, ...(style != null && style !== '' ? { style } : {}), ...optional } as DrawioCell
 }
 
 /** Extract one mxCell from xml starting at tagStart. Returns attrs, inner, fullTag and next search index, or null. */
@@ -549,20 +652,29 @@ function likec4LineType(
   return undefined
 }
 
+/** True when style or shapeFromStyle indicates actor/person (DrawIO shape=actor, shape=person, umlActor). */
+function isActorShapeInStyle(style: string | undefined, shapeFromStyle?: string): boolean {
+  const s = style?.toLowerCase() ?? ''
+  const shape = shapeFromStyle?.toLowerCase().trim()
+  return shape === 'actor' || shape === 'person' || s.includes('shape=actor') || s.includes('shape=person') ||
+    s.includes('umlactor')
+}
+
 /**
  * Infer LikeC4 element kind from DrawIO shape style. When parent is a container (container=1), child is component.
  * Explicit container=1 in style → system (context box); others default to container unless actor/swimlane.
+ * Uses shapeFromStyle when raw style is missing so actor/person is still inferred.
  */
 function inferKind(
   style: string | undefined,
   parentCell?: DrawioCell,
+  shapeFromStyle?: string,
 ): 'actor' | 'system' | 'container' | 'component' {
   const s = style?.toLowerCase() ?? ''
+  if (isActorShapeInStyle(style, shapeFromStyle)) return 'actor'
   switch (true) {
-    case !style:
+    case !style && !shapeFromStyle:
       return parentCell?.style?.toLowerCase().includes('container=1') ? 'component' : 'container'
-    case s.includes('umlactor') || s.includes('shape=person') || s.includes('shape=actor'):
-      return 'actor'
     case s.includes('swimlane'):
     case s.includes('container=1'):
       return 'system'
@@ -573,12 +685,10 @@ function inferKind(
   }
 }
 
-/** Infer LikeC4 shape from DrawIO style when possible (person, cylinder, document, etc.). */
-function inferShape(style: string | undefined): string | undefined {
-  if (!style) return undefined
-  const s = style.toLowerCase()
-  // Actor/person shape (export may use shape=actor or shape=umlActor; legacy may have shape=person)
-  if (s.includes('shape=actor') || s.includes('shape=person') || s.includes('umlactor')) return 'person'
+/** Infer LikeC4 shape from DrawIO style (or shapeFromStyle) when possible (person, cylinder, document, etc.). */
+function inferShape(style: string | undefined, shapeFromStyle?: string): string | undefined {
+  const s = style?.toLowerCase() ?? ''
+  if (isActorShapeInStyle(style, shapeFromStyle)) return 'person'
   if (s.includes('shape=cylinder') || s.includes('cylinder3')) return 'cylinder'
   if (s.includes('shape=document')) return 'document'
   if (s.includes('shape=rectangle') && s.includes('rounded')) return 'rectangle'
@@ -610,16 +720,60 @@ function makeUniqueName(usedNames: Set<string>): (base: string) => string {
   }
 }
 
-/** Assign FQNs to element vertices: root first, then hierarchy by parent, then orphans (DRY). */
+/** True when s is a syntactically valid dot-separated FQN (each segment non-empty, identifier-like). */
+function isValidFqn(s: string): boolean {
+  if (s.length === 0) return false
+  const segments = s.split('.')
+  return segments.every(seg => /^[a-zA-Z0-9_-]+$/.test(seg))
+}
+
+/** Depth of vertex from root (0 = root or parent not in diagram). Cycle-safe: cycles in parent graph return 0. */
+function vertexDepth(
+  v: DrawioCell,
+  idToVertex: Map<string, DrawioCell>,
+  visited: Set<string> = new Set(),
+): number {
+  if (visited.has(v.id)) return 0
+  visited.add(v.id)
+  if (v.parent == null || !idToVertex.has(v.parent)) return 0
+  return 1 + vertexDepth(idToVertex.get(v.parent)!, idToVertex, visited)
+}
+
+/** True when bridgeId is valid FQN and matches parent chain (root or prefix). */
+function isUsableBridgeId(
+  bridgeId: string,
+  v: DrawioCell,
+  idToFqn: Map<string, string>,
+  _idToVertex: Map<string, DrawioCell>,
+  isRootParent: (parent: string | undefined) => boolean,
+): boolean {
+  if (!isValidFqn(bridgeId)) return false
+  const parentFqn = v.parent ? idToFqn.get(v.parent) : undefined
+  if (parentFqn === undefined) return isRootParent(v.parent)
+  return bridgeId.startsWith(parentFqn + '.') && bridgeId.length > parentFqn.length + 1
+}
+
+/** Assign FQNs to element vertices: bridge-managed likec4Id first (when valid), then root, hierarchy, orphans (DRY). */
 function assignFqnsToElementVertices(
   idToFqn: Map<string, string>,
   elementVertices: DrawioCell[],
   containerIdToTitle: Map<string, string>,
   isRootParent: (parent: string | undefined) => boolean,
   uniqueName: (base: string) => string,
+  usedNames: Set<string>,
 ): void {
   const baseName = (v: DrawioCell) => v.value ?? containerIdToTitle.get(v.id) ?? v.id
+  const idToVertex = new Map(elementVertices.map(v => [v.id, v]))
+  const byDepth = [...elementVertices].sort((a, b) => vertexDepth(a, idToVertex) - vertexDepth(b, idToVertex))
+  for (const v of byDepth) {
+    const bridgeId = v.likec4Id?.trim()
+    if (bridgeId && isUsableBridgeId(bridgeId, v, idToFqn, idToVertex, isRootParent)) {
+      idToFqn.set(v.id, bridgeId)
+      for (const segment of bridgeId.split('.')) usedNames.add(segment)
+    }
+  }
   for (const v of elementVertices) {
+    if (idToFqn.has(v.id)) continue
     if (isRootParent(v.parent)) idToFqn.set(v.id, uniqueName(baseName(v)))
   }
   let changed = true
@@ -804,7 +958,7 @@ function pushElementStyleBlock(
 ): void {
   const border = cell.border?.trim()
   const opacityVal = cell.opacity
-  const shapeOverride = inferShape(cell.style)
+  const shapeOverride = inferShape(cell.style, cell.shapeFromStyle)
   const sizeVal = cell.size?.trim()
   const paddingVal = cell.padding?.trim()
   const textSizeVal = cell.textSize?.trim()
@@ -918,7 +1072,7 @@ function elementHasBody(
     !!colorName ||
     !!cell.border?.trim() ||
     !!cell.opacity ||
-    !!inferShape(cell.style) ||
+    !!inferShape(cell.style, cell.shapeFromStyle) ||
     !!cell.size ||
     !!cell.padding ||
     !!cell.textSize ||
@@ -974,7 +1128,7 @@ function emitElementToLines(ctx: ElementEmitContext, cellId: string, fqn: string
   const cell = ctx.idToCell.get(cellId)
   if (!cell) return
   const parentCell = cell.parent ? ctx.byId.get(cell.parent) : undefined
-  const kind = inferKind(cell.style, parentCell)
+  const kind = inferKind(cell.style, parentCell, cell.shapeFromStyle)
   const rawTitle = (cell.value && cell.value.trim()) || ''
   const title = stripHtml(rawTitle) ||
     (ctx.containerIdToTitle.get(cell.id) ?? ctx.containerIdToTitle.get(cellId) ?? '') ||
@@ -1363,7 +1517,7 @@ function buildCommonDiagramStateFromCells(
   const elementVertices = vertices.filter(v => !titleCellIds.has(v.id))
   const usedNames = new Set<string>()
   const uniqueName = makeUniqueName(usedNames)
-  assignFqnsToElementVertices(idToFqn, elementVertices, containerIdToTitle, isRootParent, uniqueName)
+  assignFqnsToElementVertices(idToFqn, elementVertices, containerIdToTitle, isRootParent, uniqueName, usedNames)
   const hexToCustomName = buildHexToCustomName(elementVertices, edges)
   const children = new Map<string, Array<{ cellId: string; fqn: string }>>()
   const roots: Array<{ cellId: string; fqn: string }> = []

package/src/index.ts

@@ -3,6 +3,7 @@ export { DEFAULT_DRAWIO_ALL_FILENAME } from './drawio/constants'
 export {
   buildDrawioExportOptionsForViews,
   buildDrawioExportOptionsFromSource,
+  type DrawioExportProfile,
   type DrawioViewModelLike,
   generateDrawio,
   generateDrawioEditUrl,
@@ -10,6 +11,7 @@ export {
   type GenerateDrawioOptions,
 } from './drawio/generate-drawio'
 export {
+  decompressDrawioDiagram,
   getAllDiagrams,
   parseDrawioRoundtripComments,
   parseDrawioToLikeC4,

package/src/likec4/generate-likec4.ts

@@ -0,0 +1,72 @@
+import * as operators from './operators'
+import { type AnyOp, type ctxOf, materialize, withctx } from './operators/base'
+import { schemas } from './schemas'
+
+type Params = {
+  indentation?: string | number
+}
+
+export function generateLikeC4(input: schemas.likec4data.Input, params?: Params): string {
+  params = {
+    indentation: 2,
+    ...params,
+  }
+  return materialize(withctx(input, operators.likec4data()), params.indentation)
+}
+
+/**
+ * Prints the result of an operation with the data
+ *
+ * @see operators
+ *
+ * @example
+ * ```ts
+ * print(operators.expression, {
+ *   ref: {
+ *     model: 'some.el',
+ *   },
+ *   selector: 'descendants',
+ * })
+ * // "some.el.**"
+ * ```
+ *
+ * @example
+ * ```ts
+ * print(operators.model, {
+ *   elements: [
+ *     {
+ *       id: 'cloud',
+ *       kind: 'system',
+ *     },
+ *     {
+ *       id: 'cloud.mobile',
+ *       kind: 'mobileapp',
+ *       shape: 'mobile',
+ *       color: 'amber',
+ *     }
+ *   ],
+ * })
+ * // model {
+ * //   cloud = system {
+ * //     mobile = mobileapp {
+ * //       style {
+ * //         shape mobile
+ * //         color amber
+ * //       }
+ * //     }
+ * //   }
+ * // }
+ * ```
+ */
+export function print<O extends () => AnyOp>(operator: O, data: ctxOf<O>, params?: Params): string {
+  return materialize(withctx(data, operator()), params?.indentation)
+}
+
+/**
+ * Same as {@link print} but uses tab indentation
+ */
+export function printTabIndent<O extends () => AnyOp>(operator: O, data: ctxOf<O>): string {
+  return materialize(withctx(data, operator()), '\t')
+}
+
+export { operators }

package/src/likec4/index.ts

@@ -0,0 +1,12 @@
+export {
+  generateLikeC4 as generate,
+  operators,
+  print,
+  printTabIndent,
+} from './generate-likec4'
+
+export type * from './operators/base'
+
+export type {
+  schemas,
+} from './schemas'