create-yss-spec 2.1.4 → 2.1.6

package/template/.pi/skills/drawio/scripts/postprocess/artifacts.js

@@ -1,142 +0,0 @@
-import { createHash } from 'node:crypto'
-import { dirname, resolve } from 'node:path'
-import { mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs'
-
-import { serializeDocumentSpecYaml, serializeSpecYaml } from '../runtime/artifacts.js'
-import { normalizePostprocessInput, selectPostprocessPages } from './input.js'
-
-const EVIDENCE = new Set(['recorded-fixture', 'command-executed', 'missing-evidence'])
-const SENSITIVE_KEY = /(?:path|secret|token|password|credential|home|input|output)/i
-const ABSOLUTE_PATH = /^(?:[A-Za-z]:[\\/]|[\\/]{2}|\/)/
-
-function stableValue(value, key = '') {
-  if (SENSITIVE_KEY.test(key)) return undefined
-  if (typeof value === 'string') {
-    if (ABSOLUTE_PATH.test(value)) return undefined
-    return value
-  }
-  if (Array.isArray(value)) return value.map((entry) => stableValue(entry)).filter((entry) => entry !== undefined)
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.keys(value)
-        .sort()
-        .map((field) => [field, stableValue(value[field], field)])
-        .filter(([, entry]) => entry !== undefined)
-    )
-  }
-  if (value === undefined || typeof value === 'function') return undefined
-  return value
-}
-
-function canonicalBytes(input) {
-  const document = normalizePostprocessInput(input)
-  const text =
-    document.kind === 'multi-page-v1' ? serializeDocumentSpecYaml(document) : serializeSpecYaml(document.spec)
-  return { document, bytes: Buffer.from(text, 'utf8') }
-}
-
-function sha256Digest(bytes) {
-  const content = Buffer.isBuffer(bytes)
-    ? bytes
-    : bytes instanceof Uint8Array
-      ? Buffer.from(bytes)
-      : typeof bytes === 'string'
-        ? Buffer.from(bytes, 'utf8')
-        : null
-  if (!content) throw new TypeError('postprocess auxiliary input must be bytes or a string')
-  return `sha256:${createHash('sha256').update(content).digest('hex')}`
-}
-
-function auxiliaryDigestMap(inputs = {}) {
-  if (!inputs || typeof inputs !== 'object' || Array.isArray(inputs)) {
-    throw new TypeError('postprocess auxiliaryInputs must be an object')
-  }
-  const entries = Object.entries(inputs).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-  const digests = {}
-  for (const [role, bytes] of entries) {
-    if (!/^[a-z][a-z0-9-]*$/.test(role)) throw new Error(`postprocess auxiliary input role "${role}" is unsafe`)
-    digests[role] = sha256Digest(bytes)
-  }
-  return digests
-}
-
-export function buildPostprocessMetadata({
-  operation,
-  input,
-  options = {},
-  auxiliaryInputs = {},
-  outputKind,
-  evidence = 'missing-evidence',
-  diagnostics
-} = {}) {
-  if (typeof operation !== 'string' || !/^[a-z][a-z0-9-]*$/.test(operation)) {
-    throw new Error('postprocess operation must be a safe name')
-  }
-  if (typeof outputKind !== 'string' || !/^[a-z][a-z0-9-]*$/.test(outputKind)) {
-    throw new Error('postprocess outputKind must be a safe name')
-  }
-  if (!EVIDENCE.has(evidence)) throw new Error(`postprocess evidence must be one of ${[...EVIDENCE].join(', ')}`)
-  const { document, bytes } = canonicalBytes(input)
-  const selected = selectPostprocessPages(document, {
-    page: options.page,
-    allPages: options.page == null ? options.allPages !== false : options.allPages
-  })
-  const pages = selected.pages.map((page) => ({
-    index: document.pages.findIndex((candidate) => candidate.id === page.id),
-    id: page.id,
-    name: page.name
-  }))
-  const normalizedDiagnostics = stableValue(diagnostics)
-  const auxiliaryDigests = auxiliaryDigestMap(auxiliaryInputs)
-  return {
-    version: 1,
-    operation,
-    inputKind: document.kind,
-    pages,
-    options: stableValue(options) || {},
-    inputDigest: sha256Digest(bytes),
-    ...(Object.keys(auxiliaryDigests).length === 0 ? {} : { auxiliaryDigests }),
-    outputKind,
-    evidence,
-    ...(normalizedDiagnostics === undefined ? {} : { diagnostics: normalizedDiagnostics })
-  }
-}
-
-export function serializePostprocessMetadata(metadata) {
-  return `${JSON.stringify(metadata, null, 2)}\n`
-}
-
-export function derivePostprocessSidecarPath(outputPath) {
-  return `${resolve(outputPath)}.postprocess.json`
-}
-
-function pathKey(path) {
-  return resolve(path).replaceAll('\\', '/').toLowerCase()
-}
-
-export function assertDistinctPostprocessPaths(inputPath, outputPath) {
-  if (typeof outputPath !== 'string' || outputPath.trim() === '') throw new Error('postprocess output path is required')
-  if (inputPath != null && pathKey(inputPath) === pathKey(outputPath)) {
-    throw new Error('postprocess output must not overwrite the source')
-  }
-  return resolve(outputPath)
-}
-
-export function writePostprocessArtifact(outputPath, content, { inputPath } = {}) {
-  const resolved = assertDistinctPostprocessPaths(inputPath, outputPath)
-  mkdirSync(dirname(resolved), { recursive: true })
-  const temporary = `${resolved}.postprocess-tmp-${process.pid}`
-  try {
-    writeFileSync(temporary, content)
-    try {
-      renameSync(temporary, resolved)
-    } catch (error) {
-      if (!['EEXIST', 'EPERM', 'ENOTEMPTY'].includes(error.code)) throw error
-      rmSync(resolved, { force: true })
-      renameSync(temporary, resolved)
-    }
-  } finally {
-    rmSync(temporary, { force: true })
-  }
-  return resolved
-}

