create-yss-spec 2.1.4 → 2.1.6

package/template/.agents/skills/drawio/scripts/dsl/auto-layout.js

@@ -1,206 +0,0 @@
-/**
- * auto-layout.js
- * Edge-aware layered auto-layout (vendored elkjs) as an async pre-pass:
- * for a hierarchical spec whose nodes carry no explicit bounds/position it
- * computes a layered layout (modules as compound containers, orthogonal edge
- * routes) and returns a copy of the spec with node bounds and edge waypoints
- * filled in, so the synchronous converter consumes them like hand-written
- * geometry. If the vendored engine is unavailable or fails, callers keep the
- * original spec and the legacy grid layout applies.
- */
-
-import { createRequire } from 'node:module'
-import { detectSemanticType, deriveNodeIcon, getNodeSize } from './spec-to-drawio.js'
-
-const require = createRequire(import.meta.url)
-
-const MARGIN = 40
-const MODULE_PADDING = '[top=56,left=24,bottom=24,right=24]'
-// Spacing is looked up per containing node under INCLUDE_CHILDREN, so module
-// containers need the same values or their interiors fall back to elk defaults.
-const SPACING_OPTIONS = {
-  'elk.layered.spacing.nodeNodeBetweenLayers': '64',
-  'elk.spacing.nodeNode': '32',
-  'elk.spacing.edgeNode': '24'
-}
-const ROOT_LAYOUT_OPTIONS = {
-  'elk.algorithm': 'layered',
-  'elk.direction': 'RIGHT',
-  'elk.edgeRouting': 'ORTHOGONAL',
-  'elk.hierarchyHandling': 'INCLUDE_CHILDREN',
-  ...SPACING_OPTIONS
-}
-
-let elkInstance
-
-function loadElk() {
-  if (elkInstance !== undefined) return elkInstance
-  try {
-    const ELK = require('../vendor/elkjs/elk.bundled.cjs')
-    elkInstance = new ELK()
-  } catch {
-    elkInstance = null
-  }
-  return elkInstance
-}
-
-export function hasExplicitPosition(node) {
-  return node?.bounds != null || node?.position != null
-}
-
-/**
- * Auto-layout applies only to fully unpositioned hierarchical specs:
- * any explicit bounds/position means the author owns the geometry.
- */
-export function canAutoLayout(spec) {
-  if (spec?.meta?.layout !== 'hierarchical') return false
-  const nodes = spec.nodes || []
-  if (nodes.length === 0) return false
-  return !nodes.some(hasExplicitPosition)
-}
-
-export function buildElkGraph(spec) {
-  const nodes = spec.nodes || []
-  const modules = spec.modules || []
-
-  const moduleContainers = new Map()
-  for (const module of modules) {
-    moduleContainers.set(module.id, {
-      id: module.id,
-      layoutOptions: { 'elk.padding': MODULE_PADDING, ...SPACING_OPTIONS },
-      children: []
-    })
-  }
-
-  const children = []
-  const nodeIds = new Set()
-  for (const node of nodes) {
-    nodeIds.add(node.id)
-    const semanticType = detectSemanticType(node.label, node.type, node.network)
-    const size = getNodeSize(node.size, semanticType, node.label, {
-      fontSize: node.style?.fontSize,
-      contentAware: !(node.icon || deriveNodeIcon(node))
-    })
-    const elkNode = { id: node.id, width: size.width, height: size.height }
-    const container = node.module ? moduleContainers.get(node.module) : null
-    if (container) {
-      container.children.push(elkNode)
-    } else {
-      children.push(elkNode)
-    }
-  }
-
-  for (const container of moduleContainers.values()) {
-    if (container.children.length > 0) children.push(container)
-  }
-
-  const edges = []
-  ;(spec.edges || []).forEach((edge, index) => {
-    if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) return
-    if (edge.from === edge.to) return
-    edges.push({ id: `e${index}`, sources: [edge.from], targets: [edge.to] })
-  })
-
-  return { id: 'root', layoutOptions: ROOT_LAYOUT_OPTIONS, children, edges }
-}
-
-function collectAbsoluteOrigins(container, originX, originY, origins) {
-  origins.set(container.id, { x: originX, y: originY })
-  for (const child of container.children || []) {
-    collectAbsoluteOrigins(child, originX + (child.x || 0), originY + (child.y || 0), origins)
-  }
-}
-
-function dedupePoints(points) {
-  const result = []
-  for (const point of points) {
-    const prev = result[result.length - 1]
-    if (!prev || Math.abs(prev.x - point.x) >= 1 || Math.abs(prev.y - point.y) >= 1) {
-      result.push(point)
-    }
-  }
-  return result
-}
-
-/**
- * Map an elk layout result back onto the spec: absolute node bounds for every
- * leaf node, absolute waypoints from orthogonal bend points. Elk reports edge
- * coordinates relative to `edge.container` (the least common ancestor), so
- * every id's absolute origin is resolved first.
- */
-export function convertElkResult(spec, result) {
-  const origins = new Map()
-  collectAbsoluteOrigins(result, MARGIN, MARGIN, origins)
-
-  const nodeBounds = new Map()
-  const walk = (container) => {
-    for (const child of container.children || []) {
-      if (child.children?.length) {
-        walk(child)
-      } else {
-        const origin = origins.get(child.id)
-        nodeBounds.set(child.id, {
-          x: Math.round(origin.x),
-          y: Math.round(origin.y),
-          width: Math.round(child.width || 0),
-          height: Math.round(child.height || 0)
-        })
-      }
-    }
-  }
-  walk(result)
-
-  const waypointsByEdgeIndex = new Map()
-  for (const edge of result.edges || []) {
-    const section = edge.sections?.[0]
-    if (!section?.bendPoints?.length) continue
-    const origin = origins.get(edge.container || 'root') || { x: MARGIN, y: MARGIN }
-    const points = dedupePoints(
-      section.bendPoints.map((point) => ({
-        x: Math.round(point.x + origin.x),
-        y: Math.round(point.y + origin.y)
-      }))
-    )
-    if (points.length === 0) continue
-    waypointsByEdgeIndex.set(Number(edge.id.slice(1)), points)
-  }
-
-  return {
-    ...spec,
-    nodes: (spec.nodes || []).map((node) =>
-      nodeBounds.has(node.id) ? { ...node, bounds: nodeBounds.get(node.id) } : node
-    ),
-    edges: (spec.edges || []).map((edge, index) =>
-      waypointsByEdgeIndex.has(index) ? { ...edge, waypoints: waypointsByEdgeIndex.get(index) } : edge
-    )
-  }
-}
-
-/**
- * @param {Object} spec - parsed spec
- * @param {Object} [options] - `elk` overrides the engine instance (tests)
- * @returns {Promise<{spec: Object, applied: boolean, warning?: string}>}
- */
-export async function applyAutoLayout(spec, options = {}) {
-  if (!canAutoLayout(spec)) {
-    return { spec, applied: false }
-  }
-  const elk = options.elk !== undefined ? options.elk : loadElk()
-  if (!elk) {
-    return {
-      spec,
-      applied: false,
-      warning: 'Auto-layout engine (vendored elkjs) is unavailable; falling back to the legacy grid layout.'
-    }
-  }
-  try {
-    const result = await elk.layout(buildElkGraph(spec))
-    return { spec: convertElkResult(spec, result), applied: true }
-  } catch (err) {
-    return {
-      spec,
-      applied: false,
-      warning: `Auto-layout failed (${err.message}); falling back to the legacy grid layout.`
-    }
-  }
-}

