shadowbox 0.3.0__tar.gz

shadowbox-0.3.0/.github/workflows/ci.yml

@@ -0,0 +1,45 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  m0:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.13"
+      - run: uv sync --group dev
+      - run: uv run ruff check .
+      - run: uv run mypy src
+      - run: uv run pytest
+      - run: uv run shadowbox init --out /tmp/sb
+      - run: uv run shadowbox validate /tmp/sb/model.yaml --scenario /tmp/sb/scenarios/db-failure.yaml
+      - run: uv run shadowbox import --from /tmp/sb/docker-compose.yaml --out /tmp/imported.yaml
+      - run: uv run shadowbox validate /tmp/imported.yaml --scenario /tmp/sb/cards/db-down.yaml
+      - run: |
+          for card in /tmp/sb/cards/*.yaml; do
+            uv run shadowbox validate /tmp/sb/model.yaml --scenario "$card"
+          done
+      - run: uv run shadowbox simulate /tmp/sb/model.yaml --scenario /tmp/sb/cards/queue-overflow.yaml --seed 42 --out /tmp/report.json
+      - run: uv run shadowbox simulate /tmp/sb/model.yaml --scenario /tmp/sb/scenarios/db-failure.yaml --seed 42 --out /tmp/base.json
+      - run: uv run shadowbox compare --a /tmp/base.json --b /tmp/base.json
+      - run: uv run shadowbox report /tmp/report.json --format text
+      - run: uv build
+      - run: uv run python -c "import zipfile,glob; w=sorted(glob.glob('dist/*.whl'))[-1]; n=zipfile.ZipFile(w).namelist(); assert sum(1 for x in n if '/data/' in x) == 11, n; assert any(x.endswith('example/model.yaml') for x in n)"
+
+  studio:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/studio
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "24"
+      - run: npm install
+      - run: npm run build

shadowbox-0.3.0/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.13"
+      - run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

shadowbox-0.3.0/.gitignore

@@ -0,0 +1,26 @@
+# Ignore all Markdown except README.md (spec and agent docs stay local)
+*.md
+**/*.md
+!README.md
+!**/README.md
+
+# Python runtimes (never commit)
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Local server artifacts (never commit)
+*.db
+report.json
+model.yaml
+!src/shadowbox/data/example/model.yaml
+
+# Build output (never commit)
+dist/
+
+# Node (never commit)
+node_modules/
+dist/

shadowbox-0.3.0/.python-version

@@ -0,0 +1 @@
+3.13

