create-yss-spec 2.1.4 → 2.1.6

package/template/.claude/skills/drawio/scripts/adapters/raster-extraction.js

@@ -1,258 +0,0 @@
-import { createRequire } from 'node:module'
-
-import { adapterError, isRecord, parseJsonDocument } from './config-common.js'
-import { ERROR_CODES } from './identity.js'
-
-const require = createRequire(import.meta.url)
-const specSchema = require('../../assets/schemas/spec.schema.json')
-
-const ADAPTER = 'raster-extraction'
-const MAX_NODES = 100
-const MAX_EDGES = 200
-const MAX_CANVAS_DIMENSION = 100000
-const MAX_FONT_SIZE = 512
-const SAFE_ID = /^[A-Za-z][A-Za-z0-9_-]*$/
-const SAFE_COLOR = /^(?:#[0-9A-Fa-f]{3}|#[0-9A-Fa-f]{6}|none)$/
-const CONTROL_CHARACTERS = /[\u0000-\u001F\u007F]/
-const HTML_TAG = /<\/?[A-Za-z][^>]*>/
-const CANONICAL_TYPES = new Set(specSchema.properties.nodes.items.properties.type.enum)
-const TOP_LEVEL_KEYS = new Set(['schemaVersion', 'canvas', 'nodes', 'edges'])
-const CANVAS_KEYS = new Set(['width', 'height', 'background'])
-const NODE_KEYS = new Set([
-  'id',
-  'label',
-  'type',
-  'shape',
-  'x',
-  'y',
-  'w',
-  'h',
-  'fill',
-  'stroke',
-  'fontSize',
-  'fontColor'
-])
-const EDGE_KEYS = new Set([
-  'id',
-  'source',
-  'target',
-  'label',
-  'dashed',
-  'arrow',
-  'stroke',
-  'waypoints',
-  'labelOffset'
-])
-const POINT_KEYS = new Set(['x', 'y'])
-const GEOMETRY_KEYS = ['x', 'y', 'w', 'h']
-const SHAPE_TYPES = new Map([
-  ['rect', 'service'],
-  ['rectangle', 'service'],
-  ['rounded', 'service'],
-  ['hexagon', 'service'],
-  ['ellipse', 'terminal'],
-  ['oval', 'terminal'],
-  ['diamond', 'decision'],
-  ['rhombus', 'decision'],
-  ['cylinder', 'database'],
-  ['parallelogram', 'queue'],
-  ['cloud', 'cloud'],
-  ['document', 'document'],
-  ['text', 'text'],
-  ['formula', 'formula']
-])
-
-function fail(message, path) {
-  adapterError(ERROR_CODES.ADAPTER_PARSE, message, { adapter: ADAPTER, path })
-}
-
-function assertRecord(value, path) {
-  if (!isRecord(value)) fail('must be an object', path)
-  return value
-}
-
-function assertAllowedKeys(value, allowed, path) {
-  for (const key of Object.keys(value)) {
-    if (!allowed.has(key)) fail(`contains unknown field "${key}"`, `${path}.${key}`)
-  }
-}
-
-function requireSafeId(value, path) {
-  if (typeof value !== 'string' || !SAFE_ID.test(value)) fail('must be a safe canonical ID', path)
-  return value
-}
-
-function requireLabel(value, path) {
-  if (typeof value !== 'string' || value.trim() === '' || value.length > 200) {
-    fail('must be a non-empty string of at most 200 characters', path)
-  }
-  if (CONTROL_CHARACTERS.test(value)) fail('must not contain control characters', path)
-  if (HTML_TAG.test(value)) fail('must not contain raw HTML tags', path)
-  return value
-}
-
-function requireFiniteNumber(value, path, { positive = false, integer = false, maxAbs = null } = {}) {
-  if (
-    !Number.isFinite(value) ||
-    (positive && value <= 0) ||
-    (integer && !Number.isInteger(value)) ||
-    (maxAbs != null && Math.abs(value) > maxAbs)
-  ) {
-    fail(`must be a finite${integer ? ' integer' : ' number'}${positive ? ' greater than 0' : ''}`, path)
-  }
-  return value
-}
-
-function requireColor(value, path, { allowNone = true } = {}) {
-  if (typeof value !== 'string' || !SAFE_COLOR.test(value) || (!allowNone && value === 'none')) {
-    fail(`must be ${allowNone ? '#RGB, #RRGGBB, or none' : '#RGB or #RRGGBB'}`, path)
-  }
-  return value
-}
-
-function resolveNodeType(node, path) {
-  if (node.type != null) {
-    if (typeof node.type !== 'string' || !CANONICAL_TYPES.has(node.type)) {
-      fail('must be a supported canonical node type', `${path}.type`)
-    }
-    return node.type
-  }
-  if (typeof node.shape !== 'string' || !SHAPE_TYPES.has(node.shape)) {
-    fail('requires a supported shape when type is omitted', `${path}.shape`)
-  }
-  return SHAPE_TYPES.get(node.shape)
-}
-
-function parseCanvas(value) {
-  if (value == null) return null
-  const canvas = assertRecord(value, 'canvas')
-  assertAllowedKeys(canvas, CANVAS_KEYS, 'canvas')
-  const width = requireFiniteNumber(canvas.width, 'canvas.width', { positive: true, integer: true })
-  const height = requireFiniteNumber(canvas.height, 'canvas.height', { positive: true, integer: true })
-  if (width > MAX_CANVAS_DIMENSION) fail(`must not exceed ${MAX_CANVAS_DIMENSION}`, 'canvas.width')
-  if (height > MAX_CANVAS_DIMENSION) fail(`must not exceed ${MAX_CANVAS_DIMENSION}`, 'canvas.height')
-  const background = canvas.background == null ? undefined : requireColor(canvas.background, 'canvas.background', { allowNone: false })
-  return { width, height, background }
-}
-
-function geometryMode(nodes) {
-  let hasMissingGeometry = false
-  nodes.forEach((node, index) => {
-    const count = GEOMETRY_KEYS.filter((key) => Object.hasOwn(node, key)).length
-    if (count === 0) hasMissingGeometry = true
-    else if (count !== GEOMETRY_KEYS.length) fail('must provide all of x, y, w, and h or none of them', `nodes[${index}]`)
-  })
-  return hasMissingGeometry ? 'layout' : 'bounds'
-}
-
-function parseNode(nodeValue, index, useBounds) {
-  const path = `nodes[${index}]`
-  const node = assertRecord(nodeValue, path)
-  assertAllowedKeys(node, NODE_KEYS, path)
-  const id = requireSafeId(node.id, `${path}.id`)
-  const label = requireLabel(node.label, `${path}.label`)
-  const type = resolveNodeType(node, path)
-  const result = { id, label, type }
-
-  if (useBounds) {
-    result.bounds = {
-      x: requireFiniteNumber(node.x, `${path}.x`, { maxAbs: MAX_CANVAS_DIMENSION }),
-      y: requireFiniteNumber(node.y, `${path}.y`, { maxAbs: MAX_CANVAS_DIMENSION }),
-      width: requireFiniteNumber(node.w, `${path}.w`, { positive: true, maxAbs: MAX_CANVAS_DIMENSION }),
-      height: requireFiniteNumber(node.h, `${path}.h`, { positive: true, maxAbs: MAX_CANVAS_DIMENSION })
-    }
-  }
-
-  const style = {}
-  if (node.fill != null) style.fillColor = requireColor(node.fill, `${path}.fill`)
-  if (node.stroke != null) style.strokeColor = requireColor(node.stroke, `${path}.stroke`)
-  if (node.fontSize != null) {
-    style.fontSize = requireFiniteNumber(node.fontSize, `${path}.fontSize`, { positive: true, maxAbs: MAX_FONT_SIZE })
-  }
-  if (node.fontColor != null) style.fontColor = requireColor(node.fontColor, `${path}.fontColor`, { allowNone: false })
-  if (type === 'text') {
-    if (style.fillColor != null && style.fillColor !== 'none') fail('plain text fill must be none', `${path}.fill`)
-    if (style.strokeColor != null && style.strokeColor !== 'none') fail('plain text stroke must be none', `${path}.stroke`)
-    style.fillColor = 'none'
-    style.strokeColor = 'none'
-  }
-  if (Object.keys(style).length > 0) result.style = style
-  return result
-}
-
-function parsePoint(value, path) {
-  const point = assertRecord(value, path)
-  assertAllowedKeys(point, POINT_KEYS, path)
-  return {
-    x: requireFiniteNumber(point.x, `${path}.x`, { maxAbs: MAX_CANVAS_DIMENSION }),
-    y: requireFiniteNumber(point.y, `${path}.y`, { maxAbs: MAX_CANVAS_DIMENSION })
-  }
-}
-
-function parseEdge(edgeValue, index, nodeIds) {
-  const path = `edges[${index}]`
-  const edge = assertRecord(edgeValue, path)
-  assertAllowedKeys(edge, EDGE_KEYS, path)
-  const id = requireSafeId(edge.id, `${path}.id`)
-  const from = requireSafeId(edge.source, `${path}.source`)
-  const to = requireSafeId(edge.target, `${path}.target`)
-  if (!nodeIds.has(from)) fail('must reference an existing node', `${path}.source`)
-  if (!nodeIds.has(to)) fail('must reference an existing node', `${path}.target`)
-  const result = { id, from, to }
-  if (edge.label != null) result.label = requireLabel(edge.label, `${path}.label`)
-
-  const style = {}
-  if (edge.dashed != null) {
-    if (typeof edge.dashed !== 'boolean') fail('must be a boolean', `${path}.dashed`)
-    style.dashed = edge.dashed
-  }
-  if (edge.arrow != null) {
-    if (typeof edge.arrow !== 'boolean') fail('must be a boolean', `${path}.arrow`)
-    if (!edge.arrow) style.endArrow = 'none'
-  }
-  if (edge.stroke != null) style.strokeColor = requireColor(edge.stroke, `${path}.stroke`, { allowNone: false })
-  if (Object.keys(style).length > 0) result.style = style
-  if (edge.waypoints != null) {
-    if (!Array.isArray(edge.waypoints)) fail('must be an array', `${path}.waypoints`)
-    result.waypoints = edge.waypoints.map((point, pointIndex) => parsePoint(point, `${path}.waypoints[${pointIndex}]`))
-  }
-  if (edge.labelOffset != null) result.labelOffset = parsePoint(edge.labelOffset, `${path}.labelOffset`)
-  return result
-}
-
-export function parseRasterExtraction(source) {
-  const document = assertRecord(parseJsonDocument(source, { adapter: ADAPTER }), ADAPTER)
-  assertAllowedKeys(document, TOP_LEVEL_KEYS, ADAPTER)
-  if (document.schemaVersion !== 1) {
-    adapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'raster extraction schemaVersion must be 1', {
-      adapter: ADAPTER,
-      path: 'schemaVersion'
-    })
-  }
-  if (!Array.isArray(document.nodes) || document.nodes.length === 0) fail('must be a non-empty array', 'nodes')
-  if (document.nodes.length > MAX_NODES) fail(`must contain at most ${MAX_NODES} entries`, 'nodes')
-  if (!Array.isArray(document.edges)) fail('must be an array', 'edges')
-  if (document.edges.length > MAX_EDGES) fail(`must contain at most ${MAX_EDGES} entries`, 'edges')
-
-  const canvas = parseCanvas(document.canvas)
-  const useBounds = geometryMode(document.nodes) === 'bounds'
-  const nodes = document.nodes.map((node, index) => parseNode(node, index, useBounds))
-  const nodeIds = new Set()
-  for (const [index, node] of nodes.entries()) {
-    if (nodeIds.has(node.id)) fail(`duplicates node id "${node.id}"`, `nodes[${index}].id`)
-    nodeIds.add(node.id)
-  }
-  const edges = document.edges.map((edge, index) => parseEdge(edge, index, nodeIds))
-  const edgeIds = new Set()
-  for (const [index, edge] of edges.entries()) {
-    if (edgeIds.has(edge.id)) fail(`duplicates edge id "${edge.id}"`, `edges[${index}].id`)
-    edgeIds.add(edge.id)
-  }
-
-  const replication = { colorMode: 'preserve-original' }
-  if (canvas?.background != null) replication.background = canvas.background
-  const meta = { source: 'replicated', layout: 'hierarchical' }
-  if (canvas) meta.canvas = `${canvas.width}x${canvas.height}`
-  meta.replication = replication
-  return { meta, nodes, edges, modules: [] }
-}

