create-yss-spec 2.1.5 → 2.1.6

package/template/.hermes/skills/drawio/scripts/dsl/palette.js

@@ -1,302 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, relative, resolve, sep } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { contrastRatio, relativeLuminance } from './palette-validate.js'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const PALETTES_DIR = resolve(__dirname, '../../assets/palettes')
-const PALETTE_NAME = /^[a-z][a-z0-9-]*$/
-const ENTRY_NAME = /^[a-z][a-z0-9-]*$/
-const ROLE_NAME = /^[a-z][a-z0-9_-]*$/
-const HEX_COLOR = /^#[0-9A-F]{6}$/i
-const CATEGORIES = new Set(['academic', 'engineering', 'general'])
-const TOKEN_PATTERN = /^\$palette([1-9][0-9]*)(?:-(fill|stroke|text))?$/
-
-export const PALETTE_REQUIRED_FIELDS = [
-  'name',
-  'displayName',
-  'category',
-  'colorblindSafe',
-  'grayscaleSafe',
-  'maxCategories',
-  'source',
-  'venues',
-  'notes',
-  'entries'
-]
-
-const SEMANTIC_ROLE_ORDER = [
-  'service',
-  'database',
-  'decision',
-  'queue',
-  'user',
-  'document',
-  'terminal',
-  'formula',
-  'input',
-  'output',
-  'loss',
-  'feature',
-  'conv',
-  'pool',
-  'embed',
-  'temporal',
-  'attention',
-  'gate',
-  'norm',
-  'graph',
-  'matrix',
-  'operator',
-  'llm',
-  'agent',
-  'vector_store',
-  'memory',
-  'tool',
-  'gateway'
-]
-
-function assertString(value, context) {
-  if (typeof value !== 'string' || value.trim() === '') throw new Error(`${context} must be a non-empty string`)
-}
-
-function assertHex(value, context) {
-  if (typeof value !== 'string' || !HEX_COLOR.test(value)) {
-    throw new Error(`${context} must be a #RRGGBB color`)
-  }
-}
-
-export function validatePaletteDefinition(palette) {
-  if (typeof palette !== 'object' || palette == null || Array.isArray(palette)) {
-    throw new Error('palette must be an object')
-  }
-  for (const field of PALETTE_REQUIRED_FIELDS) {
-    if (!Object.hasOwn(palette, field)) throw new Error(`palette.${field} is required`)
-  }
-
-  assertString(palette.name, 'palette.name')
-  if (!PALETTE_NAME.test(palette.name)) throw new Error('palette.name must match /^[a-z][a-z0-9-]*$/')
-  assertString(palette.displayName, 'palette.displayName')
-  if (!CATEGORIES.has(palette.category)) {
-    throw new Error('palette.category must be one of academic, engineering, general')
-  }
-  for (const field of ['colorblindSafe', 'grayscaleSafe']) {
-    if (typeof palette[field] !== 'boolean') throw new Error(`palette.${field} must be a boolean`)
-  }
-  if (!Number.isInteger(palette.maxCategories) || palette.maxCategories < 1 || palette.maxCategories > 16) {
-    throw new Error('palette.maxCategories must be an integer between 1 and 16')
-  }
-  assertString(palette.source, 'palette.source')
-  if (!Array.isArray(palette.venues) || palette.venues.some((venue) => typeof venue !== 'string')) {
-    throw new Error('palette.venues must be an array of strings')
-  }
-  if (typeof palette.notes !== 'string') throw new Error('palette.notes must be a string')
-  if (!Array.isArray(palette.entries) || palette.entries.length < 1 || palette.entries.length > 16) {
-    throw new Error('palette.entries must contain between 1 and 16 entries')
-  }
-  if (palette.maxCategories > palette.entries.length) {
-    throw new Error('palette.maxCategories must not exceed palette.entries.length')
-  }
-
-  const entryNames = new Set()
-  palette.entries.forEach((entry, index) => {
-    const context = `palette.entries[${index}]`
-    if (typeof entry !== 'object' || entry == null || Array.isArray(entry)) {
-      throw new Error(`${context} must be an object`)
-    }
-    assertString(entry.name, `${context}.name`)
-    if (!ENTRY_NAME.test(entry.name)) throw new Error(`${context}.name must use lowercase kebab-case`)
-    if (entryNames.has(entry.name)) throw new Error(`${context}.name must be unique`)
-    entryNames.add(entry.name)
-    assertHex(entry.base, `${context}.base`)
-    for (const field of ['fill', 'stroke', 'text']) {
-      if (entry[field] != null) assertHex(entry[field], `${context}.${field}`)
-    }
-  })
-
-  if (palette.roles != null) {
-    if (typeof palette.roles !== 'object' || Array.isArray(palette.roles)) {
-      throw new Error('palette.roles must be an object when provided')
-    }
-    for (const [role, index] of Object.entries(palette.roles)) {
-      if (!ROLE_NAME.test(role)) throw new Error(`palette.roles.${role} must match a supported semantic type key`)
-      if (!Number.isInteger(index) || index < 0 || index >= palette.entries.length) {
-        throw new Error(`palette.roles.${role} must index an existing palette entry`)
-      }
-    }
-  }
-
-  if (palette.connector != null) {
-    if (typeof palette.connector !== 'object' || Array.isArray(palette.connector)) {
-      throw new Error('palette.connector must be an object when provided')
-    }
-    if (palette.connector.default != null) assertHex(palette.connector.default, 'palette.connector.default')
-  }
-
-  return palette
-}
-
-function normalizeHex(value) {
-  return value.toUpperCase()
-}
-
-function mix(color, target, amount) {
-  const source = [1, 3, 5].map((offset) => Number.parseInt(color.slice(offset, offset + 2), 16))
-  const destination = [1, 3, 5].map((offset) => Number.parseInt(target.slice(offset, offset + 2), 16))
-  const channels = source.map((channel, index) => Math.round(channel * (1 - amount) + destination[index] * amount))
-  return `#${channels.map((channel) => channel.toString(16).padStart(2, '0')).join('').toUpperCase()}`
-}
-
-function deriveStroke(base, canvasBackground) {
-  if (contrastRatio(base, canvasBackground) >= 3) return base
-  for (let amount = 0.05; amount <= 1; amount += 0.05) {
-    const candidate = mix(base, '#000000', amount)
-    if (contrastRatio(candidate, canvasBackground) >= 3) return candidate
-  }
-  return '#000000'
-}
-
-function materializePalette(palette, theme) {
-  const diagnostics = []
-  const canvasBackground = normalizeHex(theme?.canvas?.background || theme?.colors?.background || '#FFFFFF')
-  const themeText = normalizeHex(theme?.colors?.text || '#000000')
-  const entries = palette.entries.map((raw) => {
-    const base = normalizeHex(raw.base)
-    const fill = raw.fill
-      ? normalizeHex(raw.fill)
-      : relativeLuminance(base) < 0.25
-        ? base
-        : mix(base, '#FFFFFF', 0.85)
-    const derivedStroke = raw.stroke ? normalizeHex(raw.stroke) : deriveStroke(base, canvasBackground)
-    if (!raw.stroke && derivedStroke !== base) {
-      diagnostics.push({
-        level: 'info',
-        code: 'PALETTE_STROKE_DERIVED',
-        message: `Palette "${palette.name}" entry "${raw.name}" stroke was darkened to ${derivedStroke} for 3:1 canvas contrast.`
-      })
-    }
-    const text = raw.text ? normalizeHex(raw.text) : relativeLuminance(fill) < 0.25 ? '#FFFFFF' : themeText
-    return { name: raw.name, base, fill, stroke: derivedStroke, text }
-  })
-  return { palette: { ...palette, entries }, diagnostics }
-}
-
-function listPaletteNames(directory) {
-  if (!existsSync(directory)) return []
-  return readdirSync(directory, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-    .map((entry) => entry.name.slice(0, -5))
-    .filter((name) => PALETTE_NAME.test(name))
-}
-
-function resolvePaletteFile(directory, name) {
-  const root = resolve(directory)
-  const candidate = resolve(root, `${name}.json`)
-  const pathFromRoot = relative(root, candidate)
-  if (pathFromRoot.startsWith(`..${sep}`) || pathFromRoot === '..') throw new Error('Palette path escapes its directory')
-  return candidate
-}
-
-export function loadPalette(name, options = {}) {
-  if (name == null || name === '') return { palette: null, diagnostics: [] }
-
-  const userDir = options.userDir || resolve(homedir(), '.drawio-skill/palettes')
-  const available = [...new Set([...listPaletteNames(PALETTES_DIR), ...listPaletteNames(userDir)])].sort()
-  const availableMessage = `Available palettes: ${available.join(', ') || '(none)'}`
-  if (typeof name !== 'string' || !PALETTE_NAME.test(name)) {
-    throw new Error(`Invalid palette name "${name}". ${availableMessage}`)
-  }
-
-  const builtinPath = resolvePaletteFile(PALETTES_DIR, name)
-  const userPath = resolvePaletteFile(userDir, name)
-  const userOverride = existsSync(userPath)
-  const selectedPath = userOverride ? userPath : builtinPath
-  if (!existsSync(selectedPath)) throw new Error(`Unknown palette "${name}". ${availableMessage}`)
-
-  let parsed
-  try {
-    parsed = JSON.parse(readFileSync(selectedPath, 'utf8'))
-  } catch (error) {
-    throw new Error(`Could not parse palette "${name}": ${error.message}. ${availableMessage}`)
-  }
-
-  try {
-    validatePaletteDefinition(parsed)
-    if (parsed.name !== name) throw new Error(`palette.name must equal "${name}"`)
-  } catch (error) {
-    throw new Error(`Invalid palette "${name}": ${error.message}. ${availableMessage}`)
-  }
-
-  const materialized = materializePalette(parsed, options.theme)
-  if (userOverride) {
-    materialized.diagnostics.unshift({
-      level: 'info',
-      code: 'PALETTE_USER_OVERRIDE',
-      message: `User palette "${name}" overrides the bundled palette.`
-    })
-  }
-  return materialized
-}
-
-function entryIndexForType(palette, semanticType) {
-  const explicit = palette.roles?.[semanticType]
-  if (Number.isInteger(explicit)) return explicit
-  const position = SEMANTIC_ROLE_ORDER.indexOf(semanticType)
-  return (position < 0 ? 0 : position) % palette.entries.length
-}
-
-export function applyPalette(theme, palette, options = {}) {
-  if (!palette) return { theme, usage: [], diagnostics: [] }
-
-  const derived = structuredClone(theme)
-  derived.palette = palette
-  derived.node ||= {}
-  derived.connector ||= {}
-  const usageByIndex = new Map()
-
-  for (const semanticType of new Set(options.semanticTypes || [])) {
-    const index = entryIndexForType(palette, semanticType)
-    const entry = palette.entries[index]
-    derived.node[semanticType] = {
-      ...(derived.node[semanticType] || derived.node.default || {}),
-      fillColor: entry.fill,
-      strokeColor: entry.stroke,
-      fontColor: entry.text
-    }
-    usageByIndex.set(index, { index, ...entry })
-  }
-
-  for (const index of options.tokenIndexes || []) {
-    if (index >= 0 && index < palette.entries.length) usageByIndex.set(index, { index, ...palette.entries[index] })
-  }
-
-  if (palette.connector?.default) {
-    derived.connector.primary = {
-      ...(derived.connector.primary || {}),
-      strokeColor: palette.connector.default
-    }
-  }
-
-  return {
-    theme: derived,
-    usage: [...usageByIndex.values()].sort((first, second) => first.index - second.index),
-    diagnostics: []
-  }
-}
-
-export function resolvePaletteToken(value, palette, fallback) {
-  if (typeof value !== 'string') return null
-  const match = TOKEN_PATTERN.exec(value)
-  if (!match) return null
-  const entry = palette?.entries?.[Number(match[1]) - 1]
-  if (!entry) return fallback
-  return entry[match[2] || 'base']
-}
-
-export function paletteTokenIndex(value) {
-  if (typeof value !== 'string') return null
-  const match = TOKEN_PATTERN.exec(value)
-  return match ? Number(match[1]) - 1 : null
-}

package/template/.hermes/skills/drawio/scripts/dsl/palette.test.js

@@ -1,197 +0,0 @@
-import { afterEach, describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import {
-  PALETTE_REQUIRED_FIELDS,
-  applyPalette,
-  loadPalette,
-  validatePaletteDefinition
-} from './palette.js'
-import { contrastRatio, relativeLuminance, validatePaletteUsage } from './palette-validate.js'
-import { loadTheme } from './spec-to-drawio.js'
-
-const tempDirs = []
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true })
-})
-
-function makeTempPaletteDir() {
-  const dir = mkdtempSync(join(tmpdir(), 'drawio-palette-'))
-  tempDirs.push(dir)
-  return dir
-}
-
-describe('palette definition and loader', () => {
-  it('loads and validates the three representative built-in palettes', () => {
-    const theme = loadTheme('academic')
-    const okabe = loadPalette('okabe-ito', { theme }).palette
-    const ieee = loadPalette('ieee-bw', { theme }).palette
-    const classic = loadPalette('drawio-classic', { theme }).palette
-
-    assert.equal(okabe.entries.length, 8)
-    assert.deepEqual(
-      okabe.entries.map((entry) => entry.base),
-      ['#E69F00', '#56B4E9', '#009E73', '#F0E442', '#0072B2', '#D55E00', '#CC79A7', '#000000']
-    )
-    assert.ok(ieee.entries.length >= 4)
-    assert.equal(classic.entries.length, 8)
-    assert.deepEqual(classic.entries[0], {
-      name: 'blue',
-      base: '#6C8EBF',
-      fill: '#DAE8FC',
-      stroke: '#6C8EBF',
-      text: '#000000'
-    })
-  })
-
-  it('keeps the documented schema required list aligned with runtime validation', () => {
-    const schema = JSON.parse(readFileSync(new URL('../../references/palette.schema.json', import.meta.url), 'utf8'))
-    assert.deepEqual(schema.required, PALETTE_REQUIRED_FIELDS)
-
-    const valid = {
-      name: 'test-palette',
-      displayName: 'Test Palette',
-      category: 'general',
-      colorblindSafe: true,
-      grayscaleSafe: true,
-      maxCategories: 1,
-      source: 'https://example.com/palette',
-      venues: [],
-      notes: 'Test palette',
-      entries: [{ name: 'test', base: '#123456' }]
-    }
-    for (const field of PALETTE_REQUIRED_FIELDS) {
-      const candidate = { ...valid }
-      delete candidate[field]
-      assert.throws(() => validatePaletteDefinition(candidate), new RegExp(`palette\\.${field}`))
-    }
-
-    assert.doesNotThrow(() =>
-      validatePaletteDefinition({ ...valid, roles: { vector_store: 0 } })
-    )
-  })
-
-  it('materializes complete entry colors without mutating the source theme', () => {
-    const theme = loadTheme('academic')
-    const { palette, diagnostics } = loadPalette('okabe-ito', { theme })
-
-    assert.ok(palette.entries.every((entry) => entry.base && entry.fill && entry.stroke && entry.text))
-    assert.equal(palette.entries.at(-1).fill, '#000000')
-    assert.equal(palette.entries.at(-1).text, '#FFFFFF')
-    assert.equal(theme.node.service.fillColor, '#FFFFFF')
-    assert.ok(diagnostics.every((diagnostic) => diagnostic.level === 'info'))
-  })
-
-  it('uses a valid user palette override and reports it as info', () => {
-    const userDir = makeTempPaletteDir()
-    const custom = {
-      name: 'okabe-ito',
-      displayName: 'Local Okabe',
-      category: 'academic',
-      colorblindSafe: true,
-      grayscaleSafe: true,
-      maxCategories: 1,
-      source: 'https://example.com/local',
-      venues: ['local'],
-      notes: 'Local test override',
-      entries: [{ name: 'local', base: '#123456' }]
-    }
-    writeFileSync(join(userDir, 'okabe-ito.json'), JSON.stringify(custom))
-
-    const { palette, diagnostics } = loadPalette('okabe-ito', { theme: loadTheme(), userDir })
-    assert.equal(palette.entries[0].base, '#123456')
-    assert.ok(diagnostics.some((diagnostic) => diagnostic.code === 'PALETTE_USER_OVERRIDE'))
-  })
-
-  it('throws actionable hard errors for unknown, malformed, and invalid palettes', () => {
-    const theme = loadTheme()
-    assert.throws(() => loadPalette('missing', { theme, userDir: makeTempPaletteDir() }), /Available palettes:.*okabe-ito/)
-
-    const malformedDir = makeTempPaletteDir()
-    writeFileSync(join(malformedDir, 'broken.json'), '{')
-    assert.throws(() => loadPalette('broken', { theme, userDir: malformedDir }), /Could not parse palette "broken".*Available palettes:/)
-
-    const invalidDir = makeTempPaletteDir()
-    writeFileSync(
-      join(invalidDir, 'invalid.json'),
-      JSON.stringify({
-        name: 'invalid',
-        displayName: 'Invalid',
-        category: 'general',
-        colorblindSafe: false,
-        grayscaleSafe: false,
-        maxCategories: 1,
-        source: 'https://example.com/invalid',
-        venues: [],
-        notes: 'Invalid role',
-        entries: [{ name: 'only', base: '#000000' }],
-        roles: { service: 1 }
-      })
-    )
-    assert.throws(() => loadPalette('invalid', { theme, userDir: invalidDir }), /roles\.service.*Available palettes:/)
-  })
-})
-
-describe('applyPalette', () => {
-  it('is an identity operation when no palette is selected', () => {
-    const theme = loadTheme('academic')
-    const result = applyPalette(theme, null)
-    assert.strictEqual(result.theme, theme)
-    assert.deepEqual(result.usage, [])
-    assert.deepEqual(result.diagnostics, [])
-  })
-
-  it('overrides semantic colors while preserving typography and connector geometry', () => {
-    const theme = loadTheme('academic')
-    const palette = loadPalette('okabe-ito', { theme }).palette
-    const result = applyPalette(theme, palette, { semanticTypes: ['service', 'database', 'service'] })
-
-    assert.notStrictEqual(result.theme, theme)
-    assert.deepEqual(result.theme.typography, theme.typography)
-    assert.equal(result.theme.connector.primary.strokeWidth, theme.connector.primary.strokeWidth)
-    assert.equal(result.theme.node.service.strokeColor, palette.entries[0].stroke)
-    assert.equal(result.theme.node.database.strokeColor, palette.entries[1].stroke)
-    assert.deepEqual(
-      result.usage.map((item) => item.index),
-      [0, 1]
-    )
-  })
-})
-
-describe('palette validation gate', () => {
-  it('implements WCAG luminance and contrast calculations', () => {
-    assert.equal(relativeLuminance('#000000'), 0)
-    assert.equal(relativeLuminance('#FFFFFF'), 1)
-    assert.equal(contrastRatio('#000000', '#FFFFFF'), 21)
-  })
-
-  it('emits structured usage diagnostics with strict print escalation', () => {
-    const palette = {
-      name: 'unsafe',
-      displayName: 'Unsafe',
-      colorblindSafe: false,
-      grayscaleSafe: false,
-      maxCategories: 1
-    }
-    const usage = [
-      { index: 0, name: 'a', fill: '#777777', stroke: '#888888' },
-      { index: 1, name: 'b', fill: '#888888', stroke: '#EEEEEE' }
-    ]
-    const diagnostics = validatePaletteUsage(palette, usage, {
-      canvasBackground: '#FFFFFF',
-      profile: 'academic-paper',
-      printTarget: 'ieee-single',
-      strict: true
-    })
-
-    assert.ok(diagnostics.some((item) => item.code === 'PALETTE_GRAYSCALE_PAIR'))
-    assert.ok(diagnostics.some((item) => item.code === 'PALETTE_BOUNDARY_CONTRAST'))
-    assert.ok(diagnostics.some((item) => item.code === 'PALETTE_MAX_CATEGORIES'))
-    assert.equal(diagnostics.find((item) => item.code === 'PALETTE_PRINT_GATE').level, 'error')
-    assert.equal(diagnostics.find((item) => item.code === 'PALETTE_CVD_NOTICE').level, 'info')
-  })
-})