package/template/.pi/skills/drawio/scripts/postprocess/artifacts.test.js

@@ -1,86 +0,0 @@
-import assert from 'node:assert/strict'
-import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-
-import { normalizePostprocessInput } from './input.js'
-import {
-  assertDistinctPostprocessPaths,
-  buildPostprocessMetadata,
-  derivePostprocessSidecarPath,
-  serializePostprocessMetadata,
-  writePostprocessArtifact
-} from './artifacts.js'
-
-const bundleText = readFileSync(new URL('./fixtures/bundle.yaml', import.meta.url), 'utf8')
-const bundle = normalizePostprocessInput(bundleText)
-
-test('builds deterministic path-free postprocess provenance from canonical input bytes', () => {
-  const options = {
-    direction: 'TB',
-    page: 'context',
-    nested: { z: 2, a: 1 },
-    outputPath: 'C:\\Users\\lyh\\secret.html',
-    apiToken: 'do-not-record'
-  }
-  const first = buildPostprocessMetadata({
-    operation: 'mermaid',
-    input: bundle,
-    options,
-    auxiliaryInputs: { metrics: '{"context/gateway":5}' },
-    outputKind: 'mermaid',
-    evidence: 'command-executed'
-  })
-  const second = buildPostprocessMetadata({
-    operation: 'mermaid',
-    input: bundle,
-    options,
-    auxiliaryInputs: { metrics: '{"context/gateway":5}' },
-    outputKind: 'mermaid',
-    evidence: 'command-executed'
-  })
-  const changedAuxiliaryInput = buildPostprocessMetadata({
-    operation: 'mermaid',
-    input: bundle,
-    options,
-    auxiliaryInputs: { metrics: '{"context/gateway":6}' },
-    outputKind: 'mermaid',
-    evidence: 'command-executed'
-  })
-
-  assert.deepEqual(first, second)
-  assert.equal(first.version, 1)
-  assert.equal(first.inputKind, 'multi-page-v1')
-  assert.deepEqual(first.pages, [{ index: 0, id: 'context', name: 'Context' }])
-  assert.match(first.inputDigest, /^sha256:[0-9a-f]{64}$/)
-  assert.match(first.auxiliaryDigests.metrics, /^sha256:[0-9a-f]{64}$/)
-  assert.notEqual(first.auxiliaryDigests.metrics, changedAuxiliaryInput.auxiliaryDigests.metrics)
-  assert.deepEqual(first.options, { direction: 'TB', nested: { a: 1, z: 2 }, page: 'context' })
-  const serialized = serializePostprocessMetadata(first)
-  assert.equal(serialized.includes('Users'), false)
-  assert.equal(serialized.includes('do-not-record'), false)
-  assert.equal(serialized.includes('context/gateway'), false)
-  assert.equal(serialized.includes('timestamp'), false)
-})
-
-test('derives an adjacent postprocess sidecar and atomically writes without source aliasing', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'drawio-postprocess-'))
-  const source = join(directory, 'source.yaml')
-  const output = join(directory, 'viewer.html')
-  writeFileSync(source, bundleText, 'utf8')
-
-  try {
-    assert.equal(derivePostprocessSidecarPath(output), join(directory, 'viewer.html.postprocess.json'))
-    assert.throws(() => assertDistinctPostprocessPaths(source, source), /must not overwrite the source/i)
-    assert.throws(() => writePostprocessArtifact(source, 'changed', { inputPath: source }), /must not overwrite the source/i)
-    assert.equal(readFileSync(source, 'utf8'), bundleText)
-
-    writePostprocessArtifact(output, '<!doctype html>\n', { inputPath: source })
-    assert.equal(readFileSync(output, 'utf8'), '<!doctype html>\n')
-    assert.equal(readdirSync(directory).some((name) => name.includes('.postprocess-tmp-')), false)
-    assert.equal(existsSync(output), true)
-  } finally {
-    rmSync(directory, { recursive: true, force: true })
-  }
-})

