ptxiagram 0.1.0 → 0.3.0

package/README.md

@@ -1,40 +1,69 @@
 # ptxiagram
 
-**Generate architecture and workflow diagrams as native, editable PowerPoint shapes — not an embedded image.**
+**Generate architecture, workflow, and sequence diagrams as native, editable PowerPoint shapes — not an embedded image.**
+
+> Built with [Claude Code](https://claude.com/claude-code) (Claude Sonnet 5) — from the initial prototype through the pptxgenjs/Hancom Office compatibility investigation, the JSON schema design, the layout validator, and this package's release automation. See the [commit history](https://github.com/hiio420official/ptxiagram/commits/main) for the build process.
 
 ptxiagram is an agent skill for Claude (and a standalone CLI/library) that turns a plain-English description of a system or process into a `.pptx` slide built from real PowerPoint shapes: rectangles, cylinders, clouds, connectors, text boxes. Anyone can open the result in PowerPoint — or Hancom 한쇼 — and click a box to change its color, text, or position, because it *is* a box, not a picture of one.
 
 - **Native shapes, not a picture** — every box and arrow is a real PPTX shape, editable after generation
-- **Two diagram types today** — `workflow` (swimlanes, happy-path flows) and `architecture` (free-placed components, trust boundaries, hub-and-spoke)
+- **Five diagram types today** — `workflow` (swimlanes, happy-path flows), `architecture` (free-placed components, trust boundaries, hub-and-spoke), `sequence` (participants + lifelines, API call chains), `dataflow` (stage-to-stage pipelines with PII/lineage annotations), and `lifecycle` (state machines with terminal outcomes)
 - **A validator that catches real layout bugs before rendering** — node overlap, labels wider than their shape, and connectors that cut through an unrelated node all fail loudly with a specific fix, instead of shipping a broken-looking slide
 - **Ships a Hancom Office compatibility fix** — every generated file is post-processed to strip a documented PptxGenJS defect that PowerPoint silently repairs but Hancom's 한쇼 flags as a corrupted document (see below)
 - **Route presets instead of hand-computed coordinates** — `straight`, `drop`, `elbow-right`, `arc-over-top` cover swimlane transitions, hub-and-spoke fan-out, and routing around a boundary box
 
-## Install
+## Use it in an agent (Claude Code, Codex, Cursor, ...)
 
-As a Claude Skill:
+Install with the [`skills` CLI](https://github.com/vercel-labs/skills) — it detects every supported agent on your machine and wires the skill into each one:
 
 ```bash
 npx skills add hiio420official/ptxiagram -g
 ```
 
-As a CLI / library:
+Then just ask in chat:
 
-```bash
-npm install -g ptxiagram
-ptxiagram doctor
+```text
+Use ptxiagram to draw an architecture diagram for this repo's runtime,
+as a PPTX I can drop into a slide deck.
+```
+
+```text
+Use ptxiagram to make a workflow diagram of our incident response process,
+with a lane per team, so I can paste it into the postmortem deck.
+```
+
+```text
+Use ptxiagram to draw a sequence diagram of this API's cache-fallback path,
+from request to response, for the engineering review deck.
 ```
 
-## Quick start
+The agent reads `SKILL.md`, writes a small JSON file describing your nodes and
+edges, and runs the CLI to produce a `.pptx` with real, editable shapes.
+
+**Per-agent notes:**
+- **Claude Code**: works out of the box after `npx skills add`.
+- **Codex CLI / opencode**: install with an explicit `--agent` flag if you don't want it installed everywhere, e.g. `npx skills use hiio420official/ptxiagram@ptxiagram --agent codex`.
+- **Any other `skills`-supported agent** (Cursor, Windsurf, Continue, Antigravity, Gemini CLI, ...): the same `npx skills add` command installs to whichever of these are detected on your machine.
+
+## Use it standalone (CLI / library)
 
 ```bash
+npm install -g ptxiagram
+ptxiagram doctor
 ptxiagram render workflow examples/onboarding.workflow.json out.pptx
 ptxiagram check out.pptx
 ```
 
+Or as a library:
+
+```js
+import { renderWorkflow } from "ptxiagram";
+await renderWorkflow("my-diagram.workflow.json", "out.pptx");
+```
+
 `render` validates the input (schema + layout) before writing anything, and always repairs the output for Hancom Office compatibility. `check` confirms the repair took, dumps every embedded text run for a spelling/content spot-check, and — if LibreOffice is installed — writes a PNG preview for a quick visual check.
 
-See [`ptxiagram/SKILL.md`](ptxiagram/SKILL.md) for the full JSON shape of both diagram types, the node-type → shape/color mapping, and the route presets.
+See [`SKILL.md`](SKILL.md) for the full JSON shape of all five diagram types, the node-type → shape/color mapping, and the route presets.
 
 ## Why every file gets repaired
 

package/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: ptxiagram
-description: Create architecture and workflow diagrams as native, editable PowerPoint shapes (real rectangles, connectors, and text boxes a user can click and restyle in PowerPoint or Hancom 한쇼) instead of an embedded image. Accepts a plain-language description, turns it into a small JSON file, and renders it with pptxgenjs. Use when the user asks for a diagram, architecture drawing, or process flow that needs to end up inside a .pptx deck or a Korean-office-suite-compatible presentation - not when they just want a standalone image or an HTML/web diagram (use an SVG-based diagram tool for that instead).
+description: Create architecture, workflow, sequence, dataflow, and lifecycle diagrams as native, editable PowerPoint shapes (real rectangles, connectors, and text boxes a user can click and restyle in PowerPoint or Hancom 한쇼) instead of an embedded image. Accepts a plain-language description, turns it into a small JSON file, and renders it with pptxgenjs. Use when the user asks for a diagram, architecture drawing, process flow, API call sequence, data pipeline, or state machine that needs to end up inside a .pptx deck or a Korean-office-suite-compatible presentation - not when they just want a standalone image or an HTML/web diagram (use an SVG-based diagram tool for that instead).
 license: MIT
 metadata:
-  version: "0.1.0"
+  version: "0.3.0"
   status: prototype
   based_on: "gitbrent/PptxGenJS (MIT)"
 ---
@@ -51,6 +51,9 @@ validation and the embedded-text dump, just no rendered preview image).
 |------|---------|--------|
 | `workflow` | Cross-team processes, approval chains, anything with swimlanes and a happy path | `schemas/workflow.schema.json` |
 | `architecture` | System components, services, datastores, trust boundaries, hub-and-spoke integrations | `schemas/architecture.schema.json` |
+| `sequence` | API call chains, request/response traces, cache-fallback flows — up to 6 participants, up to 9 messages | `schemas/sequence.schema.json` |
+| `dataflow` | Data pipelines, ETL/ELT, PII/lineage annotations, stage-to-stage flows | `schemas/dataflow.schema.json` |
+| `lifecycle` | State machines, status transitions, terminal outcomes (same JSON shape as `workflow`) | `schemas/lifecycle.schema.json` |
 
 ## The loop
 
@@ -58,6 +61,9 @@ validation and the embedded-text dump, just no rendered preview image).
    shape, don't guess the field names:
    - `examples/onboarding.workflow.json`
    - `examples/order-processing.architecture.json`
+   - `examples/cache-miss.sequence.json`
+   - `examples/product-analytics.dataflow.json`
+   - `examples/agent-run.lifecycle.json`
 2. Write `<name>.<type>.json`.
 3. Render:
    ```bash
@@ -127,12 +133,83 @@ order. Default node size is 1.8×0.95in.
 `boundaries[].wraps` takes component ids, not coordinates — the renderer
 computes a padded frame around them, so never hand-compute a boundary box.
 
+## Sequence JSON shape
+
+```json
+{
+  "schema_version": 1,
+  "diagram_type": "sequence",
+  "meta": { "title": "...", "output": "out.pptx" },
+  "participants": [
+    { "id": "api", "type": "backend", "label": "API", "sublabel": "handler" }
+  ],
+  "messages": [
+    { "from": "client", "to": "api", "label": "GET /orders/123", "variant": "emphasis" }
+  ],
+  "cards": []
+}
+```
+
+**Layout budget**: up to 6 participants in a row (auto-spaced, 2.2in apart),
+each with a vertical dashed lifeline. Messages are drawn in JSON array order
+at auto-incrementing y positions (0.55in apart) — order matters, there's no
+explicit `y` field. Up to 9 messages without `cards`, ~6 with (cards need
+room at the bottom, so the lifeline gets shorter). Self-messages (same
+`from`/`to`) aren't supported yet.
+
+## Dataflow JSON shape
+
+```json
+{
+  "schema_version": 1,
+  "diagram_type": "dataflow",
+  "meta": { "title": "...", "output": "out.pptx" },
+  "stages": [{ "label": "Sources" }, { "label": "Ingest" }],
+  "nodes": [
+    { "id": "web", "type": "frontend", "label": "웹 앱", "stage": 0, "row": 0 }
+  ],
+  "flows": [
+    { "from": "web", "to": "queue", "label": "이벤트 전송", "classification": "PII touch", "variant": "security" }
+  ],
+  "cards": []
+}
+```
+
+**Layout budget**: up to 5 stages (columns, 2.6in apart) x 5 rows (fixed y
+positions). `flow.label` is required; `classification` is optional
+free-text rendered in parentheses after the label (e.g. "PII touch",
+"non-PII", "approved only") for sensitivity/lineage annotations. Route is
+picked automatically — `straight` when both ends share a row, `elbow-right`
+otherwise — so flows don't take a `route` field.
+
+## Lifecycle JSON shape
+
+Structurally identical to the workflow schema (same `lanes`/`nodes`/`edges`
+shape, same layout budget) — only `diagram_type` differs. Convention: a
+`main` lane for the happy-path states and a `terminal` lane for end states.
+
+```json
+{
+  "schema_version": 1,
+  "diagram_type": "lifecycle",
+  "meta": { "title": "...", "output": "out.pptx" },
+  "lanes": [{ "id": "main", "label": "실행 단계" }, { "id": "terminal", "label": "종료 결과" }],
+  "nodes": [
+    { "id": "queued", "lane": "main", "col": 0, "type": "neutral", "label": "대기 중" },
+    { "id": "completed", "lane": "terminal", "col": 3, "type": "success", "label": "완료" }
+  ],
+  "edges": [{ "from": "queued", "to": "completed", "variant": "emphasis", "route": "drop" }]
+}
+```
+
 ## Node types
 
 `client` `frontend` `neutral` `backend` `database` `cache` `queue`
-`external` `security` `decision` — each maps to a shape preset (ellipse,
-rect, roundRect, can/cylinder, hexagon, cube, cloud, diamond) and a color
-pair. Pick by role, not by desired color.
+`external` `security` `decision` `active` `waiting` `success` `failure` —
+each maps to a shape preset (ellipse, rect, roundRect, can/cylinder,
+hexagon, cube, cloud, diamond) and a color pair. The last four
+(`active`/`waiting`/`success`/`failure`) exist for `lifecycle` states;
+pick by role, not by desired color.
 
 ## Route presets
 
@@ -169,7 +246,11 @@ this automatically; `check` verifies it actually happened. Source:
 
 ## What's not built yet
 
-- `sequence`, `dataflow`, `lifecycle` diagram types (only `workflow` and
-  `architecture` exist so far)
 - No CJK exact-metrics font measurement — the label-width check is a
   conservative estimate, not real glyph widths
+- Sequence self-messages (a participant messaging itself)
+- No label-vs-label collision detection — two edges converging on the same
+  node from different rows can still end up with close (though no longer
+  overlapping, after the `elbow-right` label-anchor fix) labels in a busy
+  diagram; the validator catches label-vs-*shape* and edge-vs-*node*
+  collisions, not label-vs-label

package/bin/cli.mjs

@@ -7,11 +7,20 @@ import { promisify } from "node:util";
 import JSZip from "jszip";
 import { renderWorkflow } from "../renderers/workflow/render-workflow.mjs";
 import { renderArchitecture } from "../renderers/architecture/render-architecture.mjs";
+import { renderSequence } from "../renderers/sequence/render-sequence.mjs";
+import { renderDataflow } from "../renderers/dataflow/render-dataflow.mjs";
+import { renderLifecycle } from "../renderers/lifecycle/render-lifecycle.mjs";
 import { validateAll } from "../lib/validate.mjs";
 
 const execFileAsync = promisify(execFile);
 
-const RENDERERS = { workflow: renderWorkflow, architecture: renderArchitecture };
+const RENDERERS = {
+  workflow: renderWorkflow,
+  architecture: renderArchitecture,
+  sequence: renderSequence,
+  dataflow: renderDataflow,
+  lifecycle: renderLifecycle,
+};
 
 function usage() {
   console.log(`Usage:
@@ -20,7 +29,7 @@ function usage() {
   cli check <output.pptx>
   cli doctor
 
-Types: workflow, architecture`);
+Types: workflow, architecture, sequence, dataflow, lifecycle`);
 }
 
 async function cmdRender(type, inputPath, outputPath) {

package/examples/agent-run.lifecycle.json

@@ -0,0 +1,26 @@
+{
+  "schema_version": 1,
+  "diagram_type": "lifecycle",
+  "meta": {
+    "title": "에이전트 실행 라이프사이클",
+    "subtitle": "상태와 종료 결과",
+    "output": "test/output/agent-run.schema-driven.pptx"
+  },
+  "lanes": [
+    { "id": "main", "label": "실행 단계" },
+    { "id": "terminal", "label": "종료 결과" }
+  ],
+  "nodes": [
+    { "id": "queued", "lane": "main", "col": 0, "type": "neutral", "label": "대기 중", "sublabel": "큐에 등록됨" },
+    { "id": "running", "lane": "main", "col": 1, "type": "active", "label": "실행 중", "sublabel": "작업 처리" },
+    { "id": "reviewing", "lane": "main", "col": 3, "type": "waiting", "label": "승인 대기", "sublabel": "휴먼 리뷰" },
+    { "id": "completed", "lane": "terminal", "col": 3, "type": "success", "label": "완료" },
+    { "id": "failed", "lane": "terminal", "col": 5, "type": "failure", "label": "실패", "sublabel": "재시도 필요" }
+  ],
+  "edges": [
+    { "from": "queued", "to": "running", "variant": "default", "route": "straight" },
+    { "from": "running", "to": "reviewing", "variant": "default", "route": "straight" },
+    { "from": "reviewing", "to": "completed", "variant": "emphasis", "route": "drop", "label": "승인" },
+    { "from": "reviewing", "to": "failed", "variant": "security", "route": "drop", "label": "반려" }
+  ]
+}

package/examples/cache-miss.sequence.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "diagram_type": "sequence",
+  "meta": {
+    "title": "캐시 미스 요청 흐름",
+    "subtitle": "Client → API → Cache → DB",
+    "output": "test/output/cache-miss.schema-driven.pptx"
+  },
+  "participants": [
+    { "id": "client", "type": "client", "label": "Client", "sublabel": "브라우저" },
+    { "id": "api", "type": "backend", "label": "API", "sublabel": "handler" },
+    { "id": "cache", "type": "cache", "label": "Cache", "sublabel": "Redis" },
+    { "id": "db", "type": "database", "label": "DB", "sublabel": "PostgreSQL" }
+  ],
+  "messages": [
+    { "from": "client", "to": "api", "label": "GET /orders/123", "variant": "emphasis" },
+    { "from": "api", "to": "cache", "label": "조회", "variant": "default" },
+    { "from": "cache", "to": "api", "label": "캐시 미스", "variant": "dashed" },
+    { "from": "api", "to": "db", "label": "쿼리 실행", "variant": "emphasis" },
+    { "from": "db", "to": "api", "label": "결과 반환", "variant": "dashed" },
+    { "from": "api", "to": "client", "label": "200 OK", "variant": "emphasis" }
+  ]
+}

package/examples/product-analytics.dataflow.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "diagram_type": "dataflow",
+  "meta": {
+    "title": "제품 분석 데이터 파이프라인",
+    "subtitle": "이벤트 수집 → 적재 → 소비",
+    "output": "test/output/product-analytics.schema-driven.pptx"
+  },
+  "stages": [
+    { "label": "Sources" },
+    { "label": "Ingest" },
+    { "label": "Store" },
+    { "label": "Consumers" }
+  ],
+  "nodes": [
+    { "id": "web", "type": "frontend", "label": "웹 앱", "sublabel": "clickstream", "stage": 0, "row": 0 },
+    { "id": "mobile", "type": "frontend", "label": "모바일 앱", "sublabel": "clickstream", "stage": 0, "row": 1 },
+    { "id": "queue", "type": "queue", "label": "이벤트 큐", "sublabel": "Kafka", "stage": 1, "row": 0 },
+    { "id": "warehouse", "type": "database", "label": "데이터 웨어하우스", "sublabel": "BigQuery", "stage": 2, "row": 0 },
+    { "id": "dashboard", "type": "external", "label": "대시보드", "sublabel": "내부 분석팀", "stage": 3, "row": 0 },
+    { "id": "ml", "type": "external", "label": "추천 모델", "sublabel": "배치 학습", "stage": 3, "row": 1 }
+  ],
+  "flows": [
+    { "from": "web", "to": "queue", "label": "이벤트 전송", "classification": "PII touch", "variant": "security" },
+    { "from": "mobile", "to": "queue", "label": "이벤트 전송", "classification": "PII touch", "variant": "security" },
+    { "from": "queue", "to": "warehouse", "label": "적재", "classification": "approved only", "variant": "default" },
+    { "from": "warehouse", "to": "dashboard", "label": "집계 쿼리", "classification": "non-PII", "variant": "default" },
+    { "from": "warehouse", "to": "ml", "label": "피처 추출", "classification": "non-PII", "variant": "dashed" }
+  ]
+}

package/index.mjs

@@ -1,4 +1,14 @@
 export { renderWorkflow } from "./renderers/workflow/render-workflow.mjs";
 export { renderArchitecture } from "./renderers/architecture/render-architecture.mjs";
-export { validateAll, validateSchema, validateWorkflowLayout, validateArchitectureLayout } from "./lib/validate.mjs";
+export { renderSequence } from "./renderers/sequence/render-sequence.mjs";
+export { renderDataflow } from "./renderers/dataflow/render-dataflow.mjs";
+export { renderLifecycle } from "./renderers/lifecycle/render-lifecycle.mjs";
+export {
+  validateAll,
+  validateSchema,
+  validateWorkflowLayout,
+  validateArchitectureLayout,
+  validateSequenceLayout,
+  validateDataflowLayout,
+} from "./lib/validate.mjs";
 export { repairPptx } from "./lib/repair-pptx.mjs";

package/lib/layout.mjs

@@ -47,6 +47,56 @@ export function computeWorkflowLayout(raw) {
   return { laneBoxes, nodeBoxes, nodeMeta, cardsY };
 }
 
+export const SEQUENCE_LAYOUT = {
+  X0: 0.7, GAP: 2.2, BOX_W: 1.5, BOX_H: 0.7,
+  TOP_Y: 1.1, LIFELINE_BOTTOM: 7.0,
+  MSG_START_Y: 2.3, MSG_STEP: 0.55,
+};
+
+export function computeSequenceLayout(raw) {
+  const L = SEQUENCE_LAYOUT;
+  const participantBoxes = {};
+  const centerX = {};
+  raw.participants.forEach((p, i) => {
+    const x = L.X0 + i * L.GAP;
+    participantBoxes[p.id] = { x, y: L.TOP_Y, w: L.BOX_W, h: L.BOX_H };
+    centerX[p.id] = x + L.BOX_W / 2;
+  });
+  const messageYs = raw.messages.map((_, i) => L.MSG_START_Y + i * L.MSG_STEP);
+  // cards need ~1.75in of vertical room, so diagrams that use them get a
+  // shorter lifeline (fewer messages fit) instead of overflowing the slide
+  const lifelineBottom = raw.cards && raw.cards.length ? 5.3 : L.LIFELINE_BOTTOM;
+  const cardsY = lifelineBottom + 0.15;
+  return { participantBoxes, centerX, messageYs, lifelineBottom, cardsY };
+}
+
+export const DATAFLOW_LAYOUT = {
+  STAGE_X0: 1.7, STAGE_GAP: 2.6,
+  ROW_Y: [1.3, 2.5, 3.7, 4.9, 6.1],
+  NODE_W: 1.6, NODE_H: 0.85,
+  STAGE_LABEL_Y: 0.95,
+};
+
+// Shared by the dataflow renderer and validator so route selection can
+// never drift between what's drawn and what's checked.
+export function sameRow(a, b) {
+  return Math.abs(a.y - b.y) < 0.05;
+}
+
+export function computeDataflowLayout(raw) {
+  const L = DATAFLOW_LAYOUT;
+  const stageCenterX = raw.stages.map((_, i) => L.STAGE_X0 + i * L.STAGE_GAP);
+  const nodeBoxes = {};
+  for (const n of raw.nodes) {
+    const cx = stageCenterX[n.stage];
+    if (cx === undefined) throw new Error(`Node "${n.id}" references unknown stage index ${n.stage}`);
+    const y = L.ROW_Y[n.row];
+    if (y === undefined) throw new Error(`Node "${n.id}" references unknown row index ${n.row}`);
+    nodeBoxes[n.id] = { x: cx - L.NODE_W / 2, y, w: L.NODE_W, h: L.NODE_H };
+  }
+  return { nodeBoxes, stageCenterX };
+}
+
 const BOUNDARY_PAD = 0.3;
 
 export function computeArchitectureLayout(raw) {

package/lib/routes.mjs

@@ -65,7 +65,10 @@ export function computeSegments(from, to, opts = {}) {
         { ...boxFromPoints({ x: midX, y: Math.min(a.y, b.y) }, { x: midX, y: Math.max(a.y, b.y) }), arrow: false },
         { ...boxFromPoints({ x: midX, y: b.y }, b), arrow: true },
       ],
-      labelAnchor: label ? { x: midX - 0.6, y: b.y, w: 1.2 } : null,
+      // anchored at the jog's own midpoint (like "drop" does), not at
+      // either endpoint's row -- otherwise this collides with a sibling
+      // "straight" edge whose label sits right at the target's row
+      labelAnchor: label ? { x: midX - 0.6, y: (a.y + b.y) / 2, w: 1.2 } : null,
     };
   }
 
@@ -110,3 +113,19 @@ export function connector(slide, from, to, opts = {}) {
     });
   }
 }
+
+/** Draws a single point-to-point arrow at an explicit y (sequence
+ * messages, self-loops) instead of anchoring to node box sides. Direction
+ * matters: the arrowhead lands at (x2,y). opts: { color, dashed, label } */
+export function drawArrow(slide, { x1, x2, y, color = "94A3B8", dashed = false, label }) {
+  slide.addShape("line", {
+    x: Math.min(x1, x2), y, w: Math.abs(x2 - x1), h: 0,
+    line: { color, width: 2, dashType: dashed ? "dash" : "solid", endArrowType: "triangle" },
+  });
+  if (label) {
+    slide.addText(label, {
+      x: Math.min(x1, x2), y: y - 0.26, w: Math.abs(x2 - x1), h: 0.24,
+      align: "center", fontFace: FONT, fontSize: 8.5, color: "475569",
+    });
+  }
+}

package/lib/shapes.mjs

@@ -12,6 +12,11 @@ export const NODE_TYPES = {
   external: { shape: "cloud", fill: "FEF3C7", stroke: "F59E0B" },
   security: { shape: "roundRect", fill: "FFE4E6", stroke: "F43F5E" },
   decision: { shape: "diamond", fill: "FFE4E6", stroke: "F43F5E" },
+  // lifecycle-diagram states
+  active: { shape: "roundRect", fill: "DBEAFE", stroke: "3B82F6" },
+  waiting: { shape: "roundRect", fill: "FEF3C7", stroke: "F59E0B" },
+  success: { shape: "roundRect", fill: "D1FAE5", stroke: "10B981" },
+  failure: { shape: "roundRect", fill: "FFE4E6", stroke: "F43F5E" },
 };
 
 export const FONT = "맑은 고딕";
@@ -92,6 +97,15 @@ export function drawCards(slide, cards, y) {
   });
 }
 
+// Draws a participant's vertical lifeline (a sequence-diagram convention:
+// a thin dashed reference line a participant's messages attach to).
+export function drawLifeline(slide, { x, fromY, toY }) {
+  slide.addShape("line", {
+    x, y: fromY, w: 0, h: toY - fromY,
+    line: { color: "CBD5E1", width: 1, dashType: "dash" },
+  });
+}
+
 // Draws a swimlane frame with a title strip. Returns the lane's box.
 export function drawLane(slide, { x, y, w, h, label }) {
   slide.addShape("rect", {

package/lib/validate.mjs

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import Ajv2020 from "ajv/dist/2020.js";
-import { computeWorkflowLayout, computeArchitectureLayout, SLIDE_W, SLIDE_H } from "./layout.mjs";
+import { computeWorkflowLayout, computeArchitectureLayout, computeSequenceLayout, computeDataflowLayout, sameRow, SLIDE_W, SLIDE_H } from "./layout.mjs";
 import { computeSegments } from "./routes.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -64,7 +64,7 @@ function offSlide(box) {
   return box.x < 0 || box.y < 0 || box.x + box.w > SLIDE_W || box.y + box.h > SLIDE_H;
 }
 
-function checkCommon({ problems, ids, boxes, labelOf, fontSizePt, edgesOrConns, resolveEndpoints, edgeLabel }) {
+function checkCommon({ problems, ids, boxes, labelOf, fontSizePt, edgesOrConns, resolveEndpoints, edgeLabel, resolveRoute = (e) => e.route || "straight" }) {
   for (const id of ids) {
     const box = boxes[id];
     const label = labelOf(id);
@@ -89,7 +89,7 @@ function checkCommon({ problems, ids, boxes, labelOf, fontSizePt, edgesOrConns,
     const { from, to } = resolveEndpoints(e);
     if (!from || !to) continue; // unknown-id errors surface from the renderer/schema instead
     const { segments } = computeSegments(from, to, {
-      route: e.route || "straight", bias: e.bias, clearY: e.clearY, label: e.label,
+      route: resolveRoute(e, from, to), bias: e.bias, clearY: e.clearY, label: e.label,
     });
     for (const id of ids) {
       if (id === e.from || id === e.to) continue;
@@ -133,11 +133,68 @@ export function validateArchitectureLayout(raw) {
   });
 }
 
+export function validateDataflowLayout(raw) {
+  const { nodeBoxes } = computeDataflowLayout(raw);
+  const labelOf = (id) => raw.nodes.find((n) => n.id === id).label;
+  return checkCommon({
+    problems: [],
+    ids: Object.keys(nodeBoxes),
+    boxes: nodeBoxes,
+    labelOf,
+    fontSizePt: 12.5,
+    edgesOrConns: raw.flows,
+    resolveEndpoints: (f) => ({ from: nodeBoxes[f.from], to: nodeBoxes[f.to] }),
+    edgeLabel: (f) => `Flow "${f.from}"->"${f.to}"`,
+    resolveRoute: (f, from, to) => (from && to && sameRow(from, to) ? "straight" : "elbow-right"),
+  });
+}
+
+export function validateSequenceLayout(raw) {
+  const problems = [];
+  const { participantBoxes, messageYs, lifelineBottom } = computeSequenceLayout(raw);
+  const ids = Object.keys(participantBoxes);
+
+  for (const p of raw.participants) {
+    const box = participantBoxes[p.id];
+    const w = estimateTextWidth(p.label, 12.5);
+    if (w > box.w - 0.1) {
+      problems.push(`Participant "${p.id}" label "${p.label}" (~${w.toFixed(2)}in) is wider than its shape (${box.w.toFixed(2)}in) — shorten the label or move detail to sublabel.`);
+    }
+    if (offSlide(box)) {
+      problems.push(`Participant "${p.id}" is off-slide (slide is ${SLIDE_W}x${SLIDE_H}in).`);
+    }
+  }
+
+  for (let i = 0; i < ids.length; i++) {
+    for (let j = i + 1; j < ids.length; j++) {
+      if (rectsOverlap(participantBoxes[ids[i]], participantBoxes[ids[j]])) {
+        problems.push(`Participants "${ids[i]}" and "${ids[j]}" overlap.`);
+      }
+    }
+  }
+
+  raw.messages.forEach((m, i) => {
+    if (m.from === m.to) {
+      problems.push(`Message ${i} ("${m.label}") has the same participant "${m.from}" as from and to — self-messages aren't supported yet.`);
+    }
+    if (!participantBoxes[m.from]) problems.push(`Message ${i} references unknown participant "${m.from}".`);
+    if (!participantBoxes[m.to]) problems.push(`Message ${i} references unknown participant "${m.to}".`);
+    if (messageYs[i] > lifelineBottom - 0.3) {
+      problems.push(`Message ${i} ("${m.label}") falls below the lifeline (too many messages for the available space) — split into fewer messages or drop the cards to free up room.`);
+    }
+  });
+
+  return problems;
+}
+
 /** Runs schema validation, then layout collision checks. Returns the list
  * of layout problems (empty = clean); throws if schema validation fails. */
 export async function validateAll(type, raw) {
   await validateSchema(type, raw);
   if (type === "workflow") return validateWorkflowLayout(raw);
+  if (type === "lifecycle") return validateWorkflowLayout(raw); // same JSON shape as workflow
   if (type === "architecture") return validateArchitectureLayout(raw);
+  if (type === "sequence") return validateSequenceLayout(raw);
+  if (type === "dataflow") return validateDataflowLayout(raw);
   throw new Error(`Unknown diagram type: ${type}`);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ptxiagram",
-  "version": "0.1.0",
-  "description": "Generate native, editable PowerPoint (PPTX) architecture and workflow diagrams from a small JSON file — real shapes and connectors, not an embedded image. Ships with a Claude Skill (SKILL.md) and a CLI.",
+  "version": "0.3.0",
+  "description": "Generate native, editable PowerPoint (PPTX) architecture, workflow, sequence, dataflow, and lifecycle diagrams from a small JSON file — real shapes and connectors, not an embedded image. Ships with a Claude Skill (SKILL.md) and a CLI.",
   "type": "module",
   "main": "index.mjs",
   "bin": {
@@ -18,7 +18,7 @@
   ],
   "scripts": {
     "doctor": "node bin/cli.mjs doctor",
-    "test": "node test/render-workflow.test.mjs && node test/render-architecture.test.mjs && node test/validate.test.mjs && node test/workflow-lib-smoke.test.mjs"
+    "test": "node test/render-workflow.test.mjs && node test/render-architecture.test.mjs && node test/render-sequence.test.mjs && node test/render-dataflow.test.mjs && node test/render-lifecycle.test.mjs && node test/validate.test.mjs && node test/workflow-lib-smoke.test.mjs"
   },
   "keywords": [
     "pptx",
@@ -27,6 +27,9 @@
     "claude-skill",
     "architecture-diagram",
     "workflow-diagram",
+    "sequence-diagram",
+    "dataflow-diagram",
+    "lifecycle-diagram",
     "hancom",
     "hanshow",
     "office-automation"

package/renderers/architecture/render-architecture.mjs

@@ -1,5 +1,6 @@
 import pptxgen from "pptxgenjs";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { drawNode, drawBoundary, drawCards, FONT, EDGE_VARIANTS } from "../../lib/shapes.mjs";
 import { connector } from "../../lib/routes.mjs";
 import { repairPptx } from "../../lib/repair-pptx.mjs";
@@ -62,6 +63,7 @@ export async function renderArchitecture(inputPath, outputPath) {
   });
 
   const outFile = outputPath || raw.meta.output || "output.pptx";
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
   await pptx.writeFile({ fileName: outFile });
   await repairPptx(outFile);
   return outFile;

package/renderers/dataflow/render-dataflow.mjs

@@ -0,0 +1,73 @@
+import pptxgen from "pptxgenjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { drawNode, drawCards, FONT, EDGE_VARIANTS } from "../../lib/shapes.mjs";
+import { connector } from "../../lib/routes.mjs";
+import { repairPptx } from "../../lib/repair-pptx.mjs";
+import { validateSchema, validateDataflowLayout } from "../../lib/validate.mjs";
+import { computeDataflowLayout, DATAFLOW_LAYOUT, sameRow } from "../../lib/layout.mjs";
+
+export async function renderDataflow(inputPath, outputPath) {
+  const raw = JSON.parse(await fs.readFile(inputPath, "utf8"));
+  await validateSchema("dataflow", raw);
+
+  const { nodeBoxes, stageCenterX } = computeDataflowLayout(raw);
+  const problems = validateDataflowLayout(raw);
+  if (problems.length) {
+    throw new Error(`Dataflow layout validation failed:\n- ${problems.join("\n- ")}`);
+  }
+
+  const pptx = new pptxgen();
+  pptx.defineLayout({ name: "WIDE", width: 13.33, height: 7.5 });
+  pptx.layout = "WIDE";
+  const slide = pptx.addSlide();
+
+  slide.addText(raw.meta.title, {
+    x: 0.4, y: 0.2, w: 12.5, h: 0.5,
+    fontFace: FONT, fontSize: 20, bold: true, color: "0F172A",
+  });
+  if (raw.meta.subtitle) {
+    slide.addText(raw.meta.subtitle, {
+      x: 0.4, y: 0.65, w: 12.5, h: 0.3,
+      fontFace: FONT, fontSize: 11, color: "64748B",
+    });
+  }
+
+  raw.stages.forEach((s, i) => {
+    slide.addText(s.label, {
+      x: stageCenterX[i] - 1.0, y: DATAFLOW_LAYOUT.STAGE_LABEL_Y, w: 2.0, h: 0.3,
+      align: "center", fontFace: FONT, fontSize: 11, bold: true, color: "64748B",
+    });
+  });
+
+  for (const n of raw.nodes) {
+    drawNode(slide, { ...nodeBoxes[n.id], label: n.label, sublabel: n.sublabel, type: n.type, tag: n.tag });
+  }
+
+  for (const f of raw.flows) {
+    const variant = EDGE_VARIANTS[f.variant || "default"];
+    const from = nodeBoxes[f.from], to = nodeBoxes[f.to];
+    if (!from) throw new Error(`Flow references unknown node "${f.from}"`);
+    if (!to) throw new Error(`Flow references unknown node "${f.to}"`);
+    const label = f.classification ? `${f.label} (${f.classification})` : f.label;
+    connector(slide, from, to, {
+      color: variant.color, dashed: variant.dashed, label,
+      route: sameRow(from, to) ? "straight" : "elbow-right",
+    });
+  }
+
+  if (raw.cards && raw.cards.length) {
+    drawCards(slide, raw.cards, 6.5);
+  }
+
+  slide.addText("Made with a Claude Skill · native PPTX shapes, editable in PowerPoint", {
+    x: 0.4, y: 7.15, w: 12.5, h: 0.3,
+    fontFace: FONT, fontSize: 8, color: "94A3B8", italic: true,
+  });
+
+  const outFile = outputPath || raw.meta.output || "output.pptx";
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
+  await pptx.writeFile({ fileName: outFile });
+  await repairPptx(outFile);
+  return outFile;
+}

package/renderers/lifecycle/render-lifecycle.mjs

@@ -0,0 +1,10 @@
+import { renderWorkflow } from "../workflow/render-workflow.mjs";
+
+// lifecycle.schema.json is structurally identical to workflow.schema.json
+// (lanes/nodes/edges, same layout budget) -- it only differs in its
+// diagram_type const and typical usage (states + terminal outcomes instead
+// of process steps), so it reuses the workflow renderer wholesale rather
+// than duplicating the same ~70 lines under a different file name.
+export async function renderLifecycle(inputPath, outputPath) {
+  return renderWorkflow(inputPath, outputPath, "lifecycle");
+}

package/renderers/sequence/render-sequence.mjs

@@ -0,0 +1,67 @@
+import pptxgen from "pptxgenjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { drawNode, drawLifeline, drawCards, FONT, EDGE_VARIANTS } from "../../lib/shapes.mjs";
+import { drawArrow } from "../../lib/routes.mjs";
+import { repairPptx } from "../../lib/repair-pptx.mjs";
+import { validateSchema, validateSequenceLayout } from "../../lib/validate.mjs";
+import { computeSequenceLayout } from "../../lib/layout.mjs";
+
+export async function renderSequence(inputPath, outputPath) {
+  const raw = JSON.parse(await fs.readFile(inputPath, "utf8"));
+  await validateSchema("sequence", raw);
+
+  const { participantBoxes, centerX, messageYs, lifelineBottom, cardsY } = computeSequenceLayout(raw);
+  const problems = validateSequenceLayout(raw);
+  if (problems.length) {
+    throw new Error(`Sequence layout validation failed:\n- ${problems.join("\n- ")}`);
+  }
+
+  const pptx = new pptxgen();
+  pptx.defineLayout({ name: "WIDE", width: 13.33, height: 7.5 });
+  pptx.layout = "WIDE";
+  const slide = pptx.addSlide();
+
+  slide.addText(raw.meta.title, {
+    x: 0.4, y: 0.2, w: 12.5, h: 0.5,
+    fontFace: FONT, fontSize: 20, bold: true, color: "0F172A",
+  });
+  if (raw.meta.subtitle) {
+    slide.addText(raw.meta.subtitle, {
+      x: 0.4, y: 0.65, w: 12.5, h: 0.3,
+      fontFace: FONT, fontSize: 11, color: "64748B",
+    });
+  }
+
+  for (const p of raw.participants) {
+    drawNode(slide, { ...participantBoxes[p.id], label: p.label, sublabel: p.sublabel, type: p.type });
+    drawLifeline(slide, {
+      x: centerX[p.id],
+      fromY: participantBoxes[p.id].y + participantBoxes[p.id].h,
+      toY: lifelineBottom,
+    });
+  }
+
+  raw.messages.forEach((m, i) => {
+    const variant = EDGE_VARIANTS[m.variant || "default"];
+    drawArrow(slide, {
+      x1: centerX[m.from], x2: centerX[m.to], y: messageYs[i],
+      color: variant.color, dashed: variant.dashed, label: m.label,
+    });
+  });
+
+  if (raw.cards && raw.cards.length) {
+    drawCards(slide, raw.cards, cardsY);
+  }
+
+  slide.addText("Made with a Claude Skill · native PPTX shapes, editable in PowerPoint", {
+    x: 0.4, y: 7.15, w: 12.5, h: 0.3,
+    fontFace: FONT, fontSize: 8, color: "94A3B8", italic: true,
+  });
+
+  const outFile = outputPath || raw.meta.output || "output.pptx";
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
+  await pptx.writeFile({ fileName: outFile });
+  await repairPptx(outFile);
+  return outFile;
+}

package/renderers/workflow/render-workflow.mjs

@@ -1,14 +1,20 @@
 import pptxgen from "pptxgenjs";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { drawNode, drawLane, drawCards, FONT, EDGE_VARIANTS } from "../../lib/shapes.mjs";
 import { connector } from "../../lib/routes.mjs";
 import { repairPptx } from "../../lib/repair-pptx.mjs";
 import { validateSchema, validateWorkflowLayout } from "../../lib/validate.mjs";
 import { computeWorkflowLayout } from "../../lib/layout.mjs";
 
-export async function renderWorkflow(inputPath, outputPath) {
+// `schemaType` lets renderLifecycle (schemas/lifecycle.schema.json) reuse
+// this renderer as-is: lifecycle JSON is structurally identical to
+// workflow's (lanes/nodes/edges), it just validates against its own
+// diagram_type const and typically uses the start/active/waiting/
+// success/failure node types instead of workflow's process-step ones.
+export async function renderWorkflow(inputPath, outputPath, schemaType = "workflow") {
   const raw = JSON.parse(await fs.readFile(inputPath, "utf8"));
-  await validateSchema("workflow", raw);
+  await validateSchema(schemaType, raw);
 
   const { laneBoxes, nodeBoxes, cardsY } = computeWorkflowLayout(raw);
   const problems = validateWorkflowLayout(raw);
@@ -61,6 +67,7 @@ export async function renderWorkflow(inputPath, outputPath) {
   });
 
   const outFile = outputPath || raw.meta.output || "output.pptx";
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
   await pptx.writeFile({ fileName: outFile });
   await repairPptx(outFile);
   return outFile;

package/schemas/common.schema.json

@@ -15,7 +15,7 @@
       "maxItems": 2
     },
     "nodeType": {
-      "enum": ["client", "frontend", "neutral", "backend", "database", "cache", "queue", "external", "security", "decision"]
+      "enum": ["client", "frontend", "neutral", "backend", "database", "cache", "queue", "external", "security", "decision", "active", "waiting", "success", "failure"]
     },
     "route": {
       "enum": ["straight", "drop", "elbow-right", "arc-over-top"]

package/schemas/dataflow.schema.json

@@ -0,0 +1,80 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://claude-skills/pptx-diagram/schemas/dataflow.schema.json",
+  "title": "Native PPTX Dataflow Diagram",
+  "description": "Nodes sit in a stage (column, left-to-right) x row (0-4) grid. Flows carry a mandatory label plus an optional classification (e.g. 'PII touch', 'non-PII') for sensitivity/lineage annotations.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "diagram_type", "meta", "stages", "nodes", "flows"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "diagram_type": { "const": "dataflow" },
+    "meta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["title"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "subtitle": { "type": "string" },
+        "output": { "type": "string" }
+      }
+    },
+    "stages": {
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 5,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["label"],
+        "properties": { "label": { "type": "string", "minLength": 1 } }
+      }
+    },
+    "nodes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "type", "label", "stage", "row"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "type": { "$ref": "common.schema.json#/$defs/nodeType" },
+          "label": { "type": "string", "minLength": 1 },
+          "sublabel": { "type": "string" },
+          "tag": { "type": "string" },
+          "stage": { "type": "integer", "minimum": 0, "maximum": 4 },
+          "row": { "type": "integer", "minimum": 0, "maximum": 4 }
+        }
+      }
+    },
+    "flows": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["from", "to", "label"],
+        "properties": {
+          "from": { "$ref": "common.schema.json#/$defs/id" },
+          "to": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string", "minLength": 1 },
+          "classification": { "type": "string" },
+          "variant": { "enum": ["default", "emphasis", "security", "dashed"] }
+        }
+      }
+    },
+    "cards": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["title", "items"],
+        "properties": {
+          "title": { "type": "string", "minLength": 1 },
+          "color": { "$ref": "common.schema.json#/$defs/hexColor" },
+          "items": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    }
+  }
+}