shadowbox-0.3.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.5
+Name: shadowbox
+Version: 0.3.0
+Summary: Executable architectural model for safe what-if experimentation (M0: contracts + validate)
+License: Apache-2.0
+Requires-Python: >=3.13
+Requires-Dist: fastapi>=0.115
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.9
+Requires-Dist: uvicorn>=0.30
+Description-Content-Type: text/markdown
+
+# ShadowBox
+
+Executable architectural model for safe what-if experimentation. Model the system. Experiment safely.
+
+> Scope: headless CLI (validate, simulate, compare, report, import, init, serve) plus local API, static demo, and React Studio. Simulation output is always labeled with assumptions, confidence, and seed — never presented as production measurement.
+
+## Requirements
+
+- Python `>=3.13` (pinned via `.python-version`)
+- `uv` for env and runs (no Docker needed)
+
+## Install
+
+With a clone (development):
+
+```powershell
+uv python pin 3.13
+uv venv
+uv sync --group dev
+```
+
+Without a clone (use only):
+
+```powershell
+uvx --from "shadowbox @ git+https://github.com/Pa004/shadowBox.git@v0.2.0" shadowbox init --out demo
+```
+
+## Run in development
+
+```powershell
+uv run shadowbox init --out demo
+uv run shadowbox import --from demo/docker-compose.yaml --out demo/model2.yaml
+uv run shadowbox validate demo/model.yaml --scenario demo/scenarios/db-failure.yaml
+uv run shadowbox simulate demo/model.yaml --scenario demo/scenarios/db-failure.yaml --seed 42 --out report.json
+uv run shadowbox report report.json --format text
+uv run shadowbox compare --a base.json --b report.json
+```
+
+Exit codes: `0` valid/pass, `2` scenario regression (compare), `3` invalid input or existing files without `--force` (prints `E_*` code).
+
+Import notes: every performance field is an estimated default (see warnings). Calibrate before trusting output.
+
+Chaos cards ship in the package (`init` writes them to `cards/`): `db-down`, `cache-poison`, `latency-500ms`, `traffic-10x`, `zone-loss`, `slow-dependency`, `queue-overflow`.
+
+## API server (local)
+
+```powershell
+uv run uvicorn shadowbox.api:app --port 8000
+# or: uv run shadowbox serve --port 8000
+```
+
+Endpoints: `POST /api/v1/models`, `GET /api/v1/models/{id}`, `POST /api/v1/simulations?model_id=...`, `GET /api/v1/simulations/{id}[/events|/metrics|/report]`. Events are paginated (`limit` 1..1000, `cursor` offset over the stored 500-request sample). State lives in `shadowbox.db` (git-ignored, created on first use). The API has no authentication: bind to localhost (`serve` defaults to `127.0.0.1`) and never expose it directly to the internet.
+
+## Deploy (Cloudflare free tier, no card)
+
+Scaffold ready in `wrangler.jsonc` + `schema.sql` + `apps/api/worker.py` + `apps/web/` (static demo, no build step). Remaining steps need your Cloudflare account:
+
+```powershell
+!npm install -g wrangler
+!wrangler login
+!wrangler d1 create shadowbox  # paste database_id into wrangler.jsonc
+!wrangler d1 execute shadowbox --file schema.sql
+!uvx --from workers-py pywrangler dev   # local Worker emulation, no account needed
+!wrangler deploy
+```
+
+Production note: the Worker serves the same FastAPI app; swapping the SQLite file store for the D1 binding is a follow-up task verified against a real account (M4b-full). The static demo deploys to Pages as-is and talks to any API base URL.
+
+Open `apps/web/index.html` after `Run` to scrub virtual time: the SVG graph colors failed components red and shows active faults per second (first 500 sampled requests).
+
+## Studio (React + Cytoscape)
+
+Full UI in `apps/studio/` (Vite, strict TS). Needs Node deps (run yourself):
+
+```powershell
+cd apps/studio
+npm install
+npm run build   # tsc plus vite
+npm run dev     # /api proxies to 127.0.0.1:8000
+```
+
+Run any scenario vs baseline, inspect p99/error verdict, scrub the failure cascade on the Cytoscape graph.
+
+## Environment variables
+
+None required. Server mode reads no env vars yet; Cloudflare D1 bindings arrive with the production Worker swap.
+
+## Project structure
+
+```text
+src/shadowbox/         # model, dsl, cli, errors, engine, metrics, report, cards, api, store
+src/shadowbox/data/    # canonical example + chaos cards (shipped in the wheel)
+schemas/               # model-v1.json, scenario-v1.json
+tests/                 # unit, deterministic (golden seed 42), property, integration
+tests/fixtures/        # broken models (E_CYCLE, E_REF)
+apps/web/              # static demo with replay (no build)
+apps/studio/           # React + Cytoscape UI (Vite, strict TS)
+```
+
+## Run tests
+
+```powershell
+uv run ruff check .
+uv run mypy src
+uv run pytest
+```
+
+Benchmarks (reference: i7-1255U, 16GB, Python 3.13; SLO: 50k events < 2s):
+
+- checkout db-failure (6k reqs, 85k events): ~0.05s
+- 60k reqs, 840k events: ~0.6s
+
+## Deploy notes
+
+Local-first: CLI and `serve` need nothing but Python. Demo deploy: Cloudflare Pages (web) + Python Worker (FastAPI via `workers.asgi`) + D1 — see `Deploy (Cloudflare...)` above. No paid service, no credit card at any tier. See `ShadowBox.md` (local spec, git-ignored) for the full contract.

shadowbox-0.3.0/README.md