package/template/.pi/skills/drawio/scripts/postprocess/cli.js

@@ -1,228 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { extname, resolve } from 'node:path'
-
-import { createDrawioFileContent, serializeDocumentSpecYaml, serializeSpecYaml } from '../runtime/artifacts.js'
-import { renderDocumentFile } from '../dsl/multi-page.js'
-import { specToDrawioXml, validateXml } from '../dsl/spec-to-drawio.js'
-import { applyHeatmap, applyRelabel, applyRestyle } from './mutate.js'
-import { renderHtml } from './html.js'
-import { explainDocument, renderMermaid } from './projection.js'
-import {
-  assertDistinctPostprocessPaths,
-  buildPostprocessMetadata,
-  derivePostprocessSidecarPath,
-  serializePostprocessMetadata,
-  writePostprocessArtifact
-} from './artifacts.js'
-import { normalizePostprocessInput } from './input.js'
-
-const OPERATIONS = new Set(['mermaid', 'explain', 'relabel', 'restyle', 'heatmap', 'html'])
-const VALUE_FLAGS = new Set([
-  '--input-format', '--page', '--map', '--preset', '--metrics', '--palette', '--direction', '--title', '--search',
-  '--size-min', '--size-max', '--min', '--max'
-])
-const BOOLEAN_FLAGS = new Set(['--all-pages', '--fenced', '--label-fallback', '--allow-missing'])
-
-function parseOptions(args) {
-  const options = {}
-  for (let index = 0; index < args.length; index++) {
-    const flag = args[index]
-    if (BOOLEAN_FLAGS.has(flag)) {
-      options[flag.slice(2).replaceAll('-', '')] = true
-      continue
-    }
-    if (!VALUE_FLAGS.has(flag)) throw new Error(`unknown postprocess option "${flag}"`)
-    const value = args[++index]
-    if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`)
-    options[flag.slice(2).replaceAll('-', '')] = value
-  }
-  return options
-}
-
-function readLocalFile(path, context) {
-  try {
-    const bytes = readFileSync(resolve(path))
-    return { bytes, text: bytes.toString('utf8') }
-  } catch (error) {
-    throw new Error(`could not read ${context} "${path}": ${error.message}`)
-  }
-}
-
-function readJsonInput(path, context) {
-  const input = readLocalFile(path, context)
-  try {
-    return { ...input, value: JSON.parse(input.text) }
-  } catch (error) {
-    throw new Error(`could not parse ${context} "${path}": ${error.message}`)
-  }
-}
-
-function readInput(path) {
-  if (!path || path === '-') throw new Error('postprocess input must be an explicit local file path')
-  try {
-    return readFileSync(resolve(path), 'utf8')
-  } catch (error) {
-    throw new Error(`could not read postprocess input "${path}": ${error.message}`)
-  }
-}
-
-function resolvePresetInput(value) {
-  if (!value) throw new Error('restyle requires --preset <bundled-name|json-file>')
-  if (!value.endsWith('.json')) return { value }
-  const input = readJsonInput(value, 'restyle preset')
-  return { value: input.value, bytes: input.bytes }
-}
-
-function optionNumber(value, name) {
-  if (value == null) return undefined
-  const number = Number(value)
-  if (!Number.isFinite(number)) throw new Error(`${name} requires a finite number`)
-  return number
-}
-
-function canonicalOutput(document, extension) {
-  if (extension === '.drawio') {
-    if (document.kind === 'multi-page-v1') return renderDocumentFile(document, { silent: true })
-    const xml = specToDrawioXml(document.spec, { silent: true })
-    const validation = validateXml(xml)
-    if (!validation.valid) throw new Error(`canonical XML validation failed: ${validation.errors.join('; ')}`)
-    return createDrawioFileContent(xml)
-  }
-  if (extension === '.yaml' || extension === '.yml') {
-    return document.kind === 'multi-page-v1' ? serializeDocumentSpecYaml(document) : serializeSpecYaml(document.spec)
-  }
-  throw new Error(`unsupported postprocess output extension "${extension}"`)
-}
-
-function auxiliaryInputPaths(options) {
-  const paths = [options.map, options.metrics]
-  if (typeof options.preset === 'string' && options.preset.endsWith('.json')) paths.push(options.preset)
-  return paths.filter(Boolean)
-}
-
-function assertPreservedInputPaths(inputPaths, outputPath) {
-  const sidecarPath = derivePostprocessSidecarPath(outputPath)
-  for (const inputPath of inputPaths) {
-    assertDistinctPostprocessPaths(inputPath, outputPath)
-    assertDistinctPostprocessPaths(inputPath, sidecarPath)
-  }
-  return sidecarPath
-}
-
-export async function runPostprocessCommand(commandArgs, { stdout = process.stdout, stderr = process.stderr } = {}) {
-  const [operation, inputPath, outputPath, ...optionArgs] = commandArgs
-  if (!OPERATIONS.has(operation)) throw new Error(`unsupported postprocess operation "${operation || ''}"`)
-  if (!inputPath || !outputPath) {
-    throw new Error('postprocess requires <operation> <input-file> <output-file>')
-  }
-  const options = parseOptions(optionArgs)
-  if (options.page != null && options.allpages) throw new Error('--all-pages cannot be combined with --page')
-  const inputFormat = options.inputformat || 'yaml'
-  if (!['yaml', 'drawio'].includes(inputFormat)) throw new Error(`unsupported postprocess input format "${inputFormat}"`)
-  const extension = outputPath === '-' ? null : extname(outputPath).toLowerCase()
-  const projection = new Set(['mermaid', 'explain', 'html']).has(operation)
-  if (outputPath === '-' && !projection) {
-    throw new Error('canonical postprocess output requires an explicit file path')
-  }
-  let sidecarPath
-  if (outputPath !== '-') {
-    sidecarPath = assertPreservedInputPaths([inputPath, ...auxiliaryInputPaths(options)], outputPath)
-  }
-
-  const inputText = readInput(inputPath)
-  const input = normalizePostprocessInput(inputText, { inputFormat })
-  const transformOptions = {
-    page: options.page,
-    allPages: options.allpages,
-    direction: options.direction,
-    fenced: options.fenced,
-    title: options.title,
-    search: options.search,
-    labelFallback: options.labelfallback,
-    allowMissing: options.allowmissing,
-    palette: options.palette,
-    min: optionNumber(options.min, '--min'),
-    max: optionNumber(options.max, '--max')
-  }
-  if (options.sizemin != null || options.sizemax != null) {
-    transformOptions.sizeScale = {
-      min: optionNumber(options.sizemin, '--size-min'),
-      max: optionNumber(options.sizemax, '--size-max')
-    }
-  }
-
-  let content
-  let outputKind
-  let diagnostics
-  const auxiliaryInputs = {}
-  if (operation === 'mermaid') {
-    if (outputPath !== '-' && !['.mmd', '.md', '.txt'].includes(extension)) throw new Error('mermaid output must use .mmd, .md, or .txt')
-    const rendered = renderMermaid(input, { ...transformOptions, returnWarnings: true })
-    content = rendered.text
-    diagnostics = { warnings: rendered.warnings }
-    for (const warning of rendered.warnings) stderr.write(`Warning: ${warning}\n`)
-    outputKind = 'mermaid'
-  } else if (operation === 'explain') {
-    if (outputPath !== '-' && !['.md', '.txt'].includes(extension)) throw new Error('explain output must use .md or .txt')
-    content = explainDocument(input, transformOptions)
-    outputKind = 'markdown'
-  } else if (operation === 'html') {
-    if (outputPath !== '-' && !['.html', '.htm'].includes(extension)) throw new Error('html output must use .html or .htm')
-    content = await renderHtml(input, transformOptions)
-    outputKind = 'html'
-  } else {
-    if (!['.yaml', '.yml', '.drawio'].includes(extension)) throw new Error('canonical postprocess output must use .yaml, .yml, or .drawio')
-    let transformed
-    if (operation === 'relabel') {
-      if (!options.map) throw new Error('relabel requires --map <json-file>')
-      const mapInput = readJsonInput(options.map, 'relabel map')
-      auxiliaryInputs.map = mapInput.bytes
-      const result = applyRelabel(input, mapInput.value, {
-        ...transformOptions,
-        returnDiagnostics: true
-      })
-      transformed = result.value
-      diagnostics = result.diagnostics
-    } else if (operation === 'restyle') {
-      const presetInput = resolvePresetInput(options.preset)
-      if (presetInput.bytes) auxiliaryInputs.preset = presetInput.bytes
-      const result = applyRestyle(input, presetInput.value, {
-        ...transformOptions,
-        returnDiagnostics: true
-      })
-      transformed = result.value
-      diagnostics = result.diagnostics
-    } else {
-      if (!options.metrics) throw new Error('heatmap requires --metrics <json-or-csv-file>')
-      const metricsInput = readLocalFile(options.metrics, 'heatmap metrics')
-      auxiliaryInputs.metrics = metricsInput.bytes
-      const result = applyHeatmap(input, metricsInput.text, {
-        ...transformOptions,
-        returnDiagnostics: true
-      })
-      transformed = result.value
-      diagnostics = result.diagnostics
-    }
-    const normalized = normalizePostprocessInput(transformed)
-    content = await canonicalOutput(normalized, extension)
-    outputKind = extension === '.drawio' ? 'drawio' : 'spec-yaml'
-  }
-
-  if (outputPath === '-') {
-    stdout.write(content)
-    if (!content.endsWith('\n')) stdout.write('\n')
-    return
-  }
-  const metadata = buildPostprocessMetadata({
-    operation,
-    input,
-    options: transformOptions,
-    auxiliaryInputs,
-    outputKind,
-    evidence: 'command-executed',
-    diagnostics
-  })
-  writePostprocessArtifact(outputPath, content, { inputPath })
-  writePostprocessArtifact(sidecarPath, serializePostprocessMetadata(metadata), { inputPath })
-  stderr.write(`Saved postprocess ${operation}: ${outputPath}\n`)
-}

package/template/.pi/skills/drawio/scripts/postprocess/cli.test.js

@@ -1,129 +0,0 @@
-import assert from 'node:assert/strict'
-import { execFileSync, spawnSync } from 'node:child_process'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import test from 'node:test'
-
-import { parseDocumentYaml } from '../dsl/document-spec.js'
-import { validateDrawioDocument } from '../dsl/multi-page.js'
-
-const CLI = resolve('skills/drawio/scripts/cli.js')
-const BUNDLE = readFileSync(new URL('./fixtures/bundle.yaml', import.meta.url), 'utf8')
-
-function run(args) {
-  return execFileSync(process.execPath, [CLI, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
-}
-
-function runResult(args) {
-  return spawnSync(process.execPath, [CLI, ...args], { encoding: 'utf8' })
-}
-
-test('CLI runs all six approved postprocess operations and writes deterministic sidecars', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'drawio-postprocess-cli-'))
-  const input = join(directory, 'bundle.yaml')
-  const map = join(directory, 'labels.json')
-  const metrics = join(directory, 'metrics.json')
-  writeFileSync(input, BUNDLE, 'utf8')
-  writeFileSync(map, JSON.stringify({ 'context/gateway': 'Gateway CLI' }), 'utf8')
-  writeFileSync(metrics, JSON.stringify({ 'context/gateway': 0, 'context/cache': 10, unmatched: 5 }), 'utf8')
-
-  try {
-    const mermaid = join(directory, 'bundle.mmd')
-    const explain = join(directory, 'bundle.md')
-    const relabel = join(directory, 'relabel.spec.yaml')
-    const restyle = join(directory, 'restyle.drawio')
-    const heatmap = join(directory, 'heatmap.spec.yaml')
-    const html = join(directory, 'bundle.html')
-
-    run(['postprocess', 'mermaid', input, mermaid, '--page', 'context', '--direction', 'TB'])
-    run(['postprocess', 'explain', input, explain, '--all-pages'])
-    run(['postprocess', 'relabel', input, relabel, '--map', map])
-    run(['postprocess', 'restyle', input, restyle, '--preset', 'corporate'])
-    run(['postprocess', 'heatmap', input, heatmap, '--metrics', metrics, '--palette', 'heat'])
-    run(['postprocess', 'html', input, html, '--title', 'Offline bundle'])
-
-    assert.match(readFileSync(mermaid, 'utf8'), /^flowchart TB/)
-    assert.match(readFileSync(explain, 'utf8'), /^# Postprocess bundle fixture/)
-    assert.equal(parseDocumentYaml(readFileSync(relabel, 'utf8')).pages[0].nodes[0].label, 'Gateway CLI')
-    assert.equal(validateDrawioDocument(readFileSync(restyle, 'utf8')).valid, true)
-    assert.equal(parseDocumentYaml(readFileSync(heatmap, 'utf8')).pages[0].nodes[0].style.fillColor, '#FFF7EC')
-    assert.match(readFileSync(html, 'utf8'), /^<!doctype html>/)
-
-    for (const [path, operation] of [
-      [mermaid, 'mermaid'], [explain, 'explain'], [relabel, 'relabel'], [restyle, 'restyle'], [heatmap, 'heatmap'], [html, 'html']
-    ]) {
-      const sidecar = `${path}.postprocess.json`
-      const metadata = JSON.parse(readFileSync(sidecar, 'utf8'))
-      assert.equal(metadata.operation, operation)
-      assert.equal(JSON.stringify(metadata).includes(directory), false)
-      if (operation === 'relabel') assert.match(metadata.auxiliaryDigests.map, /^sha256:[0-9a-f]{64}$/)
-      if (operation === 'heatmap') {
-        assert.match(metadata.auxiliaryDigests.metrics, /^sha256:[0-9a-f]{64}$/)
-        assert.deepEqual(metadata.diagnostics.unmatched, ['unmatched'])
-      }
-    }
-  } finally {
-    rmSync(directory, { recursive: true, force: true })
-  }
-})
-
-test('CLI rejects selector conflicts, source aliasing, deferred operations, and mutator stdout', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'drawio-postprocess-errors-'))
-  const input = join(directory, 'bundle.yaml')
-  const map = join(directory, 'labels.json')
-  writeFileSync(input, BUNDLE, 'utf8')
-  writeFileSync(map, JSON.stringify({ 'context/gateway': 'Gateway CLI' }), 'utf8')
-
-  try {
-    const conflict = runResult(['postprocess', 'html', input, join(directory, 'x.html'), '--page', 'context', '--all-pages'])
-    assert.notEqual(conflict.status, 0)
-    assert.match(conflict.stderr, /--all-pages cannot be combined with --page/i)
-
-    const alias = runResult(['postprocess', 'mermaid', input, input])
-    assert.notEqual(alias.status, 0)
-    assert.match(alias.stderr, /must not overwrite the source/i)
-
-    const deferred = runResult(['postprocess', 'runbook', input, join(directory, 'runbook.html')])
-    assert.notEqual(deferred.status, 0)
-    assert.match(deferred.stderr, /unsupported postprocess operation.*runbook/i)
-
-    const stdout = runResult(['postprocess', 'relabel', input, '-', '--map', map])
-    assert.notEqual(stdout.status, 0)
-    assert.match(stdout.stderr, /canonical postprocess output requires an explicit file path/i)
-  } finally {
-    rmSync(directory, { recursive: true, force: true })
-  }
-})
-
-test('CLI records Mermaid downgrade warnings and preserves auxiliary input files', () => {
-  const directory = mkdtempSync(join(tmpdir(), 'drawio-postprocess-inputs-'))
-  const input = join(directory, 'unsupported.yaml')
-  const mermaid = join(directory, 'unsupported.mmd')
-  const mapAsOutput = join(directory, 'protected-map.yaml')
-  const outputWithSidecarMap = join(directory, 'sidecar-output.yaml')
-  const sidecarMap = `${outputWithSidecarMap}.postprocess.json`
-  const mapText = JSON.stringify({ api: 'Renamed' })
-  writeFileSync(input, 'nodes:\n  - id: api\n    label: API\n    type: document\nedges: []\nmodules: []\n', 'utf8')
-  writeFileSync(mapAsOutput, mapText, 'utf8')
-  writeFileSync(sidecarMap, mapText, 'utf8')
-
-  try {
-    run(['postprocess', 'mermaid', input, mermaid])
-    const metadata = JSON.parse(readFileSync(`${mermaid}.postprocess.json`, 'utf8'))
-    assert.equal(metadata.diagnostics.warnings.length, 1)
-    assert.match(metadata.diagnostics.warnings[0], /unsupported Mermaid type.*document/i)
-
-    const outputAlias = runResult(['postprocess', 'relabel', input, mapAsOutput, '--map', mapAsOutput])
-    assert.notEqual(outputAlias.status, 0)
-    assert.match(outputAlias.stderr, /must not overwrite the source/i)
-    assert.equal(readFileSync(mapAsOutput, 'utf8'), mapText)
-
-    const sidecarAlias = runResult(['postprocess', 'relabel', input, outputWithSidecarMap, '--map', sidecarMap])
-    assert.notEqual(sidecarAlias.status, 0)
-    assert.match(sidecarAlias.stderr, /must not overwrite the source/i)
-    assert.equal(readFileSync(sidecarMap, 'utf8'), mapText)
-  } finally {
-    rmSync(directory, { recursive: true, force: true })
-  }
-})

package/template/.pi/skills/drawio/scripts/postprocess/fixtures/bundle.yaml

@@ -1,75 +0,0 @@
-schemaVersion: 1
-meta:
-  title: Postprocess bundle fixture
-  source: generated
-  description: Stable multi-page consumer baseline
-pages:
-  - id: context
-    name: Context
-    meta:
-      title: Context
-      source: generated
-      theme: tech-blue
-      layout: horizontal
-      adapter:
-        projectionVersion: 1
-        name: postprocess-fixture
-        domain: architecture
-        mode: code
-        locator: fixtures/context.yaml
-    nodes:
-      - id: gateway
-        label: Gateway
-        type: service
-        icon: lucide.server-cog
-        identity: { scheme: fixture, key: context/gateway }
-        bounds: { x: 40, y: 80, width: 120, height: 60 }
-      - id: cache
-        label: Redis
-        type: database
-        icon: redis.server
-        identity: { scheme: fixture, key: context/cache }
-        bounds: { x: 280, y: 80, width: 120, height: 60 }
-      - id: model
-        label: Model
-        type: service
-        icon: lobe.openai
-        identity: { scheme: fixture, key: context/model }
-        bounds: { x: 520, y: 80, width: 120, height: 60 }
-      - id: worker
-        label: Worker
-        type: service
-        icon: aws.lambda
-        identity: { scheme: fixture, key: context/worker }
-        bounds: { x: 760, y: 80, width: 120, height: 60 }
-    edges:
-      - id: flow
-        from: gateway
-        to: cache
-        label: query
-        identity: { scheme: fixture, key: context/flow }
-    modules: []
-  - id: detail
-    name: Detail
-    meta:
-      title: Detail
-      source: generated
-      theme: academic
-      layout: vertical
-      profile: academic-paper
-      figureType: architecture
-      print: { target: cn-thesis }
-    nodes:
-      - id: gateway
-        label: Detail gateway
-        type: service
-        icon: lucide.network
-        bounds: { x: 80, y: 80, width: 160, height: 64 }
-    edges: []
-    modules:
-      - id: paper
-        label: Academic layer
-        color: '#E8F0FE'
-links:
-  - from: { pageId: context, objectId: gateway }
-    to: { pageId: detail, objectId: gateway }

package/template/.pi/skills/drawio/scripts/postprocess/fixtures/legacy.yaml

@@ -1,21 +0,0 @@
-meta:
-  title: Legacy postprocess fixture
-  source: generated
-  theme: tech-blue
-  layout: horizontal
-nodes:
-  - id: api
-    label: API
-    type: service
-    icon: lucide.server-cog
-    bounds: { x: 40, y: 80, width: 120, height: 60 }
-  - id: cache
-    label: Redis
-    type: database
-    icon: redis.server
-    bounds: { x: 280, y: 80, width: 120, height: 60 }
-edges:
-  - from: api
-    to: cache
-    label: queries
-modules: []