package/schemas/lifecycle.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://claude-skills/pptx-diagram/schemas/lifecycle.schema.json",
+  "title": "Native PPTX Lifecycle Diagram",
+  "description": "Structurally identical to the workflow schema (lanes/nodes/edges, same layout budget) -- use it for state machines instead of process flows. Convention: a 'main' lane for the happy-path states and a 'terminal' lane for end states, with node types start/active/waiting/success/failure.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "diagram_type", "meta", "lanes", "nodes", "edges"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "diagram_type": { "const": "lifecycle" },
+    "meta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["title"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "subtitle": { "type": "string" },
+        "output": { "type": "string" }
+      }
+    },
+    "lanes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "label"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string", "minLength": 1 },
+          "height": { "type": "number", "minimum": 1.2, "maximum": 3, "description": "inches; default 1.75" }
+        }
+      }
+    },
+    "nodes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "lane", "type", "label"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "lane": { "$ref": "common.schema.json#/$defs/id" },
+          "col": { "type": "integer", "minimum": 0, "maximum": 5, "description": "slot index within the lane; auto-assigned to the next free slot if omitted" },
+          "type": { "$ref": "common.schema.json#/$defs/nodeType" },
+          "label": { "type": "string", "minLength": 1 },
+          "sublabel": { "type": "string" },
+          "tag": { "type": "string" },
+          "width": { "type": "number", "minimum": 0.6, "maximum": 1.85, "description": "inches; default 1.8, capped so it never exceeds one slot" },
+          "height": { "type": "number", "minimum": 0.5, "maximum": 1.5, "description": "inches; default 0.95" }
+        }
+      }
+    },
+    "edges": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["from", "to"],
+        "properties": {
+          "from": { "$ref": "common.schema.json#/$defs/id" },
+          "to": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string" },
+          "variant": { "enum": ["default", "emphasis", "security", "dashed"] },
+          "route": { "$ref": "common.schema.json#/$defs/route" },
+          "bias": { "type": "number", "minimum": 0.1, "maximum": 0.9 }
+        }
+      }
+    },
+    "cards": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["title", "items"],
+        "properties": {
+          "title": { "type": "string", "minLength": 1 },
+          "color": { "$ref": "common.schema.json#/$defs/hexColor" },
+          "items": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    }
+  }
+}