package/template/.hermes/skills/drawio/scripts/dsl/shape-catalog.js

@@ -1,89 +0,0 @@
-/**
- * shape-catalog.js
- * Lazy-loaded catalog of shape names this repository is allowed to emit.
- *
- * Data file: ../../assets/catalog/shape-catalog.json.gz, filtered from the
- * draw.io default shape libraries (see the _source note inside the file).
- * Used to emit aws4 resource icons with the correct compound style and by
- * validateSpec to warn on unknown `shape=` names before they reach draw.io
- * Desktop, where a typo renders as an empty box.
- */
-
-import { readFileSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { gunzipSync } from 'node:zlib'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const CATALOG_PATH = resolve(__dirname, '../../assets/catalog/shape-catalog.json.gz')
-
-// mxgraph library prefixes this repository can emit; names under other
-// prefixes are never produced here and stay unchecked to avoid false alarms.
-export const COVERED_PREFIXES = [
-  'mxgraph.aws4.',
-  'mxgraph.gcp2.',
-  'mxgraph.azure.',
-  'mxgraph.mscae.',
-  'mxgraph.kubernetes.',
-  'mxgraph.cisco.',
-  'mxgraph.cisco19.',
-  'mxgraph.networks.',
-  'mxgraph.sysml.',
-  'mxgraph.bpmn.'
-]
-
-let _catalog = null
-
-/**
- * Load and cache the shape catalog. Returns null when the data file is
- * missing or unreadable so callers can degrade to "no validation".
- * @returns {{ builtin: Set<string>, entries: Object[], stencils: Set<string>, aws4ResourceIcons: Set<string>, families: Map<string, Object> }|null}
- */
-export function loadShapeCatalog() {
-  if (_catalog !== null) return _catalog
-  try {
-    const raw = JSON.parse(gunzipSync(readFileSync(CATALOG_PATH)).toString('utf-8'))
-    const entries = raw.entries || []
-    _catalog = {
-      builtin: new Set(raw.builtin || []),
-      entries,
-      stencils: new Set(raw.stencils || entries.filter((entry) => entry.k === 'stencil').map((entry) => entry.n)),
-      aws4ResourceIcons: new Set(raw.aws4ResourceIcons || entries.filter((entry) => entry.k === 'aws4ResourceIcon').map((entry) => entry.n)),
-      families: new Map((raw.families || []).map((family) => [`${family.base}:${family.param}`, family]))
-    }
-  } catch {
-    _catalog = false
-  }
-  return _catalog || null
-}
-
-/**
- * Classify a resolved `shape=` candidate name against the catalog.
- * @param {string} name
- * @returns {'stencil'|'builtin'|'aws4ResourceIcon'|'k8sParamIcon'|'cisco19ParamIcon'|'aws4ProductIcon'|'aws4GroupIcon'|'uncovered'|'unknown'|'unchecked'}
- *   - stencil: plain stencil shape, emit as shape=<name>
- *   - builtin: draw.io builtin shape name
- *   - aws4ResourceIcon: only exists as a resource icon, emit as
- *     shape=mxgraph.aws4.resourceIcon;resIcon=<name>
- *   - uncovered: mxgraph library outside the emitted prefixes (not checked)
- *   - unknown: under a covered namespace but absent from the catalog
- *   - unchecked: catalog data unavailable
- */
-export function resolveShapeNameKind(name) {
-  if (!name) return 'unknown'
-  const catalog = loadShapeCatalog()
-  if (!catalog) return 'unchecked'
-  const parameterized = /^(.*):(prIcon|resIcon|grIcon)=([^;]+)$/.exec(name)
-  if (parameterized) {
-    const [, base, param, value] = parameterized
-    const family = catalog.families.get(`${base}:${param}`)
-    return family?.values.some((entry) => entry.v === value) ? family.k : 'unknown'
-  }
-  if (name.startsWith('mxgraph.')) {
-    if (catalog.stencils.has(name)) return 'stencil'
-    if (name.startsWith('mxgraph.aws4.') && catalog.aws4ResourceIcons.has(name)) return 'aws4ResourceIcon'
-    return COVERED_PREFIXES.some((prefix) => name.startsWith(prefix)) ? 'unknown' : 'uncovered'
-  }
-  return catalog.builtin.has(name) ? 'builtin' : 'unknown'
-}

package/template/.hermes/skills/drawio/scripts/dsl/shape-catalog.test.js

@@ -1,21 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { loadShapeCatalog, resolveShapeNameKind } from './shape-catalog.js'
-
-test('v2 catalog loads parameterized families and mscae entries', () => {
-  const catalog = loadShapeCatalog()
-  assert.equal(catalog.families.get('mxgraph.kubernetes.icon2:prIcon').values.length, 39)
-  assert.equal(catalog.entries.filter((entry) => entry.n.startsWith('mxgraph.mscae.')).length, 148)
-  assert.equal(resolveShapeNameKind('mxgraph.kubernetes.icon2:prIcon=pod'), 'k8sParamIcon')
-  assert.equal(resolveShapeNameKind('mxgraph.kubernetes.icon2:prIcon=podd'), 'unknown')
-})
-
-test('catalog covers the vendored SysML and BPMN stencil namespaces', () => {
-  const catalog = loadShapeCatalog()
-  assert.equal(catalog.entries.filter((entry) => entry.n.startsWith('mxgraph.sysml.')).length, 19)
-  assert.equal(catalog.entries.filter((entry) => entry.n.startsWith('mxgraph.bpmn.')).length, 6)
-  assert.equal(resolveShapeNameKind('mxgraph.sysml.port'), 'stencil')
-  assert.equal(resolveShapeNameKind('mxgraph.bpmn.task2'), 'stencil')
-  assert.equal(resolveShapeNameKind('mxgraph.sysml.not_real'), 'unknown')
-  assert.equal(resolveShapeNameKind('mxgraph.bpmn.not_real'), 'unknown')
-})