package/template/.agents/skills/drawio/scripts/dsl/auto-layout.test.js

@@ -1,249 +0,0 @@
-/**
- * auto-layout.test.js
- * Unit tests for the elkjs-backed auto-layout pre-pass
- */
-
-import { describe, it } from 'node:test'
-import assert from 'node:assert'
-import { applyAutoLayout, buildElkGraph, canAutoLayout, convertElkResult, hasExplicitPosition } from './auto-layout.js'
-import {
-  calculateLayout,
-  computeLayoutQualityMetrics,
-  loadTheme,
-  specToDrawioXml,
-  validateEdgeQuality
-} from './spec-to-drawio.js'
-
-const WORKFLOW_SPEC = {
-  meta: { title: 'Auto workflow', layout: 'hierarchical' },
-  modules: [
-    { id: 'prep', label: 'Preparation' },
-    { id: 'delivery', label: 'Delivery' }
-  ],
-  nodes: [
-    { id: 'start', label: 'Start', type: 'terminal' },
-    { id: 'validate', label: 'Validate', module: 'prep' },
-    { id: 'enrich_a', label: 'Enrich A', module: 'prep' },
-    { id: 'enrich_b', label: 'Enrich B', module: 'prep' },
-    { id: 'merge', label: 'Merge', module: 'prep' },
-    { id: 'transform', label: 'Transform' },
-    { id: 'review', label: 'Review' },
-    { id: 'approve', label: 'Auto Approve' },
-    { id: 'publish', label: 'Publish', module: 'delivery' },
-    { id: 'notify', label: 'Notify', module: 'delivery' },
-    { id: 'archive', label: 'Archive', module: 'delivery' },
-    { id: 'end', label: 'End', type: 'terminal' }
-  ],
-  edges: [
-    { from: 'start', to: 'validate' },
-    { from: 'validate', to: 'enrich_a' },
-    { from: 'validate', to: 'enrich_b' },
-    { from: 'enrich_a', to: 'merge' },
-    { from: 'enrich_b', to: 'merge' },
-    { from: 'merge', to: 'transform' },
-    { from: 'transform', to: 'review' },
-    { from: 'transform', to: 'approve' },
-    { from: 'review', to: 'publish' },
-    { from: 'approve', to: 'publish' },
-    { from: 'publish', to: 'notify' },
-    { from: 'publish', to: 'archive' },
-    { from: 'notify', to: 'end' },
-    { from: 'archive', to: 'end' }
-  ]
-}
-
-function rectsOverlap(a, b) {
-  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height
-}
-
-describe('auto-layout gate', () => {
-  it('accepts fully unpositioned hierarchical specs', () => {
-    assert.equal(canAutoLayout(WORKFLOW_SPEC), true)
-  })
-
-  it('rejects non-hierarchical layouts', () => {
-    assert.equal(canAutoLayout({ ...WORKFLOW_SPEC, meta: { layout: 'horizontal' } }), false)
-    assert.equal(canAutoLayout({ ...WORKFLOW_SPEC, meta: {} }), false)
-  })
-
-  it('rejects specs with any explicit bounds or position', () => {
-    const withBounds = {
-      ...WORKFLOW_SPEC,
-      nodes: [
-        { ...WORKFLOW_SPEC.nodes[0], bounds: { x: 0, y: 0, width: 100, height: 40 } },
-        ...WORKFLOW_SPEC.nodes.slice(1)
-      ]
-    }
-    assert.equal(canAutoLayout(withBounds), false)
-    const withPosition = {
-      ...WORKFLOW_SPEC,
-      nodes: [{ ...WORKFLOW_SPEC.nodes[0], position: { x: 10, y: 10 } }, ...WORKFLOW_SPEC.nodes.slice(1)]
-    }
-    assert.equal(canAutoLayout(withPosition), false)
-    assert.equal(hasExplicitPosition({ id: 'n', bounds: { x: 0, y: 0, width: 1, height: 1 } }), true)
-    assert.equal(hasExplicitPosition({ id: 'n' }), false)
-  })
-})
-
-describe('buildElkGraph', () => {
-  it('maps modules to compound containers with padding and membership', () => {
-    const graph = buildElkGraph(WORKFLOW_SPEC)
-    const prep = graph.children.find((child) => child.id === 'prep')
-    assert.ok(prep, 'prep container exists')
-    assert.match(prep.layoutOptions['elk.padding'], /top=56/)
-    assert.deepEqual(prep.children.map((child) => child.id).sort(), ['enrich_a', 'enrich_b', 'merge', 'validate'])
-    const topIds = graph.children.map((child) => child.id)
-    assert.ok(topIds.includes('start') && topIds.includes('transform'))
-    assert.ok(graph.children.every((child) => child.children?.length || (child.width > 0 && child.height > 0)))
-  })
-
-  it('drops empty modules and keeps orphan-module nodes at top level', () => {
-    const spec = {
-      meta: { layout: 'hierarchical' },
-      modules: [{ id: 'ghost', label: 'Ghost' }],
-      nodes: [{ id: 'a', label: 'A', module: 'missing' }],
-      edges: []
-    }
-    const graph = buildElkGraph(spec)
-    assert.deepEqual(
-      graph.children.map((child) => child.id),
-      ['a']
-    )
-  })
-
-  it('filters self-loops and dangling edges while keeping original indices', () => {
-    const spec = {
-      meta: { layout: 'hierarchical' },
-      nodes: [
-        { id: 'a', label: 'A' },
-        { id: 'b', label: 'B' }
-      ],
-      edges: [
-        { from: 'a', to: 'ghost' },
-        { from: 'a', to: 'a' },
-        { from: 'a', to: 'b' }
-      ]
-    }
-    const graph = buildElkGraph(spec)
-    assert.deepEqual(
-      graph.edges.map((edge) => edge.id),
-      ['e2']
-    )
-  })
-})
-
-describe('convertElkResult', () => {
-  it('resolves absolute bounds through nested containers and offsets waypoints by edge container', () => {
-    const spec = {
-      meta: { layout: 'hierarchical' },
-      modules: [{ id: 'mod', label: 'M' }],
-      nodes: [
-        { id: 'leaf', label: 'L', module: 'mod' },
-        { id: 'top', label: 'T' }
-      ],
-      edges: [{ from: 'leaf', to: 'top' }]
-    }
-    const result = {
-      id: 'root',
-      children: [
-        {
-          id: 'mod',
-          x: 10,
-          y: 20,
-          children: [{ id: 'leaf', x: 5, y: 6, width: 100, height: 40 }]
-        },
-        { id: 'top', x: 200, y: 30, width: 80, height: 40 }
-      ],
-      edges: [
-        {
-          id: 'e0',
-          container: 'mod',
-          sections: [
-            {
-              bendPoints: [
-                { x: 1, y: 2 },
-                { x: 1.4, y: 2.4 }
-              ]
-            }
-          ]
-        }
-      ]
-    }
-    const laid = convertElkResult(spec, result)
-    assert.deepEqual(laid.nodes[0].bounds, { x: 55, y: 66, width: 100, height: 40 })
-    assert.deepEqual(laid.nodes[1].bounds, { x: 240, y: 70, width: 80, height: 40 })
-    assert.deepEqual(laid.edges[0].waypoints, [{ x: 51, y: 62 }])
-  })
-})
-
-describe('applyAutoLayout', () => {
-  it('lays out a 12-node branching workflow without overlaps, flowing left to right', async () => {
-    const { spec: laid, applied, warning } = await applyAutoLayout(WORKFLOW_SPEC)
-    assert.equal(applied, true)
-    assert.equal(warning, undefined)
-    for (const node of laid.nodes) {
-      assert.ok(node.bounds, `node ${node.id} has bounds`)
-    }
-    for (let i = 0; i < laid.nodes.length; i++) {
-      for (let j = i + 1; j < laid.nodes.length; j++) {
-        assert.ok(
-          !rectsOverlap(laid.nodes[i].bounds, laid.nodes[j].bounds),
-          `${laid.nodes[i].id} overlaps ${laid.nodes[j].id}`
-        )
-      }
-    }
-    const boundsById = new Map(laid.nodes.map((node) => [node.id, node.bounds]))
-    for (const edge of laid.edges) {
-      const source = boundsById.get(edge.from)
-      const target = boundsById.get(edge.to)
-      assert.ok(
-        source.x + source.width / 2 < target.x + target.width / 2,
-        `edge ${edge.from}->${edge.to} flows left to right`
-      )
-    }
-    assert.ok(
-      laid.edges.some((edge) => edge.waypoints?.length),
-      'orthogonal routing produced at least one waypointed edge'
-    )
-  })
-
-  it('produces a spec that passes edge-quality validation and converts to XML', async () => {
-    const { spec: laid } = await applyAutoLayout(WORKFLOW_SPEC)
-    const theme = loadTheme('tech-blue')
-    const layout = calculateLayout(laid, theme)
-    assert.deepEqual(validateEdgeQuality(laid, layout), [])
-    assert.equal(computeLayoutQualityMetrics(laid).edgeNodeCrossings, 0)
-    const xml = specToDrawioXml(laid, { silent: true })
-    assert.ok(xml.includes('<mxGraphModel'))
-  })
-
-  it('passes through specs that fail the gate', async () => {
-    const explicit = {
-      meta: { layout: 'horizontal' },
-      nodes: [{ id: 'a', label: 'A' }],
-      edges: []
-    }
-    const result = await applyAutoLayout(explicit)
-    assert.equal(result.applied, false)
-    assert.equal(result.spec, explicit)
-    assert.equal(result.warning, undefined)
-  })
-
-  it('degrades with a warning when the engine is unavailable or fails', async () => {
-    const unavailable = await applyAutoLayout(WORKFLOW_SPEC, { elk: null })
-    assert.equal(unavailable.applied, false)
-    assert.match(unavailable.warning, /unavailable/)
-    assert.equal(unavailable.spec, WORKFLOW_SPEC)
-
-    const failing = await applyAutoLayout(WORKFLOW_SPEC, {
-      elk: {
-        layout: async () => {
-          throw new Error('boom')
-        }
-      }
-    })
-    assert.equal(failing.applied, false)
-    assert.match(failing.warning, /boom/)
-    assert.equal(failing.spec, WORKFLOW_SPEC)
-  })
-})

