devagent-ignition 0.1.0__py3-none-any.whl

devagent_spatial/_resources/reference/v8-original/README.md

@@ -0,0 +1,36 @@
+# DevAgent Distribution Operations HMI V8
+
+**Operator-first, connected warehouse material-flow concept.** Replaces V7's artificial 6-conveyor circle with a branched hub similar in *operating model* to parcel sorting and airport baggage handling: two receiving sources feed induction/gapping → scanning/merge → main sorter → three discharge destinations, with a no-read/exception route.
+
+This is a **self-contained local browser demo**, NOT a finished Ignition Perspective project and NOT connected to any PLC, WCS, VFD, safety system, or live facility. Throughput, parcels, speeds, equipment health and alarms are **synthetic**.
+
+## Run
+
+```bash
+cd "$HOME/Downloads"
+unzip -n devagent-warehouse-facility-overview-v8.zip
+cd devagent-warehouse-facility-overview-v8
+sha256sum -c SHA256SUMS.txt
+python3 -m unittest discover -s tests -v
+./run_demo.sh
+```
+
+Open **operator overview** at `http://127.0.0.1:8768/index.html`. Open **separate engineering console** at `http://127.0.0.1:8768/simulator.html`.
+
+## Using the interface
+
+- The main page is a continuous, non-loop topology. Follow the receiving conveyors into two induction branches, shared scan/merge, linear sorter and the outbound diverts. Map sections and their label badges show operational status.
+- Select a conveyor **path or equipment ID badge** to zoom into it. The right panel switches to a read-only motor, VFD, photoeye, throughput and diagnostic faceplate. **Return to overview**, press **Esc**, or click **Fit View** to reset.
+- Select **Receiving / Induction / Sortation / Outbound** to zoom an area. Mouse wheel zooms at the pointer; drag blank background to pan. The right panel shows area health and changes to show faults/affected routes.
+- In the *engineering console only*, inject a jam, VFD trip, bad photoeye, congestion, low speed or global stop. The operator screen polls every 1.4 seconds. Normal restores all sections. Targeted jam/fault scenarios emulate upstream backpressure and downstream starvation. These propagated states are **conceptual**, not a verified control algorithm.
+- The main HMI cannot send start, stop, reset or other actuator commands. `/api/scenario` changes in-memory synthetic data only, requires local host, and is not mounted to equipment.
+
+## Project layout
+
+`topology.json` — branched section graph, SVG paths and area geometry; `model.py` — state machine, propagation and simulated process values; `server.py` — Python standard-library localhost web server, allowlisted static files and simulated test API; `web/*` — operator HMI & isolated engineering simulator; `tests/test_v8.py` — topology, scenario, security, API tests.
+
+## Verification boundary
+
+`python3 -m unittest discover -s tests -v` verifies structural, data and HTTP contracts. Browser smoke tests validate rendering, zoom/inspection and cross-tab scenario updates when run in a Chromium/Playwright environment. These tests **do not establish functional safety, equipment-level fidelity, real-time determinism, scan-routing accuracy, PLC integration or Ignition gateway compatibility**.
+
+For a production Ignition Perspective implementation, convert topology to a model-driven SVG/coordinate view, bind qualified tag values via a tested UDT contract, enforce alarm quality/staleness and navigation roles, and verify in an isolated gateway after full fresh `.gwbk` backup and preflight. All physical topology/safety interlocks must match actual engineering drawings.

devagent_spatial/_resources/reference/v8-original/SHA256SUMS.txt

@@ -0,0 +1,12 @@
+dd4032360e10c1597d839a6e84f3c528cd4b64e12b67f271744cd532cb8ca373  README.md
+7ce53dbea176e3f9b9f356695ffea855e9d6e33fbb7dfbf7b659dd484b05a51d  model.py
+373a34f1e93621d6da71d4aa57d0923a4ccc5274db9f50bfd0bb03170ebedc9a  run_demo.sh
+41392a8b9665e93baa667e94e7fdc5d82c7c485d8655112e9b73695f47d04685  server.py
+e1c8342d7142433a953b0e14ee0e9b24877cb6b16f26dd251b4001b223e9cc94  tests/browser_smoke.py
+75f13679facb939577f4e22bcdf2abf83f74177f703aec056a5160778ed8a976  tests/test_v8.py
+1137cce6b83c594ff1be3eaaeddc210a78b6f5b7fe2dbeaf7151f228964edbbf  topology.json
+b82fe00959c43f39fc658ae8c89fb03fc2b61649d4abc30471d37ebcbb1a151c  web/app.js
+870f2d3cf5913d35ef6f46c7e853c3a7283e65888778d40e64cf6ae64a099f92  web/index.html
+ab2d98a3a6944913e1d5ce35ab9f16dc12d6007f9a0ca4728b3f63fcc2ad0966  web/simulator.html
+2758752d746b768aecd3b8a1c2a99ec898507379513683f18847f0d82522299e  web/simulator.js
+e14b737638102bd95492cb94851bc40ea6502f574fc3f2c0c8be6dba5086faa3  web/style.css