@@ -0,0 +1,115 @@
+# ShadowBox
+
+Executable architectural model for safe what-if experimentation. Model the system. Experiment safely.
+
+> Scope: headless CLI (validate, simulate, compare, report, import, init, serve) plus local API, static demo, and React Studio. Simulation output is always labeled with assumptions, confidence, and seed — never presented as production measurement.
+
+## Requirements
+
+- Python `>=3.13` (pinned via `.python-version`)
+- `uv` for env and runs (no Docker needed)
+
+## Install
+
+With a clone (development):
+
+```powershell
+uv python pin 3.13
+uv venv
+uv sync --group dev
+```
+
+Without a clone (use only):
+
+```powershell
+uvx --from "shadowbox @ git+https://github.com/Pa004/shadowBox.git@v0.2.0" shadowbox init --out demo
+```
+
+## Run in development
+
+```powershell
+uv run shadowbox init --out demo
+uv run shadowbox import --from demo/docker-compose.yaml --out demo/model2.yaml
+uv run shadowbox validate demo/model.yaml --scenario demo/scenarios/db-failure.yaml
+uv run shadowbox simulate demo/model.yaml --scenario demo/scenarios/db-failure.yaml --seed 42 --out report.json
+uv run shadowbox report report.json --format text
+uv run shadowbox compare --a base.json --b report.json
+```
+
+Exit codes: `0` valid/pass, `2` scenario regression (compare), `3` invalid input or existing files without `--force` (prints `E_*` code).
+
+Import notes: every performance field is an estimated default (see warnings). Calibrate before trusting output.
+
+Chaos cards ship in the package (`init` writes them to `cards/`): `db-down`, `cache-poison`, `latency-500ms`, `traffic-10x`, `zone-loss`, `slow-dependency`, `queue-overflow`.
+
+## API server (local)
+
+```powershell
+uv run uvicorn shadowbox.api:app --port 8000
+# or: uv run shadowbox serve --port 8000
+```
+
+Endpoints: `POST /api/v1/models`, `GET /api/v1/models/{id}`, `POST /api/v1/simulations?model_id=...`, `GET /api/v1/simulations/{id}[/events|/metrics|/report]`. Events are paginated (`limit` 1..1000, `cursor` offset over the stored 500-request sample). State lives in `shadowbox.db` (git-ignored, created on first use). The API has no authentication: bind to localhost (`serve` defaults to `127.0.0.1`) and never expose it directly to the internet.
+
+## Deploy (Cloudflare free tier, no card)
+
+Scaffold ready in `wrangler.jsonc` + `schema.sql` + `apps/api/worker.py` + `apps/web/` (static demo, no build step). Remaining steps need your Cloudflare account:
+
+```powershell
+!npm install -g wrangler
+!wrangler login
+!wrangler d1 create shadowbox  # paste database_id into wrangler.jsonc
+!wrangler d1 execute shadowbox --file schema.sql
+!uvx --from workers-py pywrangler dev   # local Worker emulation, no account needed
+!wrangler deploy
+```
+
+Production note: the Worker serves the same FastAPI app; swapping the SQLite file store for the D1 binding is a follow-up task verified against a real account (M4b-full). The static demo deploys to Pages as-is and talks to any API base URL.
+
+Open `apps/web/index.html` after `Run` to scrub virtual time: the SVG graph colors failed components red and shows active faults per second (first 500 sampled requests).
+
+## Studio (React + Cytoscape)
+
+Full UI in `apps/studio/` (Vite, strict TS). Needs Node deps (run yourself):
+
+```powershell
+cd apps/studio
+npm install
+npm run build   # tsc plus vite
+npm run dev     # /api proxies to 127.0.0.1:8000
+```
+
+Run any scenario vs baseline, inspect p99/error verdict, scrub the failure cascade on the Cytoscape graph.
+
+## Environment variables
+
+None required. Server mode reads no env vars yet; Cloudflare D1 bindings arrive with the production Worker swap.
+
+## Project structure
+
+```text
+src/shadowbox/         # model, dsl, cli, errors, engine, metrics, report, cards, api, store
+src/shadowbox/data/    # canonical example + chaos cards (shipped in the wheel)
+schemas/               # model-v1.json, scenario-v1.json
+tests/                 # unit, deterministic (golden seed 42), property, integration
+tests/fixtures/        # broken models (E_CYCLE, E_REF)
+apps/web/              # static demo with replay (no build)
+apps/studio/           # React + Cytoscape UI (Vite, strict TS)
+```
+
+## Run tests
+
+```powershell
+uv run ruff check .
+uv run mypy src
+uv run pytest
+```
+
+Benchmarks (reference: i7-1255U, 16GB, Python 3.13; SLO: 50k events < 2s):
+
+- checkout db-failure (6k reqs, 85k events): ~0.05s
+- 60k reqs, 840k events: ~0.6s
+
+## Deploy notes
+
+Local-first: CLI and `serve` need nothing but Python. Demo deploy: Cloudflare Pages (web) + Python Worker (FastAPI via `workers.asgi`) + D1 — see `Deploy (Cloudflare...)` above. No paid service, no credit card at any tier. See `ShadowBox.md` (local spec, git-ignored) for the full contract.

