create-yss-spec 3.3.0 → 3.3.3

package/template/.trae/skills/archify/test/legend-contract.test.mjs

@@ -1,404 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(__dirname, '..');
-const cli = path.join(skillRoot, 'bin/archify.mjs');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-legend-contract-'));
-let sequence = 0;
-
-const FIXTURES = {
-  architecture: {
-    schema_version: 1,
-    diagram_type: 'architecture',
-    meta: { title: 'Legend architecture', viewBox: [720, 420] },
-    components: [
-      { id: 'ui', type: 'frontend', label: 'UI', pos: [60, 90] },
-      { id: 'store', type: 'database', label: 'Store', pos: [300, 90] },
-    ],
-    connections: [],
-  },
-  workflow: {
-    schema_version: 1,
-    diagram_type: 'workflow',
-    meta: { title: 'Legend workflow', viewBox: [720, 360] },
-    lanes: [{ id: 'main', label: 'Main' }],
-    nodes: [
-      { id: 'ui', lane: 'main', col: 0, type: 'frontend', label: 'UI' },
-      { id: 'agent', lane: 'main', col: 2, type: 'backend', label: 'Agent' },
-    ],
-    edges: [],
-  },
-  sequence: {
-    schema_version: 1,
-    diagram_type: 'sequence',
-    meta: { title: 'Legend sequence', viewBox: [720, 560] },
-    participants: [
-      { id: 'client', type: 'frontend', label: 'Client' },
-      { id: 'api', type: 'backend', label: 'API' },
-    ],
-    messages: [
-      { from: 'client', to: 'api', y: 220, label: 'request', variant: 'emphasis' },
-      { from: 'api', to: 'client', y: 280, label: 'response', variant: 'return' },
-    ],
-  },
-  dataflow: {
-    schema_version: 1,
-    diagram_type: 'dataflow',
-    meta: { title: 'Default Flow Only' },
-    stages: [{ label: 'Input' }, { label: 'Output' }],
-    nodes: [
-      { id: 'input', type: 'backend', label: 'Input', stage: 0, row: 0 },
-      { id: 'output', type: 'backend', label: 'Output', stage: 1, row: 0 },
-    ],
-    flows: [
-      { from: 'input', to: 'output', label: 'request', route: 'straight' },
-    ],
-  },
-  lifecycle: {
-    schema_version: 1,
-    diagram_type: 'lifecycle',
-    meta: { title: 'No Waiting or Failure', viewBox: [720, 566] },
-    lanes: [{ id: 'main', label: 'Lifecycle' }],
-    states: [
-      { id: 'started', type: 'start', label: 'Started', lane: 'main', col: 0 },
-      { id: 'running', type: 'active', label: 'Running', lane: 'main', col: 1 },
-      { id: 'completed', type: 'success', label: 'Completed', lane: 'main', col: 2 },
-    ],
-    transitions: [
-      { from: 'started', to: 'running' },
-      { from: 'running', to: 'completed' },
-    ],
-  },
-};
-
-const CATALOGS = {
-  architecture: ['frontend', 'backend', 'database', 'cloud', 'security', 'messagebus', 'external'],
-  workflow: ['frontend', 'backend', 'security', 'messagebus', 'database', 'cloud', 'external'],
-  sequence: ['emphasis', 'return', 'security', 'dashed', 'default'],
-  dataflow: ['emphasis', 'security', 'dashed', 'database', 'default'],
-  lifecycle: ['start', 'active', 'waiting', 'decision', 'success', 'failure', 'neutral', 'external'],
-};
-
-const AUTO_KINDS = {
-  architecture: ['frontend', 'database'],
-  workflow: ['frontend', 'backend'],
-  sequence: ['emphasis', 'return'],
-  dataflow: ['default'],
-  lifecycle: ['start', 'active', 'success'],
-};
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function withLegend(type, legend) {
-  const doc = clone(FIXTURES[type]);
-  if (legend !== undefined) doc.meta.legend = legend;
-  return doc;
-}
-
-function run(type, doc, command = 'render') {
-  const id = sequence++;
-  const input = path.join(tmp, `${id}-${type}.json`);
-  const output = path.join(tmp, `${id}-${type}.html`);
-  fs.writeFileSync(input, JSON.stringify(doc));
-  const args = command === 'render'
-    ? [cli, 'render', type, input, output]
-    : [cli, 'validate', type, input, '--json'];
-  const result = spawnSync(process.execPath, args, { cwd: skillRoot, encoding: 'utf8' });
-  return {
-    ...result,
-    html: result.status === 0 && command === 'render' ? fs.readFileSync(output, 'utf8') : '',
-  };
-}
-
-function render(type, doc) {
-  const result = run(type, doc);
-  assert.equal(result.status, 0, result.stderr || result.stdout);
-  return result.html;
-}
-
-function canonicalSvg(html) {
-  return html.match(/<svg\b[\s\S]*?<\/svg>/)?.[0] || '';
-}
-
-function attrValues(source, attribute) {
-  const pattern = new RegExp(`${attribute}="([^"]+)"`, 'g');
-  return [...source.matchAll(pattern)].map((match) => match[1]);
-}
-
-function legendKinds(html) {
-  return attrValues(canonicalSvg(html), 'data-legend-semantic-kind');
-}
-
-function validateFailure(type, doc) {
-  const result = run(type, doc, 'validate');
-  assert.notEqual(result.status, 0, `expected ${type} validation to fail`);
-  const payload = JSON.parse(result.stdout);
-  assert.equal(payload.ok, false);
-  return payload;
-}
-
-test('public typed renderers default to auto and expose only authored semantic kinds', () => {
-  for (const type of Object.keys(FIXTURES)) {
-    const html = render(type, FIXTURES[type]);
-    assert.deepEqual(legendKinds(html), AUTO_KINDS[type], type);
-  }
-});
-
-test('Dataflow database node facts are interactive while flow variants stay visual-only', () => {
-  const withDatabase = clone(FIXTURES.dataflow);
-  withDatabase.nodes[1].type = 'database';
-  const databaseSvg = canonicalSvg(render('dataflow', withDatabase));
-  assert.deepEqual(attrValues(databaseSvg, 'data-legend-semantic-kind'), ['database', 'default']);
-  assert.deepEqual(attrValues(databaseSvg, 'data-legend-kind'), ['database']);
-  assert.equal((databaseSvg.match(/data-legend-bridge=""/g) || []).length, 1);
-  assert.ok(attrValues(databaseSvg, 'data-node-kind').includes('database'));
-
-  const forcedWithoutFact = canonicalSvg(render('dataflow', withLegend('dataflow', {
-    entries: { database: { visible: true } },
-  })));
-  assert.deepEqual(attrValues(forcedWithoutFact, 'data-legend-semantic-kind'), ['database', 'default']);
-  assert.deepEqual(attrValues(forcedWithoutFact, 'data-legend-kind'), []);
-  assert.doesNotMatch(forcedWithoutFact, /data-legend-bridge/);
-});
-
-test('Issue #52 dataflow and lifecycle reproductions publish truthful default legends', () => {
-  const dataflow = canonicalSvg(render('dataflow', FIXTURES.dataflow));
-  assert.deepEqual(attrValues(dataflow, 'data-legend-semantic-kind'), ['default']);
-  assert.doesNotMatch(dataflow, /policy \/ PII|async batch|primary data|data store/i);
-  assert.doesNotMatch(dataflow, /data-legend-bridge|data-legend-kind=/);
-
-  const lifecycle = canonicalSvg(render('lifecycle', FIXTURES.lifecycle));
-  const lifecycleLegend = lifecycle.slice(lifecycle.indexOf('<!-- Legend -->'));
-  assert.deepEqual(attrValues(lifecycleLegend, 'data-legend-semantic-kind'), ['start', 'active', 'success']);
-  assert.doesNotMatch(lifecycleLegend, /waiting|failure \/ exit/i);
-  assert.deepEqual(attrValues(lifecycleLegend, 'data-legend-kind'), ['start', 'active', 'success']);
-});
-
-test('all mode follows each renderer-owned stable catalog order', () => {
-  for (const type of Object.keys(FIXTURES)) {
-    const html = render(type, withLegend(type, { mode: 'all' }));
-    assert.deepEqual(legendKinds(html), CATALOGS[type], type);
-  }
-});
-
-test('hidden mode removes the complete legend and overrides visible true', () => {
-  for (const type of Object.keys(FIXTURES)) {
-    const forcedKind = CATALOGS[type].at(-1);
-    const html = render(type, withLegend(type, {
-      mode: 'hidden',
-      entries: { [forcedKind]: { label: 'Must stay hidden', visible: true } },
-    }));
-    const svg = canonicalSvg(html);
-    assert.doesNotMatch(svg, />Legend</);
-    assert.doesNotMatch(svg, /data-legend(?:-semantic-kind|-kind|-bridge)?=/);
-    assert.doesNotMatch(svg, /Must stay hidden/);
-  }
-});
-
-test('visibility overrides apply after auto/all and empty legends leave no chrome', () => {
-  const cases = {
-    architecture: { hidden: 'frontend', forced: 'external' },
-    workflow: { hidden: 'frontend', forced: 'security' },
-    sequence: { hidden: 'emphasis', forced: 'dashed' },
-    dataflow: { hidden: 'default', forced: 'database' },
-    lifecycle: { hidden: 'active', forced: 'waiting' },
-  };
-  for (const [type, kinds] of Object.entries(cases)) {
-    const html = render(type, withLegend(type, {
-      entries: {
-        [kinds.hidden]: { visible: false },
-        [kinds.forced]: { visible: true },
-      },
-    }));
-    const expected = AUTO_KINDS[type]
-      .filter((kind) => kind !== kinds.hidden)
-      .concat(kinds.forced)
-      .sort((left, right) => CATALOGS[type].indexOf(left) - CATALOGS[type].indexOf(right));
-    assert.deepEqual(legendKinds(html), expected, type);
-  }
-
-  const allMinusSecurity = render('sequence', withLegend('sequence', {
-    mode: 'all',
-    entries: { security: { visible: false } },
-  }));
-  assert.deepEqual(
-    legendKinds(allMinusSecurity),
-    CATALOGS.sequence.filter((kind) => kind !== 'security'),
-  );
-
-  for (const type of Object.keys(FIXTURES)) {
-    const entries = Object.fromEntries(AUTO_KINDS[type].map((kind) => [kind, { visible: false }]));
-    const empty = canonicalSvg(render(type, withLegend(type, { entries })));
-    assert.doesNotMatch(empty, />Legend</, type);
-    assert.doesNotMatch(empty, /data-legend/, type);
-  }
-});
-
-test('label overrides round-trip through all five public renderers', () => {
-  for (const type of Object.keys(FIXTURES)) {
-    const kind = AUTO_KINDS[type][0];
-    const label = `Custom ${type} label`;
-    const svg = canonicalSvg(render(type, withLegend(type, {
-      entries: { [kind]: { label } },
-    })));
-    assert.match(svg, new RegExp(`data-legend-semantic-kind="${kind}"`), type);
-    assert.match(svg, new RegExp(`>${label}<`), type);
-    if (['architecture', 'workflow', 'lifecycle'].includes(type)) {
-      assert.match(svg, new RegExp(`data-legend-kind="${kind}"[^>]+data-legend-label="${label}"`), type);
-    } else {
-      assert.doesNotMatch(svg, /data-legend-kind=/, type);
-    }
-  }
-});
-
-test('label overrides preserve stable kinds and exact Semantic Legend boundaries', () => {
-  const architecture = render('architecture', withLegend('architecture', {
-    entries: {
-      frontend: { label: 'Reader <UI> & "ops"' },
-      external: { label: 'Future integration', visible: true },
-    },
-  }));
-  const svg = canonicalSvg(architecture);
-  const baselineSvg = canonicalSvg(render('architecture', FIXTURES.architecture));
-  assert.deepEqual(attrValues(svg, 'data-node-id'), attrValues(baselineSvg, 'data-node-id'));
-  assert.deepEqual(attrValues(svg, 'data-node-kind'), attrValues(baselineSvg, 'data-node-kind'));
-  assert.deepEqual(attrValues(svg, 'data-edge-from'), attrValues(baselineSvg, 'data-edge-from'));
-  assert.match(svg, />Reader &lt;UI&gt; &amp; &quot;ops&quot;</);
-  assert.doesNotMatch(svg, /<UI>/);
-  assert.match(svg, />Future integration</);
-  assert.deepEqual(attrValues(svg, 'data-legend-semantic-kind'), ['frontend', 'database', 'external']);
-  assert.deepEqual(attrValues(svg, 'data-legend-kind'), ['frontend', 'database']);
-  assert.match(svg, /data-legend-kind="frontend"[^>]+data-legend-label="Reader &lt;UI&gt; &amp; &quot;ops&quot;"/);
-  assert.match(architecture, /entry\.getAttribute\('data-legend-label'\)/);
-
-  for (const type of ['sequence', 'dataflow']) {
-    const kind = type === 'sequence' ? 'emphasis' : 'default';
-    const html = canonicalSvg(render(type, withLegend(type, {
-      entries: { [kind]: { label: 'Visible only' } },
-    })));
-    assert.match(html, />Visible only</);
-    assert.doesNotMatch(html, /data-legend-bridge|data-legend-kind=/);
-  }
-});
-
-test('strict per-renderer schemas reject malformed legend contracts with path-prefixed errors', () => {
-  const known = {
-    architecture: 'frontend', workflow: 'frontend', sequence: 'default', dataflow: 'default', lifecycle: 'start',
-  };
-  const cases = [
-    [{ mode: 'sometimes' }, '/meta/legend/mode'],
-    [{ entries: { unknown_kind: { visible: true } } }, '/meta/legend/entries'],
-    [(type) => ({ entries: { [known[type]]: { label: '' } } }), '/meta/legend/entries/'],
-    [(type) => ({ entries: { [known[type]]: { visible: 'yes' } } }), '/meta/legend/entries/'],
-    [(type) => ({ entries: { [known[type]]: { color: '#fff' } } }), '/meta/legend/entries/'],
-    [{ mode: 'auto', extra: true }, '/meta/legend'],
-  ];
-  for (const type of Object.keys(FIXTURES)) {
-    for (const [legendOrFactory, pathPrefix] of cases) {
-      const legend = typeof legendOrFactory === 'function' ? legendOrFactory(type) : legendOrFactory;
-      const failure = validateFailure(type, withLegend(type, legend));
-      assert.ok(
-        failure.diagnostics.some((diagnostic) => diagnostic.subject.path.startsWith(pathPrefix)),
-        `${type}: expected a diagnostic under ${pathPrefix}: ${JSON.stringify(failure.diagnostics)}`,
-      );
-    }
-  }
-});
-
-test('measured legends fail explicitly instead of wrapping into diagram content', () => {
-  const label = '界'.repeat(40);
-  const entries = Object.fromEntries(CATALOGS.workflow.map((kind) => [kind, { label }]));
-  const failure = validateFailure('workflow', withLegend('workflow', { mode: 'all', entries }));
-  const diagnostic = failure.diagnostics.find((entry) => entry.code === 'legend/vertical-overflow');
-  assert.ok(diagnostic, JSON.stringify(failure.diagnostics));
-  assert.equal(diagnostic.subject.path, '/meta/legend');
-  assert.ok(diagnostic.evidence.rowCount > 1);
-
-  const routedEntries = Object.fromEntries(CATALOGS.architecture.map((kind) => [
-    kind,
-    { label: `Long ${kind} convention` },
-  ]));
-  const routed = withLegend('architecture', { mode: 'all', entries: routedEntries });
-  routed.connections = [{
-    from: 'ui',
-    to: 'store',
-    label: 'bottom route',
-    fromSide: 'bottom',
-    toSide: 'bottom',
-    via: [[120, 382], [360, 382]],
-    labelAt: [240, 370],
-  }];
-  const renderFailure = run('architecture', routed);
-  assert.notEqual(renderFailure.status, 0);
-  assert.match(renderFailure.stderr, /legend\/content-overlap/);
-  assert.equal(renderFailure.html, '');
-});
-
-test('explicit Architecture viewBox rejects legend title rectangles that overlap content', () => {
-  const doc = clone(FIXTURES.architecture);
-  doc.meta.viewBox = [320, 320];
-  doc.meta.legend = { mode: 'auto' };
-  doc.components = [
-    { id: 'ui', type: 'frontend', label: 'UI', pos: [40, 216], size: [120, 60] },
-  ];
-  const failure = validateFailure('architecture', doc);
-  const diagnostic = failure.diagnostics.find((entry) => entry.code === 'legend/vertical-overflow');
-  assert.ok(diagnostic, JSON.stringify(failure.diagnostics));
-  assert.equal(diagnostic.subject.path, '/meta/legend');
-  assert.ok(diagnostic.evidence.requiredTopY < diagnostic.evidence.availableTopY);
-});
-
-test('a single unfit label fails with a path-specific width diagnostic', () => {
-  const failure = validateFailure('architecture', withLegend('architecture', {
-    entries: { frontend: { label: '界'.repeat(80) } },
-  }));
-  const diagnostic = failure.diagnostics.find((entry) => entry.code === 'legend/label-too-wide');
-  assert.ok(diagnostic, JSON.stringify(failure.diagnostics));
-  assert.equal(diagnostic.subject.path, '/meta/legend/entries/frontend/label');
-  assert.ok(diagnostic.evidence.measuredWidthPx > diagnostic.evidence.availableWidthPx);
-});
-
-test('measured legend rows share baselines and stay within the viewBox for localized labels', () => {
-  const doc = withLegend('lifecycle', {
-    mode: 'all',
-    entries: {
-      start: { label: '开始 / Start of the complete lifecycle' },
-      active: { label: '正在执行 active processing' },
-      waiting: { label: '等待人工输入' },
-      decision: { label: 'Decision gate with deterministic wrapping' },
-      success: { label: '成功完成' },
-      failure: { label: 'Failure / 失败' },
-      neutral: { label: 'Neutral state' },
-      external: { label: 'External system' },
-    },
-  });
-  const svg = canonicalSvg(render('lifecycle', doc));
-  const viewBox = attrValues(svg.match(/<svg\b[^>]*>/)?.[0] || '', 'viewBox')[0].split(/\s+/).map(Number);
-  const tags = [...svg.matchAll(/<g\b[^>]*data-legend-semantic-kind="[^"]+"[^>]*>/g)].map((match) => match[0]);
-  assert.equal(tags.length, CATALOGS.lifecycle.length);
-  const boxes = tags.map((tag) => ({
-    x: Number(attrValues(tag, 'data-legend-x')[0]),
-    y: Number(attrValues(tag, 'data-legend-baseline')[0]),
-    width: Number(attrValues(tag, 'data-legend-width')[0]),
-  }));
-  assert.ok(boxes.every((box) => Number.isFinite(box.x) && Number.isFinite(box.y) && Number.isFinite(box.width)));
-  assert.ok(boxes.every((box) => box.x >= 0 && box.x + box.width <= viewBox[2]));
-  const rows = new Map();
-  for (const box of boxes) rows.set(box.y, [...(rows.get(box.y) || []), box]);
-  for (const row of rows.values()) {
-    const sorted = [...row].sort((left, right) => left.x - right.x);
-    for (let index = 1; index < sorted.length; index += 1) {
-      assert.ok(sorted[index - 1].x + sorted[index - 1].width <= sorted[index].x);
-    }
-  }
-});
-
-process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));