package/template/.agents/skills/drawio/scripts/dsl/catalog-ranking.js

@@ -1,54 +0,0 @@
-export function normalizeCatalogSearchValue(value) {
-  return String(value || '')
-    .normalize('NFKD')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ' ')
-    .trim()
-}
-
-export function levenshteinDistance(left, right) {
-  if (left === right) return 0
-  if (!left || !right) return Math.max(left.length, right.length)
-  let previous = Array.from({ length: right.length + 1 }, (_, index) => index)
-  for (let row = 1; row <= left.length; row++) {
-    const current = [row]
-    for (let column = 1; column <= right.length; column++) {
-      current[column] = Math.min(
-        current[column - 1] + 1,
-        previous[column] + 1,
-        previous[column - 1] + (left[row - 1] === right[column - 1] ? 0 : 1)
-      )
-    }
-    previous = current
-  }
-  return previous[right.length]
-}
-
-export function scoreCatalogCandidate(query, candidate) {
-  const target = normalizeCatalogSearchValue(query)
-  const name = normalizeCatalogSearchValue(candidate.name)
-  const title = normalizeCatalogSearchValue(candidate.title)
-  const tags = normalizeCatalogSearchValue(candidate.tags.join(' '))
-  if (!target) return 0
-  if (name === target) return 100
-  const lastSegment = normalizeCatalogSearchValue(String(candidate.name).split(/[.;=]/).pop())
-  if (lastSegment && lastSegment === target) return 90
-  if (name.includes(target)) return 60
-  if (title.includes(target)) return 35
-  if (tags.includes(target)) return 20
-  const tokens = target.split(' ')
-  if (tokens.every((token) => name.includes(token) || title.includes(token) || tags.includes(token))) return 25
-  const candidateTokens = `${name} ${title} ${tags}`.split(' ')
-  const matchingTokens = tokens.filter((token) => candidateTokens.includes(token))
-  if (matchingTokens.length >= 2 || matchingTokens.some((token) => token.length >= 4 || /\d/.test(token))) {
-    return 15 + matchingTokens.length
-  }
-  return tokens.some((token) =>
-    token.length >= 4 &&
-    candidateTokens.some(
-      (value) => value.length >= 3 && Math.abs(token.length - value.length) <= 1 && levenshteinDistance(token, value) <= 1
-    )
-  )
-    ? 10
-    : 0
-}