shadowbox-0.3.0/apps/api/worker.py

@@ -0,0 +1,22 @@
+"""Cloudflare Python Worker entry (M4b scaffold).
+
+Local emulation (no account needed):
+    uvx --from workers-py pywrangler dev
+
+Production additionally needs:
+    1. `wrangler d1 create shadowbox` -> paste database_id into wrangler.jsonc
+    2. `wrangler d1 execute shadowbox --file schema.sql`
+    3. D1-backed store swap (same Store signatures, D1 binding instead of
+       sqlite3 file) — follow-up task, needs account access to verify.
+"""
+
+try:
+    from workers import asgi
+except ImportError as exc:
+    raise RuntimeError(
+        "workers runtime missing: run inside `pywrangler dev`, not plain python"
+    ) from exc
+
+from shadowbox.api import app
+
+Default = asgi.entrypoint(app)

shadowbox-0.3.0/apps/studio/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>ShadowBox Studio</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

shadowbox-0.3.0/apps/studio/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "shadowbox-studio",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "cytoscape": "^3.30.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/cytoscape": "^3.14.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "typescript": "^5.6.0",
+    "vite": "^5.0.0"
+  }
+}

shadowbox-0.3.0/apps/studio/src/App.tsx

@@ -0,0 +1,73 @@
+import { useEffect, useRef, useState } from "react";
+import { createModel, runScenario, type Report, type SimEvent } from "./api";
+import { MODEL, SCENARIOS } from "./fixtures";
+import { activeFaults, failuresUpTo, renderGraph } from "./graph";
+import type cytoscape from "cytoscape";
+
+export default function App() {
+  const [base, setBase] = useState("http://127.0.0.1:8000");
+  const [scenarioName, setScenarioName] = useState("db-down");
+  const [baseline, setBaseline] = useState<Report | null>(null);
+  const [report, setReport] = useState<Report | null>(null);
+  const [events, setEvents] = useState<SimEvent[]>([]);
+  const [t, setT] = useState(0);
+  const [error, setError] = useState("");
+  const [busy, setBusy] = useState(false);
+  const cyRef = useRef<cytoscape.Core | null>(null);
+  const boxRef = useRef<HTMLDivElement>(null);
+
+  const scenario = SCENARIOS.find((s) => s.name === scenarioName) ?? SCENARIOS[0];
+
+  async function run() {
+    setBusy(true);
+    setError("");
+    try {
+      const modelId = await createModel(base, MODEL);
+      const baseRes = await runScenario(base, modelId, SCENARIOS[0], 42);
+      const cur = await runScenario(base, modelId, scenario, 42);
+      setBaseline(baseRes.report);
+      setReport(cur.report);
+      setEvents(cur.events);
+      setT(0);
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  useEffect(() => {
+    if (!boxRef.current || !report) return;
+    cyRef.current?.destroy();
+    const timeouts: Record<string, number> = {};
+    for (const [id, c] of Object.entries(report.metrics.components)) timeouts[id] = c.timeouts;
+    cyRef.current = renderGraph(boxRef.current, MODEL.components, MODEL.connections, failuresUpTo(events, t * 1000), timeouts);
+    return () => cyRef.current?.destroy();
+  }, [report, events, t]);
+
+  const m = report?.metrics;
+  const verdict = baseline && m ? (m.error_rate > baseline.metrics.error_rate ? "REGRESSION" : "pass") : "-";
+
+  return (
+    <main style={{ fontFamily: "system-ui", maxWidth: 900, margin: "2rem auto", padding: "0 1rem" }}>
+      <h1>ShadowBox Studio</h1>
+      <p>What-if simulation. Results are illustrative, never production measurements.</p>
+      <label>API base <input value={base} onChange={(e) => setBase(e.target.value)} size={30} /></label>{" "}
+      <label>Scenario{" "}
+        <select value={scenarioName} onChange={(e) => setScenarioName(e.target.value)}>
+          {SCENARIOS.map((s) => <option key={s.name} value={s.name}>{s.name}</option>)}
+        </select>
+      </label>{" "}
+      <button onClick={run} disabled={busy}>{busy ? "Running..." : "Run vs baseline"}</button>
+      {error && <pre style={{ color: "red" }}>{error}</pre>}
+      {m && (
+        <>
+          <p>error_rate={m.error_rate.toFixed(3)} p99={m.latency_ms.p99}ms verdict={verdict} hash={report?.metrics_hash.slice(0, 12)}</p>
+          <div ref={boxRef} style={{ width: "100%", height: 320, border: "1px solid #ccc" }} />
+          <label>t={t}s <input type="range" min={0} max={scenario.duration_s} value={t} onChange={(e) => setT(Number(e.target.value))} /></label>
+          <pre>active_faults=[{activeFaults(scenario.faults, t).join(", ") || "none"}]</pre>
+        </>
+      )}
+    </main>
+  );
+}

shadowbox-0.3.0/apps/studio/src/api.ts

@@ -0,0 +1,86 @@
+export interface Latency {
+  p50: number;
+  p90: number;
+  p95: number;
+  p99: number;
+}
+
+export interface ComponentMetrics {
+  utilization: number;
+  queue_depth: number;
+  timeouts: number;
+}
+
+export interface Metrics {
+  throughput_rps: number;
+  error_rate: number;
+  latency_ms: Latency;
+  timeouts: number;
+  retries: number;
+  cascade_depth: number;
+  components: Record<string, ComponentMetrics>;
+}
+
+export interface Report {
+  metrics: Metrics;
+  metrics_hash: string;
+  seed: number;
+  confidence: string;
+  calibration_source: string;
+}
+
+export interface SimEvent {
+  correlation_id: string;
+  ok: boolean;
+  latency_ms: number;
+  failed_at: string | null;
+  timed_out: boolean;
+  arrival_ms: number;
+  finish_ms: number;
+}
+
+export interface Fault {
+  target: string;
+  type: string;
+  start_s: number;
+  duration_s: number;
+  extra_ms?: number;
+}
+
+export interface Scenario {
+  name: string;
+  duration_s: number;
+  workload: { rate_rps: number };
+  faults: Fault[];
+}
+
+async function postJson(base: string, path: string, body: unknown, query = ""): Promise<unknown> {
+  const res = await fetch(`${base}${path}${query}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`${path}: HTTP ${res.status}`);
+  return res.json() as Promise<unknown>;
+}
+
+export async function createModel(base: string, model: unknown): Promise<string> {
+  const out = (await postJson(base, "/api/v1/models", model)) as { id: string };
+  return out.id;
+}
+
+export async function runScenario(
+  base: string,
+  modelId: string,
+  scenario: Scenario,
+  seed: number
+): Promise<{ simId: string; report: Report; events: SimEvent[] }> {
+  const sim = (await postJson(base, "/api/v1/simulations", { scenario, seed }, `?model_id=${modelId}`)) as {
+    id: string;
+  };
+  const report = (await (await fetch(`${base}/api/v1/simulations/${sim.id}/report`)).json()) as Report;
+  const page = (await (
+    await fetch(`${base}/api/v1/simulations/${sim.id}/events?limit=500`)
+  ).json()) as { events: SimEvent[] };
+  return { simId: sim.id, report, events: page.events };
+}

shadowbox-0.3.0/apps/studio/src/fixtures.ts

@@ -0,0 +1,23 @@
+export const MODEL = {
+  components: [
+    { id: "api", type: "service", capacity: 50, latency_ms: { base: 20, jitter_ms: 5 }, timeout_ms: 1000, queue_size: 200, queue_policy: "drop" },
+    { id: "cache", type: "cache", capacity: 100, latency_ms: { base: 2, jitter_ms: 1 }, timeout_ms: 200, queue_size: 500, queue_policy: "drop" },
+    { id: "database", type: "database", capacity: 20, latency_ms: { base: 5, jitter_ms: 1 }, timeout_ms: 500, queue_size: 100, queue_policy: "fifo" }
+  ],
+  connections: [
+    { from: "api", to: "cache" },
+    { from: "api", to: "database" },
+    { from: "cache", to: "database" }
+  ]
+};
+
+export const SCENARIOS = [
+  { name: "baseline", duration_s: 60, workload: { rate_rps: 100 }, faults: [] },
+  { name: "db-down", duration_s: 60, workload: { rate_rps: 100 }, faults: [{ target: "database", type: "unavailable", start_s: 20, duration_s: 10 }] },
+  { name: "cache-poison", duration_s: 60, workload: { rate_rps: 100 }, faults: [{ target: "cache", type: "unavailable", start_s: 20, duration_s: 10 }] },
+  { name: "latency-500ms", duration_s: 60, workload: { rate_rps: 100 }, faults: [{ target: "database", type: "latency", extra_ms: 500, start_s: 0, duration_s: 60 }] },
+  { name: "traffic-10x", duration_s: 60, workload: { rate_rps: 1000 }, faults: [] },
+  { name: "zone-loss", duration_s: 60, workload: { rate_rps: 100 }, faults: [{ target: "cache", type: "unavailable", start_s: 20, duration_s: 20 }, { target: "database", type: "unavailable", start_s: 20, duration_s: 20 }] },
+  { name: "slow-dependency", duration_s: 60, workload: { rate_rps: 100 }, faults: [{ target: "cache", type: "latency", extra_ms: 100, start_s: 0, duration_s: 60 }] },
+  { name: "queue-overflow", duration_s: 10, workload: { rate_rps: 3000 }, faults: [] }
+];

shadowbox-0.3.0/apps/studio/src/graph.ts

@@ -0,0 +1,45 @@
+import cytoscape from "cytoscape";
+import type { SimEvent } from "./api";
+
+export type NodeStatus = "ok" | "failing" | "degraded";
+
+export function renderGraph(
+  container: HTMLElement,
+  components: { id: string; type: string }[],
+  connections: { from: string; to: string }[],
+  failures: Record<string, number>,
+  timeouts: Record<string, number>
+): cytoscape.Core {
+  const nodes = components.map((c) => {
+    const fails = failures[c.id] ?? 0;
+    const status: NodeStatus = fails > 0 ? "failing" : (timeouts[c.id] ?? 0) > 0 ? "degraded" : "ok";
+    return { data: { id: c.id, label: `${c.id}\n${c.type} fails:${fails}`, status } };
+  });
+  const edges = connections.map((c, i) => ({ data: { id: `e${i}`, source: c.from, target: c.to } }));
+  return cytoscape({
+    container,
+    elements: [...nodes, ...edges],
+    style: [
+      { selector: "node", style: { label: "data(label)", color: "#fff", "text-valign": "center", "text-halign": "center", "font-size": 11 } },
+      { selector: 'node[status="ok"]', style: { "background-color": "#2e7d32" } },
+      { selector: 'node[status="failing"]', style: { "background-color": "#c62828" } },
+      { selector: 'node[status="degraded"]', style: { "background-color": "#ef6c00" } },
+      { selector: "edge", style: { width: 2, "line-color": "#888", "target-arrow-shape": "triangle", "target-arrow-color": "#888" } }
+    ],
+    layout: { name: "breadthfirst", directed: true, padding: 30 }
+  });
+}
+
+export function failuresUpTo(events: SimEvent[], tMs: number): Record<string, number> {
+  const out: Record<string, number> = {};
+  for (const e of events) {
+    if (e.finish_ms <= tMs && !e.ok && e.failed_at) out[e.failed_at] = (out[e.failed_at] ?? 0) + 1;
+  }
+  return out;
+}
+
+export function activeFaults(faults: { target: string; type: string; start_s: number; duration_s: number }[], tS: number): string[] {
+  return faults
+    .filter((f) => f.start_s <= tS && tS < f.start_s + f.duration_s)
+    .map((f) => `${f.type}@${f.target}`);
+}

shadowbox-0.3.0/apps/studio/src/main.tsx

@@ -0,0 +1,9 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App";
+
+createRoot(document.getElementById("root") as HTMLElement).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);

shadowbox-0.3.0/apps/studio/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "noUnusedLocals": true,
+    "skipLibCheck": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src", "vite.config.ts"]
+}