devagent_spatial/_resources/reference/v8-original/model.py

@@ -0,0 +1,124 @@
+"""Local-only, deterministic synthetic conveyor network. No PLC operations."""
+from __future__ import annotations
+import json
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import Any
+
+TOPOLOGY = json.loads((Path(__file__).resolve().parent / "topology.json").read_text())
+SECTIONS = {x["id"]: x for x in TOPOLOGY["sections"]}
+SCENARIOS = ("normal", "jam", "vfd_fault", "photoeye_fault", "congestion", "slow", "line_stop")
+
+def utc_now():
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+def new_state():
+    return {"scenario": "normal", "target": "CV108", "revision": 0, "since": utc_now(),
+            "events": [{"time": utc_now(), "level": "info", "asset": "SYSTEM", "message": "Simulation started; no PLC connection"}]}
+
+def validate_command(payload: Any):
+    if not isinstance(payload, dict) or set(payload) - {"scenario", "target"}:
+        raise ValueError("Expected JSON object with scenario and target")
+    scenario, target = payload.get("scenario"), payload.get("target", "CV108")
+    if scenario not in SCENARIOS or target not in SECTIONS:
+        raise ValueError("Invalid scenario or equipment ID")
+    return scenario, target
+
+def traverse(target: str, direction: str):
+    """Return all reachable upstream or downstream section IDs, cycle safe."""
+    seen, frontier = set(), list(SECTIONS[target][direction])
+    while frontier:
+        item = frontier.pop()
+        if item not in seen:
+            seen.add(item)
+            frontier.extend(SECTIONS[item][direction])
+    return seen
+
+def transition(state, payload):
+    scenario, target = validate_command(payload)
+    if (scenario, target) == (state["scenario"], state["target"]):
+        return state
+    label = "System simulation restored" if scenario == "normal" else (
+        "Entire simulated line stopped" if scenario == "line_stop" else f"{scenario.replace('_', ' ').upper()} injected at {target}")
+    event = {"time": utc_now(), "level": "info" if scenario == "normal" else "warning" if scenario in ("slow", "congestion", "line_stop") else "alarm",
+             "asset": "SYSTEM" if scenario in ("normal", "line_stop") else target, "message": label}
+    return {"scenario": scenario, "target": target, "revision": state["revision"] + 1,
+            "since": utc_now(), "events": (state["events"] + [event])[-30:]}
+
+def view_state(controller):
+    scenario, target = controller["scenario"], controller["target"]
+    upstream = traverse(target, "upstream") if scenario in ("jam", "vfd_fault", "congestion") else set()
+    downstream = traverse(target, "downstream") if scenario in ("jam", "vfd_fault") else set()
+    units = []
+    for n, c in enumerate(TOPOLOGY["sections"]):
+        asset, status = c["id"], "RUNNING"
+        speed, frequency = c["speed"], round(c["speed"] * .88, 1)
+        quality, fault_code = "GOOD", "—"
+        motor_run, motor_feedback, drive_ready, drive_fault = True, True, True, False
+        pe_in, pe_out = "CLEAR" if n % 2 else "DETECTED", "CLEAR"
+        diag = "Nominal simulated operation. No active diagnostics."
+        if scenario == "line_stop":
+            status = "STOPPED"
+        elif asset == target:
+            if scenario == "jam":
+                status, pe_in, pe_out = "JAM", "BLOCKED", "BLOCKED"
+                diag = "Simulated jam: infeed/outfeed photoeyes blocked beyond 4.0 s. Verify transfer safely."
+            elif scenario == "vfd_fault":
+                status, drive_fault, drive_ready, fault_code = "FAULT", True, False, "F003"
+                quality = "BAD"
+                diag = "Simulated VFD trip F003. Check drive diagnostics and safe isolation procedure."
+            elif scenario == "photoeye_fault":
+                status, pe_in, quality = "SENSOR FAULT", "BAD QUALITY", "BAD"
+                diag = "Simulated photoeye signal quality failure; inspect I/O and sensor health."
+            elif scenario == "congestion":
+                status, pe_out = "CONGESTED", "BLOCKED"
+                diag = "Simulated rising accumulation at discharge; inspect downstream capacity."
+            elif scenario == "slow":
+                status, speed = "SLOW", round(speed * .35, 1)
+                diag = "Simulated measured speed below nominal threshold."
+        elif asset in upstream and scenario in ("jam", "vfd_fault", "congestion"):
+            # Synthetic dependency propagation illustrates upstream accumulation, not deterministic PLC behavior.
+            status = "BACKPRESSURE"
+            diag = f"Upstream accumulation associated with {target} (simulation only)."
+        elif asset in downstream:
+            status = "STARVED"
+            diag = f"No new product supplied from {target} (simulation only)."
+        if status in ("STOPPED", "JAM", "FAULT", "STARVED"):
+            speed, frequency, motor_run, motor_feedback = 0, 0, False, False
+        elif status == "BACKPRESSURE":
+            speed, frequency = round(speed*.35, 1), round(frequency*.35, 1)
+        elif status == "SLOW":
+            frequency = round(frequency * .35, 1)
+        units.append({
+            "id": asset, "name": c["name"], "area": c["area"],
+            "upstream": c["upstream"], "downstream": c["downstream"],
+            "status": status, "speed_mpm": speed, "nominal_speed_mpm": c["speed"],
+            "rate_pph": 0 if speed == 0 else int(c["rate"] * speed / c["speed"]),
+            "quality": quality, "diagnostic": diag,
+            "motor": {"id": "M-"+asset[2:], "run_command": motor_run, "run_feedback": motor_feedback,
+                      "current_a": round((3.8 + n * .18) * (1.2 if status == "JAM" else 1.0 if speed else 0.0), 1),
+                      "rpm": round(speed * 34)},
+            "vfd": {"id": "VFD-"+asset[2:], "ready": drive_ready, "drive_fault": drive_fault,
+                    "frequency_hz": frequency, "fault_code": fault_code},
+            "sensors": {"infeed": {"id": "PE-"+asset[2:]+"-IN", "state": pe_in},
+                        "outfeed": {"id": "PE-"+asset[2:]+"-OUT", "state": pe_out}},
+        })
+    alarms = sum(u["status"] in ("JAM", "FAULT", "SENSOR FAULT") for u in units)
+    affected = sum(u["status"] != "RUNNING" for u in units)
+    rate = {"normal": 7284, "jam": 3180, "vfd_fault": 3490, "photoeye_fault": 5910,
+            "congestion": 5015, "slow": 6380, "line_stop": 0}[scenario]
+    regions = []
+    for area in TOPOLOGY["zones"]:
+        members = [u for u in units if u["area"] == area["id"]]
+        regions.append({"id": area["id"], "name": area["name"], "total": len(members),
+                        "attention": sum(u["status"] != "RUNNING" for u in members),
+                        "alarms": sum(u["status"] in ("JAM", "FAULT", "SENSOR FAULT") for u in members)})
+    return {"meta": {"name": TOPOLOGY["facility"], "demo": True, "connected_to_plc": False,
+                     "timestamp": utc_now(), "revision": controller["revision"], "since": controller["since"]},
+            "overview": {"status": "STOPPED" if scenario == "line_stop" else "ALARM" if alarms else "ATTENTION" if affected else "RUNNING",
+                         "throughput_pph": rate, "capacity_pph": 9200, "active_alarms": alarms,
+                         "affected_units": affected, "healthy_units": len(units) - affected,
+                         "total_units": len(units), "parcels_in_system": 0 if scenario == "line_stop" else 247 + (controller["revision"] % 9),
+                         "scan_read_pct": 98.9 if scenario == "photoeye_fault" else 99.3,
+                         "scenario": scenario, "target": target},
+            "regions": regions, "units": units, "events": controller["events"][-10:][::-1]}