package/template/.agents/skills/drawio/scripts/dsl/catalog-search.js

@@ -1,58 +0,0 @@
-import { loadShapeCatalog } from './shape-catalog.js'
-import { ICON_ALIASES, resolveIconShape, specSyntaxFor } from './icon-mappings.js'
-import { scoreCatalogCandidate } from './catalog-ranking.js'
-import { searchAiIcons } from './ai-icon-catalog.js'
-
-function catalogCandidates(catalog) {
-  const entries = catalog.entries.map((entry) => ({
-    name: entry.n,
-    title: entry.t || '',
-    tags: entry.g || [],
-    spec: specSyntaxFor(entry.n)
-  }))
-  for (const family of catalog.families.values()) {
-    for (const value of family.values) {
-      entries.push({
-        name: `${family.base};${family.param}=${value.v}`,
-        title: value.t || '',
-        tags: value.g || [],
-        spec: family.k === 'k8sParamIcon' ? specSyntaxFor(family.base, family.param, value.v) : null
-      })
-    }
-  }
-  const synonyms = new Map()
-  for (const alias of Object.keys(ICON_ALIASES)) {
-    const resolved = resolveIconShape(alias)
-    if (!resolved) continue
-    const name = resolved.replace(/:(prIcon|resIcon|grIcon)=/, ';$1=')
-    if (!synonyms.has(name)) synonyms.set(name, [])
-    synonyms.get(name).push(alias.slice(alias.indexOf('.') + 1))
-  }
-  return [...new Map(entries.map((entry) => [entry.name, entry])).values()].map((entry) =>
-    synonyms.has(entry.name) ? { ...entry, tags: [...entry.tags, ...synonyms.get(entry.name)] } : entry
-  )
-}
-
-export function searchShapeCatalog(query, { prefix = null, limit = 8 } = {}) {
-  const plainPrefix = prefix ? prefix.replace(/^mxgraph\./, '').replace(/\.$/, '').toLowerCase() : null
-  if (plainPrefix === 'lobe' || plainPrefix === 'ai') {
-    return searchAiIcons(query, { limit })
-  }
-  const catalog = loadShapeCatalog()
-  if (!catalog) return []
-  const normalizedPrefix = prefix ? `mxgraph.${prefix.replace(/^mxgraph\./, '')}.` : null
-  return catalogCandidates(catalog)
-    .filter((candidate) => !normalizedPrefix || candidate.name.startsWith(normalizedPrefix))
-    .map((candidate) => ({ ...candidate, score: scoreCatalogCandidate(query, candidate) }))
-    .filter((candidate) => candidate.score > 0)
-    .sort((a, b) => b.score - a.score || (b.spec ? 1 : 0) - (a.spec ? 1 : 0) || a.name.localeCompare(b.name))
-    .slice(0, Math.max(1, limit))
-}
-
-export function searchShapeCatalogBatch(query, options) {
-  return String(query)
-    .split(',')
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => ({ query: part, results: searchShapeCatalog(part, options) }))
-}