package/schemas/sequence.schema.json

@@ -0,0 +1,68 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://claude-skills/pptx-diagram/schemas/sequence.schema.json",
+  "title": "Native PPTX Sequence Diagram",
+  "description": "Participants sit in a row (max 6, auto-spaced) with a vertical lifeline; messages are drawn in JSON order at auto-incrementing y positions. See renderers/sequence for the layout budget.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "diagram_type", "meta", "participants", "messages"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "diagram_type": { "const": "sequence" },
+    "meta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["title"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "subtitle": { "type": "string" },
+        "output": { "type": "string" }
+      }
+    },
+    "participants": {
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 6,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "type", "label"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "type": { "$ref": "common.schema.json#/$defs/nodeType" },
+          "label": { "type": "string", "minLength": 1 },
+          "sublabel": { "type": "string" }
+        }
+      }
+    },
+    "messages": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 9,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["from", "to", "label"],
+        "properties": {
+          "from": { "$ref": "common.schema.json#/$defs/id" },
+          "to": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string", "minLength": 1 },
+          "variant": { "enum": ["default", "emphasis", "security", "dashed"] }
+        }
+      }
+    },
+    "cards": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["title", "items"],
+        "properties": {
+          "title": { "type": "string", "minLength": 1 },
+          "color": { "$ref": "common.schema.json#/$defs/hexColor" },
+          "items": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    }
+  }
+}