devagent_spatial/_resources/reference/v8-original/run_demo.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")"
+exec python3 server.py --port "${PORT:-8768}"

devagent_spatial/_resources/reference/v8-original/server.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""Localhost-only demo HTTP server; scenario endpoints DO NOT control hardware."""
+from __future__ import annotations
+
+import argparse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+import json
+import threading
+from urllib.parse import urlsplit
+
+from model import new_state, transition, view_state
+
+ROOT = Path(__file__).resolve().parent / "web"
+MIME = {".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8",
+        ".css": "text/css; charset=utf-8", ".svg": "image/svg+xml", ".json": "application/json"}
+ALLOWED = {"/index.html", "/simulator.html", "/app.js", "/simulator.js", "/style.css", "/topology.json"}
+
+
+class DemoServer(ThreadingHTTPServer):
+    daemon_threads = True
+    allow_reuse_address = True
+
+    def __init__(self, addr):
+        super().__init__(addr, DemoHandler)
+        self.lock = threading.Lock()
+        self.model_state = new_state()
+
+
+class DemoHandler(BaseHTTPRequestHandler):
+    server: DemoServer
+
+    def _send(self, code, body, content_type="application/json; charset=utf-8"):
+        self.send_response(code)
+        self.send_header("Content-Type", content_type)
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("X-Frame-Options", "DENY")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _json(self, code, value):
+        self._send(code, json.dumps(value, ensure_ascii=False).encode("utf-8"))
+
+    def do_GET(self):
+        path = urlsplit(self.path).path
+        if path == "/api/state":
+            with self.server.lock:
+                data = view_state(self.server.model_state)
+            return self._json(200, data)
+        if path == "/":
+            path = "/index.html"
+        if path not in ALLOWED:
+            return self._json(404, {"error": "Not found"})
+        data = (Path(__file__).resolve().parent / "topology.json").read_bytes() if path == "/topology.json" else (ROOT / path[1:]).read_bytes()
+        self._send(200, data, MIME[Path(path).suffix])
+
+    def do_POST(self):
+        if urlsplit(self.path).path != "/api/scenario":
+            return self._json(404, {"error": "Not found"})
+        if self.headers.get("Content-Type", "").split(";")[0].strip() != "application/json":
+            return self._json(415, {"error": "Use application/json"})
+        try:
+            size = int(self.headers.get("Content-Length", "0"))
+            if not 0 < size <= 1024:
+                return self._json(413, {"error": "Invalid payload size"})
+            payload = json.loads(self.rfile.read(size).decode("utf-8"))
+            with self.server.lock:
+                new_state = transition(self.server.model_state, payload)
+                self.server.model_state = new_state
+                data = view_state(new_state)
+            self._json(200, data)
+        except (ValueError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+            self._json(400, {"error": str(exc)})
+
+    def log_message(self, fmt, *args):
+        pass  # no noisy access logs in demonstration mode
+
+
+def build_server(host="127.0.0.1", port=8767):
+    if host not in ("127.0.0.1", "localhost"):
+        raise ValueError("This simulation must bind only to localhost")
+    return DemoServer(("127.0.0.1", port))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="DevAgent connected conveyor demonstration")
+    parser.add_argument("--port", type=int, default=8767)
+    args = parser.parse_args()
+    httpd = build_server(port=args.port)
+    print(f"DEVAGENT_V8_DEMO=http://127.0.0.1:{httpd.server_port}/index.html", flush=True)
+    print(f"DEVAGENT_V8_ENGINEERING=http://127.0.0.1:{httpd.server_port}/simulator.html", flush=True)
+    print("SIMULATION ONLY — NO LIVE PLC / DRIVE CONNECTION", flush=True)
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        httpd.server_close()

devagent_spatial/_resources/reference/v8-original/tests/browser_smoke.py

@@ -0,0 +1,50 @@
+"""Optional real Chromium interaction acceptance test, local server; saves screenshot."""
+import sys,threading,time
+from pathlib import Path
+BASE=Path(__file__).resolve().parents[1]
+sys.path.insert(0,str(BASE))
+from server import build_server
+from playwright.sync_api import sync_playwright
+server=build_server(port=0)
+thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
+url=f'http://127.0.0.1:{server.server_port}'
+try:
+ with sync_playwright() as p:
+  b=p.chromium.launch(headless=True,executable_path='/usr/bin/chromium',args=['--no-sandbox'])
+  page=b.new_page(viewport={'width':1710,'height':1070},device_scale_factor=1)
+  errors=[];page.on('pageerror',lambda e:errors.append(str(e)))
+  page.goto(url+'/index.html',wait_until='networkidle')
+  page.wait_for_function("document.getElementById('healthValue').textContent==='OPERATIONAL'")
+  assert page.locator('.eq-route').count()==13
+  page.screenshot(path=str(BASE/'warehouse-v8-overview.png'),full_page=True)
+  before=page.locator('#factoryMap').get_attribute('viewBox')
+  page.locator('#eq-CV108').click()
+  page.wait_for_function("document.getElementById('mapTitle').textContent.includes('CV108')")
+  page.wait_for_timeout(500)
+  after=page.locator('#factoryMap').get_attribute('viewBox')
+  assert before!=after,(before,after)
+  assert page.get_by_text('M-108 / VFD-108').count()>=1
+  page.screenshot(path=str(BASE/'warehouse-v8-zoom.png'),full_page=True)
+  engineer=b.new_page(viewport={'width':1080,'height':850})
+  engineer.goto(url+'/simulator.html',wait_until='networkidle')
+  engineer.select_option('#target','CV108')
+  engineer.select_option('#scenario','jam')
+  engineer.locator('#inject').click()
+  engineer.wait_for_function("document.getElementById('currentScenario').textContent==='JAM'")
+  page.wait_for_function("document.getElementById('healthValue').textContent==='ALARM'",timeout=8000)
+  assert 'JAM' in page.locator('.statebadge').inner_text()
+  page.screenshot(path=str(BASE/'warehouse-v8-alarm.png'),full_page=True)
+  engineer.locator('#restore').click()
+  engineer.wait_for_function("document.getElementById('currentScenario').textContent==='NORMAL'")
+  page.wait_for_function("document.getElementById('healthValue').textContent==='OPERATIONAL'",timeout=8000)
+  page.locator('#fitBtn').click()
+  page.wait_for_timeout(400)
+  assert page.locator('#factoryMap').get_attribute('viewBox')=='0.0 0.0 1400.0 700.0'
+  page.get_by_role('button',name='Receiving').click()
+  page.wait_for_function("document.getElementById('mapTitle').textContent.includes('RECEIVING')")
+  assert not errors,errors
+  print('BROWSER_SMOKE=PASS segments=13 click_to_zoom=PASS faceplate=PASS cross_tab_jam=PASS restore=PASS fit=PASS area_zoom=PASS pageerrors=0')
+  print('SCREENSHOTS='+','.join(str(BASE / ('warehouse-v8-'+name+'.png')) for name in ('overview','zoom','alarm')))
+  b.close()
+finally:
+ server.shutdown();server.server_close();thread.join(timeout=3)

devagent_spatial/_resources/reference/v8-original/tests/test_v8.py

@@ -0,0 +1,144 @@
+"""V8 contract and localhost functional checks: no external PLC dependencies."""
+import json, os, sys, unittest, threading, urllib.request, urllib.error
+from pathlib import Path
+BASE=Path(__file__).resolve().parents[1]
+sys.path.insert(0,str(BASE))
+from model import TOPOLOGY, SECTIONS, SCENARIOS, new_state, validate_command, transition, view_state, traverse
+from server import build_server
+
+class Topology(unittest.TestCase):
+    def test_13_sections(self): self.assertEqual(13,len(SECTIONS))
+    def test_four_operating_areas(self): self.assertEqual(4,len(TOPOLOGY['zones']))
+    def test_unique_sections(self): self.assertEqual(len(SECTIONS),len(set(SECTIONS)))
+    def test_no_duplicate_area(self): self.assertEqual(len(TOPOLOGY['zones']),len(set(z['id'] for z in TOPOLOGY['zones'])))
+    def test_two_receiving_sources(self): self.assertEqual(['CV101','CV102'],[s['id'] for s in TOPOLOGY['sections'] if not s['upstream']])
+    def test_connected_merge(self): self.assertEqual({'CV105','CV106'},set(SECTIONS['CV107']['upstream']))
+    def test_branch_outbound(self): self.assertEqual({'CV109','CV111'},set(SECTIONS['CV108']['downstream']))
+    def test_three_terminal_destinations(self):
+        terminals={s['id'] for s in TOPOLOGY['sections'] if not s['downstream']}
+        self.assertEqual({'CV111','CV112','CV113'},terminals)
+    def test_edges_bidirectional_metadata(self):
+        for unit in TOPOLOGY['sections']:
+            for v in unit['downstream']:
+                self.assertIn(unit['id'],SECTIONS[v]['upstream'])
+            for v in unit['upstream']:
+                self.assertIn(unit['id'],SECTIONS[v]['downstream'])
+    def test_no_orphan_equipment(self):
+        for u in SECTIONS.values(): self.assertTrue(u['upstream'] or u['downstream'])
+    def test_full_reachability(self):
+        found={'CV101','CV102'}|traverse('CV101','downstream')|traverse('CV102','downstream')
+        self.assertEqual(set(SECTIONS),found)
+    def test_no_unwanted_circle(self):
+        def dfs(u,stack,seen):
+            if u in stack: raise AssertionError(f'Cycle found at {u}')
+            if u in seen:return
+            seen.add(u)
+            for n in SECTIONS[u]['downstream']:dfs(n,stack|{u},seen)
+        visited=set()
+        for k in ('CV101','CV102'):dfs(k,set(),visited)
+        self.assertEqual(set(SECTIONS),visited)
+    def test_all_equipment_has_paths(self):
+        for c in TOPOLOGY['sections']:
+            self.assertRegex(c['path'],r'^M\d+ \d+')
+            self.assertEqual(2,len(c['label']))
+    def test_paths_branch_into_main_trunk(self):
+        for id in ('CV111','CV112','CV113'):self.assertIn('340',SECTIONS[id]['path'])
+    def test_every_section_has_area(self):
+        areas={z['id'] for z in TOPOLOGY['zones']}
+        for c in TOPOLOGY['sections']:self.assertIn(c['area'],areas)
+
+class Behavior(unittest.TestCase):
+    def setUp(self):self.s=new_state()
+    def v(self,s,t='CV108'):return view_state(transition(self.s,{'scenario':s,'target':t}))
+    def u(self,x,sid):return next(v for v in x['units'] if v['id']==sid)
+    def test_baseline(self):
+        v=view_state(self.s)
+        self.assertEqual('RUNNING',v['overview']['status'])
+        self.assertEqual(0,v['overview']['active_alarms'])
+    def test_plc_is_always_disconnected(self):self.assertFalse(view_state(self.s)['meta']['connected_to_plc'])
+    def test_all_scenarios_accepted(self):
+        for k in SCENARIOS:self.assertEqual(k,validate_command({'scenario':k,'target':'CV107'})[0])
+    def test_reject_invalid_scenario(self):
+        with self.assertRaises(ValueError):validate_command({'scenario':'arbitrary_js','target':'CV101'})
+    def test_reject_invalid_equipment(self):
+        with self.assertRaises(ValueError):validate_command({'scenario':'jam','target':'CV999'})
+    def test_reject_extra_commands(self):
+        with self.assertRaises(ValueError):validate_command({'scenario':'normal','target':'CV101','start_motor':True})
+    def test_reject_non_object(self):
+        with self.assertRaises(ValueError):validate_command(['normal','CV101'])
+    def test_jam_updates_alarm(self):
+        v=self.v('jam');self.assertEqual('ALARM',v['overview']['status']);self.assertEqual('JAM',self.u(v,'CV108')['status'])
+    def test_jam_upstream_backpressure(self):self.assertEqual('BACKPRESSURE',self.u(self.v('jam'),'CV107')['status'])
+    def test_jam_downstream_starved(self):self.assertEqual('STARVED',self.u(self.v('jam'),'CV111')['status'])
+    def test_unaffected_receiving_not_false_alarm(self):
+        v=self.v('jam','CV102');self.assertEqual('RUNNING',self.u(v,'CV101')['status'])
+    def test_vfd_fault_code_and_speed(self):
+        v=self.v('vfd_fault');u=self.u(v,'CV108');self.assertEqual('F003',u['vfd']['fault_code']);self.assertEqual(0,u['speed_mpm'])
+    def test_photoeye_bad_quality(self):
+        v=self.v('photoeye_fault');self.assertEqual('BAD',self.u(v,'CV108')['quality'])
+    def test_congestion_alarm_distinction(self):
+        v=self.v('congestion');self.assertEqual('ATTENTION',v['overview']['status']);self.assertEqual(0,v['overview']['active_alarms'])
+    def test_slow_reduces_speed(self):
+        v=self.v('slow');u=self.u(v,'CV108');self.assertLess(u['speed_mpm'],u['nominal_speed_mpm'])
+    def test_stop_entire_line(self):
+        v=self.v('line_stop');self.assertEqual('STOPPED',v['overview']['status']);self.assertTrue(all(u['status']=='STOPPED' for u in v['units']))
+    def test_stop_zero_rate(self):self.assertEqual(0,self.v('line_stop')['overview']['throughput_pph'])
+    def test_restore_all_nominal(self):
+        v=view_state(transition(transition(self.s,{'scenario':'jam','target':'CV108'}),{'scenario':'normal','target':'CV108'}))
+        self.assertTrue(all(u['status']=='RUNNING' for u in v['units']))
+    def test_duplicate_no_revision(self):
+        s=transition(self.s,{'scenario':'normal','target':'CV108'});self.assertEqual(self.s['revision'],s['revision'])
+    def test_new_event_at_each_transition(self):
+        s=transition(self.s,{'scenario':'jam','target':'CV108'});self.assertEqual(len(self.s['events'])+1,len(s['events']))
+    def test_view_does_not_mutate_model(self):
+        copy=json.dumps(self.s,sort_keys=True);view_state(self.s);self.assertEqual(copy,json.dumps(self.s,sort_keys=True))
+    def test_line_status_count(self):
+        v=self.v('jam');self.assertEqual(13,v['overview']['total_units'])
+        self.assertEqual(13,v['overview']['healthy_units']+v['overview']['affected_units'])
+
+class HTTP(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.srv=build_server(port=0)
+        cls.worker=threading.Thread(target=cls.srv.serve_forever,daemon=True)
+        cls.worker.start()
+        cls.url=f'http://127.0.0.1:{cls.srv.server_port}'
+    @classmethod
+    def tearDownClass(cls):cls.srv.shutdown();cls.srv.server_close();cls.worker.join(timeout=2)
+    def get(self,path):
+        with urllib.request.urlopen(self.url+path,timeout=2) as r:return r.status,r.read(),r.headers
+    def post(self,path,payload,ct='application/json'):
+        request=urllib.request.Request(self.url+path,method='POST',data=json.dumps(payload).encode(),headers={'Content-Type':ct})
+        with urllib.request.urlopen(request,timeout=2) as r:return r.status,json.load(r)
+    def test_index(self):self.assertIn(b'Warehouse overview',self.get('/')[1])
+    def test_topology(self):self.assertEqual(13,len(json.loads(self.get('/topology.json')[1])['sections']))
+    def test_no_cache_state(self):self.assertEqual('no-store',self.get('/api/state')[2].get('Cache-Control'))
+    def test_engineering_is_separate(self):
+        self.assertIn(b'Scenario controller',self.get('/simulator.html')[1])
+        self.assertNotIn(b'APPLY TEST SCENARIO',self.get('/index.html')[1])
+    def test_frontend_has_no_post(self):
+        src=self.get('/app.js')[1].decode()
+        self.assertNotIn("method:'POST'",src)
+        self.assertNotIn('api/scenario',src)
+    def test_injection_changes_live_view(self):
+        status,_=self.post('/api/scenario',{'scenario':'jam','target':'CV109'})
+        self.assertEqual(200,status)
+        v=json.loads(self.get('/api/state')[1]);self.assertEqual('JAM',next(u['status'] for u in v['units'] if u['id']=='CV109'))
+        self.post('/api/scenario',{'scenario':'normal','target':'CV108'})
+    def test_reject_write_static(self):
+        with self.assertRaises(urllib.error.HTTPError) as err:self.post('/index.html',{'scenario':'jam'})
+        self.assertEqual(404,err.exception.code)
+    def test_reject_directory_traversal(self):
+        with self.assertRaises(urllib.error.HTTPError) as err:self.get('/%2e%2e/server.py')
+        self.assertEqual(404,err.exception.code)
+    def test_reject_json_wrong_type(self):
+        with self.assertRaises(urllib.error.HTTPError) as err:self.post('/api/scenario',{'scenario':'jam'},ct='text/plain')
+        self.assertEqual(415,err.exception.code)
+    def test_response_no_sniff(self):self.assertEqual('nosniff',self.get('/')[2].get('X-Content-Type-Options'))
+    def test_invalid_scenario_http400(self):
+        with self.assertRaises(urllib.error.HTTPError) as err:self.post('/api/scenario',{'scenario':'cmd_motor_run','target':'CV101'})
+        self.assertEqual(400,err.exception.code)
+    def test_server_rejects_remote_bind(self):
+        with self.assertRaises(ValueError):build_server(host='0.0.0.0',port=0)
+
+if __name__=='__main__':unittest.main(verbosity=2)

devagent_spatial/_resources/reference/v8-original/topology.json

@@ -0,0 +1,24 @@
+{
+  "facility": "NORTH DISTRIBUTION CENTER", "line": "Parcel Sortation / Area A", "canvas": {"width": 1400, "height": 700},
+  "zones": [
+    {"id":"INBOUND","name":"01 / RECEIVING","sub":"Dock A + Dock B","x":64,"y":95,"width":293,"height":555},
+    {"id":"INDUCTION","name":"02 / INDUCTION","sub":"Metering + singulation","x":366,"y":95,"width":315,"height":555},
+    {"id":"SORTATION","name":"03 / SORTATION","sub":"Scan + divert logic","x":690,"y":95,"width":390,"height":555},
+    {"id":"DISPATCH","name":"04 / DISPATCH","sub":"Outbound destinations","x":1090,"y":95,"width":255,"height":555}
+  ],
+  "sections": [
+    {"id":"CV101","name":"Receiving Infeed A","area":"INBOUND","path":"M126 225 H330","label":[204,193],"upstream":[],"downstream":["CV103"],"rate":1120,"speed":36.4},
+    {"id":"CV102","name":"Receiving Infeed B","area":"INBOUND","path":"M126 462 H330","label":[204,495],"upstream":[],"downstream":["CV104"],"rate":1080,"speed":36.8},
+    {"id":"CV103","name":"Induction A","area":"INDUCTION","path":"M330 225 H418 Q456 225 482 304 H527","label":[414,191],"upstream":["CV101"],"downstream":["CV105"],"rate":1100,"speed":39.4},
+    {"id":"CV104","name":"Induction B","area":"INDUCTION","path":"M330 462 H418 Q456 462 482 375 H527","label":[410,497],"upstream":["CV102"],"downstream":["CV106"],"rate":1090,"speed":39.1},
+    {"id":"CV105","name":"Gapping A","area":"INDUCTION","path":"M527 304 H576 Q615 304 615 340","label":[552,270],"upstream":["CV103"],"downstream":["CV107"],"rate":1090,"speed":43.2},
+    {"id":"CV106","name":"Gapping B","area":"INDUCTION","path":"M527 375 H576 Q615 375 615 340","label":[550,412],"upstream":["CV104"],"downstream":["CV107"],"rate":1070,"speed":43.0},
+    {"id":"CV107","name":"Merge & Scan Tunnel","area":"SORTATION","path":"M615 340 H839","label":[727,307],"upstream":["CV105","CV106"],"downstream":["CV108"],"rate":2110,"speed":57.2},
+    {"id":"CV108","name":"Primary Sorter","area":"SORTATION","path":"M839 340 H992","label":[908,306],"upstream":["CV107"],"downstream":["CV109","CV111"],"rate":2040,"speed":61.5},
+    {"id":"CV109","name":"Sorter Transfer","area":"SORTATION","path":"M992 340 H1111","label":[1046,305],"upstream":["CV108"],"downstream":["CV110","CV112"],"rate":1800,"speed":60.0},
+    {"id":"CV110","name":"Exception Transfer","area":"DISPATCH","path":"M1111 340 H1293","label":[1220,306],"upstream":["CV109"],"downstream":["CV113"],"rate":280,"speed":40.0},
+    {"id":"CV111","name":"Outbound Lane 01","area":"DISPATCH","path":"M952 340 V215 H1278","label":[1172,178],"upstream":["CV108"],"downstream":[],"rate":750,"speed":41.2},
+    {"id":"CV112","name":"Outbound Lane 02","area":"DISPATCH","path":"M1068 340 V463 H1278","label":[1182,430],"upstream":["CV109"],"downstream":[],"rate":690,"speed":41.0},
+    {"id":"CV113","name":"Priority / Exceptions","area":"DISPATCH","path":"M1171 340 V565 H1278","label":[1201,536],"upstream":["CV110"],"downstream":[],"rate":270,"speed":32.1}
+  ]
+}