package/template/.claude/skills/drawio/scripts/adapters/raster-extraction.test.js

@@ -1,308 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { applyAutoLayout } from '../dsl/auto-layout.js'
-import { specToDrawioXml, validateSpec, validateXml } from '../dsl/spec-to-drawio.js'
-import { parseRasterExtraction } from './raster-extraction.js'
-
-test('raster extraction maps explicit geometry and styles to one canonical spec', () => {
-  const source = JSON.stringify({
-    schemaVersion: 1,
-    canvas: { width: 1200, height: 800, background: '#FFFFFF' },
-    nodes: [
-      {
-        id: 'api',
-        label: 'API Gateway',
-        shape: 'rounded',
-        x: 120,
-        y: 80,
-        w: 180,
-        h: 64,
-        fill: '#DAE8FC',
-        stroke: '#6C8EBF',
-        fontSize: 18,
-        fontColor: '#1F2937'
-      },
-      { id: 'db', label: 'Orders', shape: 'cylinder', x: 420, y: 80, w: 140, h: 80 }
-    ],
-    edges: [
-      {
-        id: 'api-db',
-        source: 'api',
-        target: 'db',
-        label: 'SQL',
-        dashed: true,
-        arrow: false,
-        stroke: '#334155',
-        waypoints: [{ x: 340, y: 112 }],
-        labelOffset: { x: 0, y: -16 }
-      }
-    ]
-  })
-
-  assert.deepEqual(parseRasterExtraction(source), {
-    meta: {
-      source: 'replicated',
-      layout: 'hierarchical',
-      canvas: '1200x800',
-      replication: { colorMode: 'preserve-original', background: '#FFFFFF' }
-    },
-    nodes: [
-      {
-        id: 'api',
-        label: 'API Gateway',
-        type: 'service',
-        bounds: { x: 120, y: 80, width: 180, height: 64 },
-        style: {
-          fillColor: '#DAE8FC',
-          strokeColor: '#6C8EBF',
-          fontSize: 18,
-          fontColor: '#1F2937'
-        }
-      },
-      {
-        id: 'db',
-        label: 'Orders',
-        type: 'database',
-        bounds: { x: 420, y: 80, width: 140, height: 80 }
-      }
-    ],
-    edges: [
-      {
-        id: 'api-db',
-        from: 'api',
-        to: 'db',
-        label: 'SQL',
-        style: { dashed: true, endArrow: 'none', strokeColor: '#334155' },
-        waypoints: [{ x: 340, y: 112 }],
-        labelOffset: { x: 0, y: -16 }
-      }
-    ],
-    modules: []
-  })
-})
-
-test('raster extraction rejects control characters with adapter path evidence', () => {
-  const source = '{"schemaVersion":1,"nodes":[{"id":"node","label":"bad\\u0000label","shape":"rect"}],"edges":[]}'
-
-  assert.throws(
-    () => parseRasterExtraction(source),
-    (error) =>
-      error.code === 'ADAPTER_PARSE' &&
-      error.adapter === 'raster-extraction' &&
-      error.path === 'nodes[0].label' &&
-      /control characters/.test(error.message)
-  )
-})
-
-test('raster extraction rejects raw HTML labels at the adapter boundary', () => {
-  const source = JSON.stringify({
-    schemaVersion: 1,
-    nodes: [{ id: 'node', label: '<script>alert(1)</script>', shape: 'rect' }],
-    edges: []
-  })
-
-  assert.throws(
-    () => parseRasterExtraction(source),
-    (error) =>
-      error.code === 'ADAPTER_PARSE' &&
-      error.path === 'nodes[0].label' &&
-      /HTML/.test(error.message)
-  )
-})
-
-test('raster extraction drops all source bounds when any node has no geometry', async () => {
-  const source = JSON.stringify({
-    schemaVersion: 1,
-    nodes: [
-      { id: 'placed', label: 'Placed', shape: 'rect', x: 10, y: 20, w: 120, h: 60 },
-      { id: 'unplaced', label: 'Unplaced', shape: 'rect' }
-    ],
-    edges: [{ id: 'edge', source: 'placed', target: 'unplaced' }]
-  })
-
-  const spec = parseRasterExtraction(source)
-  assert.ok(spec.nodes.every((node) => node.bounds == null))
-  const layout = await applyAutoLayout(spec)
-  assert.equal(layout.applied, true)
-  assert.ok(layout.spec.nodes.every((node) => node.bounds != null))
-})
-
-test('raster extraction fixture uses the canonical ELK and renderer pipeline deterministically', async () => {
-  const source = readFileSync(new URL('./fixtures/raster-extraction.json', import.meta.url), 'utf8')
-  const render = async () => {
-    const spec = parseRasterExtraction(source)
-    validateSpec(spec)
-    assert.ok(spec.nodes.every((node) => node.bounds == null))
-    const layout = await applyAutoLayout(spec)
-    assert.equal(layout.applied, true)
-    assert.ok(layout.spec.nodes.every((node) => node.bounds != null))
-    const xml = specToDrawioXml(layout.spec)
-    assert.deepEqual(validateXml(xml), { valid: true, errors: [], warnings: [] })
-    assert.doesNotMatch(xml, /Source & ingress/)
-    assert.match(xml, /Source &amp; ingress/)
-    return xml
-  }
-
-  assert.equal(await render(), await render())
-})
-
-test('raster extraction rejects malformed, ambiguous, or unsafe records', () => {
-  const valid = {
-    schemaVersion: 1,
-    nodes: [{ id: 'node', label: 'Node', shape: 'rect' }],
-    edges: []
-  }
-  const cases = [
-    {
-      name: 'unsupported version',
-      value: { ...valid, schemaVersion: 2 },
-      code: 'ADAPTER_UNSUPPORTED',
-      path: 'schemaVersion'
-    },
-    {
-      name: 'unknown root field',
-      value: { ...valid, image: 'data:image/png;base64,AAAA' },
-      code: 'ADAPTER_PARSE',
-      path: 'raster-extraction.image'
-    },
-    {
-      name: 'partial geometry',
-      value: { ...valid, nodes: [{ ...valid.nodes[0], x: 1 }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0]'
-    },
-    {
-      name: 'oversize geometry',
-      value: {
-        ...valid,
-        nodes: [{ ...valid.nodes[0], x: 0, y: 0, w: 100001, h: 60 }]
-      },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].w'
-    },
-    {
-      name: 'unsafe node id',
-      value: { ...valid, nodes: [{ ...valid.nodes[0], id: '../node' }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].id'
-    },
-    {
-      name: 'duplicate node id',
-      value: { ...valid, nodes: [valid.nodes[0], valid.nodes[0]] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[1].id'
-    },
-    {
-      name: 'unknown shape',
-      value: { ...valid, nodes: [{ ...valid.nodes[0], shape: 'image' }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].shape'
-    },
-    {
-      name: 'unknown canonical type',
-      value: { ...valid, nodes: [{ id: 'node', label: 'Node', type: 'not-a-type' }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].type'
-    },
-    {
-      name: 'raw style field',
-      value: { ...valid, nodes: [{ ...valid.nodes[0], style: 'shape=image;image=data:image/png;base64,AAAA' }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].style'
-    },
-    {
-      name: 'invalid color',
-      value: { ...valid, nodes: [{ ...valid.nodes[0], fill: 'url(javascript:alert(1))' }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].fill'
-    },
-    {
-      name: 'opaque text',
-      value: { ...valid, nodes: [{ id: 'node', label: 'Note', shape: 'text', fill: '#FFFFFF' }] },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes[0].fill'
-    },
-    {
-      name: 'dangling edge',
-      value: {
-        ...valid,
-        edges: [{ id: 'edge', source: 'node', target: 'missing' }]
-      },
-      code: 'ADAPTER_PARSE',
-      path: 'edges[0].target'
-    },
-    {
-      name: 'duplicate edge id',
-      value: {
-        ...valid,
-        edges: [
-          { id: 'edge', source: 'node', target: 'node' },
-          { id: 'edge', source: 'node', target: 'node' }
-        ]
-      },
-      code: 'ADAPTER_PARSE',
-      path: 'edges[1].id'
-    },
-    {
-      name: 'oversize canvas',
-      value: { ...valid, canvas: { width: 100001, height: 100 } },
-      code: 'ADAPTER_PARSE',
-      path: 'canvas.width'
-    },
-    {
-      name: 'too many nodes',
-      value: {
-        ...valid,
-        nodes: Array.from({ length: 101 }, (_, index) => ({
-          id: `node${index}`,
-          label: `Node ${index}`,
-          shape: 'rect'
-        }))
-      },
-      code: 'ADAPTER_PARSE',
-      path: 'nodes'
-    },
-    {
-      name: 'too many edges',
-      value: {
-        ...valid,
-        edges: Array.from({ length: 201 }, (_, index) => ({
-          id: `edge${index}`,
-          source: 'node',
-          target: 'node'
-        }))
-      },
-      code: 'ADAPTER_PARSE',
-      path: 'edges'
-    }
-  ]
-
-  for (const fixture of cases) {
-    assert.throws(
-      () => parseRasterExtraction(JSON.stringify(fixture.value)),
-      (error) => error.code === fixture.code && error.path === fixture.path,
-      fixture.name
-    )
-  }
-
-  assert.throws(
-    () => parseRasterExtraction('{not json'),
-    (error) => error.code === 'ADAPTER_PARSE' && error.adapter === 'raster-extraction'
-  )
-  assert.throws(
-    () =>
-      parseRasterExtraction(
-        '{"schemaVersion":1,"nodes":[{"id":"node","label":"Node","shape":"rect","__proto__":{}}],"edges":[]}'
-      ),
-    (error) => error.code === 'ADAPTER_PARSE' && /nodes\[0\].*forbidden key/.test(error.message)
-  )
-  assert.throws(
-    () =>
-      parseRasterExtraction(
-        '{"schemaVersion":1,"nodes":[{"id":"node","label":"Node","shape":"rect","x":0,"y":0,"w":1e309,"h":1}],"edges":[]}'
-      ),
-    (error) => error.code === 'ADAPTER_PARSE' && error.path === 'nodes[0].w'
-  )
-})

package/template/.claude/skills/drawio/scripts/adapters/rust-code-adapter.test.js

@@ -1,64 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { parseRustImportsProject } from './rust-code.js'
-
-test('Rust adapter projects crate/self/super use edges without a Rust toolchain', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-rust-'))
-  try {
-    mkdirSync(join(root, 'src'))
-    writeFileSync(join(root, 'src', 'a.rs'), 'use crate::b;\n')
-    writeFileSync(join(root, 'src', 'b.rs'), 'use std::fmt;\n')
-    const projection = await parseRustImportsProject(root, {
-      parseFile: (source) => ({
-        uses: source.includes('crate::b') ? ['crate::b'] : source.includes('std::fmt') ? ['std::fmt'] : [],
-        hasCfg: false,
-        hasInlineModules: false
-      })
-    })
-
-    assert.deepEqual(projection.nodes.map((node) => node.identity.key), ['rust/src/a.rs', 'rust/src/b.rs'])
-    assert.equal(projection.edges[0].relation, 'uses')
-    assert.equal(projection.edges[0].to.key, 'rust/src/b.rs')
-    assert.ok(projection.diagnostics.some((entry) => entry.code === 'RUST_NON_CRATE_USES_IGNORED'))
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Rust cfg and inline modules are reported as unsupported syntax', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-rust-'))
-  try {
-    mkdirSync(join(root, 'src'))
-    writeFileSync(join(root, 'src', 'lib.rs'), '#[cfg(unix)] mod platform { use crate::other; }\n')
-    await assert.rejects(
-      () =>
-        parseRustImportsProject(root, {
-          parseFile: () => ({ uses: [], hasCfg: true, hasInlineModules: true })
-        }),
-      (error) => error.code === 'ADAPTER_UNSUPPORTED' && error.context.path === 'src/lib.rs'
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Rust super paths cannot escape the selected crate', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-rust-'))
-  try {
-    mkdirSync(join(root, 'src'))
-    writeFileSync(join(root, 'src', 'a.rs'), 'use super::super::outside;\n')
-    await assert.rejects(
-      () =>
-        parseRustImportsProject(root, {
-          parseFile: () => ({ uses: ['super::super::outside'], hasCfg: false, hasInlineModules: false })
-        }),
-      (error) => error.code === 'ADAPTER_UNSUPPORTED' && /escapes/.test(error.message)
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})