package/template/.agents/skills/drawio/scripts/dsl/catalog-search.test.js

@@ -1,44 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { searchShapeCatalog, searchShapeCatalogBatch } from './catalog-search.js'
-
-test('catalog search finds k8s parameter values with skill syntax', () => {
-  const result = searchShapeCatalog('pod', { prefix: 'kubernetes' })
-  assert.ok(result.some((entry) => entry.spec === 'k8s.pod'))
-})
-
-test('catalog search supports comma-separated batches and no-result output', () => {
-  const groups = searchShapeCatalogBatch('s3, lambda, zzz_not_exist')
-  assert.equal(groups.length, 3)
-  assert.ok(groups[0].results.length > 0)
-  assert.ok(groups[1].results.length > 0)
-  assert.equal(groups[2].results.length, 0)
-})
-
-test('catalog search ranks exact last-segment matches first', () => {
-  const [first] = searchShapeCatalog('s3')
-  assert.equal(first.name, 'mxgraph.aws4.s3')
-  assert.equal(first.spec, 'aws.s3')
-})
-
-test('catalog search finds kubernetes entries through natural-word aliases', () => {
-  const results = searchShapeCatalog('deployment', { prefix: 'kubernetes' })
-  assert.ok(results.some((entry) => entry.spec === 'k8s.deploy'))
-})
-
-test('catalog search routes the lobe prefix to canonical offline AI icons', () => {
-  const [result] = searchShapeCatalog('openai', { prefix: 'lobe', limit: 1 })
-  assert.equal(result.name, 'lobe.openai')
-  assert.equal(result.spec, 'icon: lobe.openai')
-  assert.doesNotMatch(JSON.stringify(result), /https?:\/\//)
-})
-
-test('catalog search discovers SysML and BPMN stencils from merged variant metadata', () => {
-  const [requirement] = searchShapeCatalog('sysml requirement', { prefix: 'sysml', limit: 1 })
-  assert.equal(requirement.name, 'mxgraph.sysml.package')
-  assert.ok(requirement.tags.includes('requirement'))
-
-  const [task] = searchShapeCatalog('bpmn task', { prefix: 'bpmn', limit: 1 })
-  assert.equal(task.name, 'mxgraph.bpmn.task2')
-  assert.ok(task.tags.includes('task'))
-})