package/template/.trae/skills/archify/test/motion-governor.test.mjs

@@ -1,111 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const skillRoot = path.resolve(__dirname, '..');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-motion-governor-'));
-
-const CASES = {
-  architecture: 'web-app.architecture.json',
-  workflow: 'agent-tool-call.workflow.json',
-  sequence: 'cache-miss-request.sequence.json',
-  dataflow: 'product-analytics.dataflow.json',
-  lifecycle: 'agent-run.lifecycle.json',
-};
-
-function render(mode, example, animation = 'trace') {
-  const doc = JSON.parse(fs.readFileSync(path.join(skillRoot, 'examples', example), 'utf8'));
-  doc.meta = { ...doc.meta };
-  if (animation) doc.meta.animation = animation;
-  else delete doc.meta.animation;
-  const input = path.join(tmp, `${mode}-${animation || 'static'}.json`);
-  const output = path.join(tmp, `${mode}-${animation || 'static'}.html`);
-  fs.writeFileSync(input, JSON.stringify(doc));
-  execFileSync('node', [path.join(skillRoot, `renderers/${mode}/render-${mode}.mjs`), input, output], {
-    stdio: ['ignore', 'ignore', 'pipe'],
-  });
-  return fs.readFileSync(output, 'utf8');
-}
-
-function svgBlock(html) {
-  return html.match(/<svg\b[\s\S]*?<\/svg>/)?.[0] || '';
-}
-
-test('all renderers inherit one viewer-only Live/Still Motion Governor', () => {
-  for (const [mode, example] of Object.entries(CASES)) {
-    const html = render(mode, example);
-    assert.match(html, /id="btn-motion"[^>]+hidden[^>]+aria-label="Pause motion"/, mode);
-    assert.match(html, /Archify\.motionGovernor = \(function \(\)/, mode);
-    assert.match(html, /var capable = !!\(svg && svg\.getAttribute\('data-animation'\) === 'trace'\)/, mode);
-    assert.match(svgBlock(html), /data-animation="trace"/, mode);
-    assert.doesNotMatch(svgBlock(html), /data-motion-(?:capable|owner)|motion-control/, mode);
-  }
-});
-
-test('static artifacts stay truly still while trace artifacts opt into ambient motion', () => {
-  const html = render('architecture', CASES.architecture, null);
-  const svg = svgBlock(html);
-  assert.doesNotMatch(svg, /data-animation=/);
-  assert.match(html, /\.pulse-dot \{[\s\S]*?animation: none;/);
-  assert.match(html, /html\[data-motion-capable="true"\] \.pulse-dot \{ animation: pulse 2s infinite; \}/);
-  assert.match(html, /html\[data-motion-capable="true"\]\[data-preset="signal-flow"\]\[data-ambient-motion="running"\] \.diagram-container::before/);
-  assert.match(html, /if \(!capable\) \{[\s\S]*?btn\.hidden = true;[\s\S]*?capable: false/);
-  assert.match(html, /html\.setAttribute\('data-motion-capable', 'true'\);[\s\S]*?btn\.hidden = false/);
-});
-
-test('reader pause is persistent, explicit, and reduced-motion aware', () => {
-  const html = render('workflow', CASES.workflow);
-  assert.match(html, /var STORAGE_KEY = 'archify-motion'/);
-  assert.match(html, /localStorage\.setItem\(STORAGE_KEY, 'still'\)/);
-  assert.match(html, /localStorage\.removeItem\(STORAGE_KEY\)/);
-  assert.match(html, /html\.setAttribute\('data-motion', paused \? 'still' : 'live'\)/);
-  assert.match(html, /btn\.setAttribute\('aria-pressed', paused \? 'false' : 'true'\)/);
-  assert.match(html, /Motion paused by reduced-motion preference/);
-  assert.match(html, /motionQuery\.addEventListener\('change', render\)/);
-  assert.match(html, /document\.addEventListener\('visibilitychange', syncVisibility\)/);
-  assert.match(html, /Archify\.guidedViews\.isPlaying\(\)[\s\S]*?Archify\.guidedViews\.pause\(\)/);
-  assert.match(html, /play\.disabled = !playing && !automaticPlaybackAllowed/);
-  assert.match(html, /Story playback unavailable while motion is Still/);
-  assert.match(html, /\.pulse-dot \{ animation: none !important; \}/);
-  assert.match(html, /html\[data-motion="still"\] \.story-trail-flow/);
-});
-
-test('strong semantic intent receives the single motion budget', () => {
-  const html = render('workflow', CASES.workflow);
-  assert.match(html, /if \(svg\.hasAttribute\('data-story-playing'\) \|\| svg\.hasAttribute\('data-story-follow'\)\) return 'story'/);
-  assert.match(html, /if \(svg\.hasAttribute\('data-story-active'\)\) return 'chapter'/);
-  assert.match(html, /data-route-picking'[\s\S]*?return 'route'/);
-  assert.match(html, /data-lens-active'\)\) return 'lens'/);
-  assert.match(html, /data-relationship-preview-active'\)\) return 'relationship'/);
-  assert.match(html, /data-intent-trace-active'\)\) return 'intent'/);
-  assert.match(html, /data-focus-active'\)\) return 'focus'/);
-  assert.match(html, /data-legend-preview-active'\)\) return 'legend'/);
-  assert.match(html, /new MutationObserver\(function \(\) \{ publishOwner\(\); \}\)/);
-  assert.match(html, /html\[data-motion-owner\] svg\[data-animation="trace"\] \[data-animate\]/);
-  assert.match(html, /function claim\(next, cleanup\)[\s\S]*?return ownerToken/);
-  assert.match(html, /function release\(token\)[\s\S]*?token !== ownerToken/);
-  assert.match(html, /function clearClaim\(preempted\)[\s\S]*?try \{ cleanup\(\); \} catch/);
-  assert.match(html, /function claim\(next, cleanup\)[\s\S]*?clearClaim\(true\)/);
-  assert.match(html, /animation: archify-route-probe-flow 1\.1s[\s\S]*?1 both/);
-  assert.doesNotMatch(html, /archify-route-probe-flow[^;]*infinite/);
-});
-
-test('motion control is mobile-contained, embed-safe, and export-neutral', () => {
-  const html = render('sequence', CASES.sequence);
-  assert.match(html, /\.toolbar #btn-motion\[hidden\] \{ display: none !important; \}/);
-  assert.match(html, /\.toolbar button \{[\s\S]*?min-height: 2\.75rem;/);
-  assert.match(html, /@media \(max-width: 360px\) \{[\s\S]*?\.toolbar #btn-motion \{ min-width: 4\.4rem;/);
-  assert.match(html, /#theme-label, #preset-label, #present-label \{ display: none; \}/);
-  assert.match(html, /html\[data-embed="true"\] \.diagram-container::before/);
-  assert.match(html, /html\[data-share-playback="true"\] \.diagram-container::before/);
-  assert.match(html, /Still also parks bounded[\s\S]*?viewer signals without discarding their static meaning/);
-  assert.match(html, /recordExportReceipt\('svg', blob, d\.canonicalStateClean\)/);
-  assert.doesNotMatch(svgBlock(html), /btn-motion|data-motion=|data-motion-owner/);
-});
-
-process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));

package/template/.trae/skills/archify/test/open-artifact.test.mjs

@@ -1,118 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-
-import { openArtifact, openLoopbackUrl } from '../bin/open-artifact.mjs';
-
-const target = path.resolve("/tmp/-复杂 path 'quoted'/diagram.html");
-
-test('open artifact: uses argument arrays without shell interpolation on every supported platform', () => {
-  const cases = [
-    {
-      platform: 'darwin',
-      command: 'open',
-      args: [target],
-      method: 'open',
-    },
-    {
-      platform: 'linux',
-      command: 'xdg-open',
-      args: [target],
-      method: 'xdg-open',
-    },
-    {
-      platform: 'win32',
-      command: 'powershell.exe',
-      args: [
-        '-NoProfile',
-        '-NonInteractive',
-        '-Command',
-        'Start-Process -FilePath $args[0]',
-        target,
-      ],
-      method: 'powershell',
-    },
-  ];
-
-  for (const expected of cases) {
-    let invocation;
-    const result = openArtifact(target, {
-      platform: expected.platform,
-      spawn(command, args, options) {
-        invocation = { command, args, options };
-        return { status: 0 };
-      },
-    });
-
-    assert.deepEqual(result, {
-      requested: true,
-      status: 'opened',
-      target,
-      method: expected.method,
-    });
-    assert.equal(invocation.command, expected.command);
-    assert.deepEqual(invocation.args, expected.args);
-    assert.equal(invocation.options.shell, false);
-    assert.equal(invocation.options.timeout, 5000);
-  }
-});
-
-test('open artifact: distinguishes missing support from opener execution failure', () => {
-  const missing = openArtifact(target, {
-    platform: 'linux',
-    spawn() {
-      return { error: Object.assign(new Error('missing'), { code: 'ENOENT' }) };
-    },
-  });
-  assert.equal(missing.status, 'unsupported');
-  assert.equal(missing.method, 'xdg-open');
-
-  const timedOut = openArtifact(target, {
-    platform: 'darwin',
-    spawn() {
-      return { error: Object.assign(new Error('timed out'), { code: 'ETIMEDOUT' }) };
-    },
-  });
-  assert.equal(timedOut.status, 'failed');
-  assert.equal(timedOut.method, 'open');
-
-  const unknown = openArtifact(target, { platform: 'plan9' });
-  assert.deepEqual(unknown, {
-    requested: true,
-    status: 'unsupported',
-    target,
-    method: null,
-  });
-});
-
-test('open artifact: live preview opens only an exact loopback HTTP root', () => {
-  const url = 'http://127.0.0.1:43127/';
-  let invocation;
-  const result = openLoopbackUrl(url, {
-    platform: 'darwin',
-    spawn(command, args, options) {
-      invocation = { command, args, options };
-      return { status: 0 };
-    },
-  });
-
-  assert.deepEqual(result, {
-    requested: true,
-    status: 'opened',
-    target: url,
-    method: 'open',
-  });
-  assert.deepEqual(invocation.args, [url]);
-  assert.equal(invocation.options.shell, false);
-
-  for (const rejected of [
-    'https://127.0.0.1:43127/',
-    'http://localhost:43127/',
-    'http://0.0.0.0:43127/',
-    'http://127.0.0.1:43127/path',
-    'http://127.0.0.1:43127/?source=secret',
-    'not a url',
-  ]) {
-    assert.throws(() => openLoopbackUrl(rejected), /loopback|valid/i, rejected);
-  }
-});