Signal Lab 1.0.0

Added

• Nine more languages. The interface, its tooltips and errors, the command
  line, the server's sign-in page and the installer now speak Spanish, French,
  German, Portuguese (Brazilian), Chinese (Simplified), Japanese, Korean, Hindi
  and Arabic besides English and Russian. Arabic mirrors the page right to left;
  addresses, hex dumps, code and the experiment canvas stay left to right.

• A language switch with flags. The header shows the current language's flag
  and letters and opens the list of every language, each by its flag and its own
  name; the arrows, a letter, Enter and Escape work in it.

• TCP impairment. The Impairment screen and the experiment's Impairment node
  take a protocol: over TCP each connection to the relay is joined to one of its
  own to the target, and both streams are delayed (in order, whatever the
  jitter), held to a bandwidth limit (the sender slows down; nothing is dropped),
  reset (both sides get a reset) or left half-open (nothing more goes through,
  and nobody is told), or paused while offline — every decision drawn from the
  seed. The presets have TCP versions; the screen counts connections, resets,
  half-open connections and how often a stream was held back; a run's report
  counts them per phase, and Change impairment switches a TCP relay too.

• Load on an HTTP node. An experiment's HTTP request can run under a
  profile — constant, ramp, steps, spike or random (Poisson) arrivals, up to
  100 000 requests a second and 512 at once — drawn in the properties before it
  runs. The step measures p50/p90/p95/p99, mean and slowest, the error rate, the
  rate achieved, answers by status or cause, each second and a latency histogram,
  and passes only when its thresholds hold (p95 < 300 ms, errors < 1 %):
  the first that does not fails it and says by how much. The timeline counts up
  every second; the properties show the result. Experiment files are version 9.

• Compare two runs. Compare in the timeline sets this run beside the one
  before it, or any earlier run of the experiment: each load step's metrics before
  and after, the change, a regression in red, and how each threshold went.
  signallab run prints each threshold's verdict and fails on one that does not
  hold (JUnit type="load.threshold"); MCP has list_runs and compare_runs;
  the API experiment_runs and experiment_compare. Run reports are version 5.

• The Inspector keeps whole frames. A frame keeps its bytes up to 256 KiB
  instead of the first KiB: the list still shows a preview, Show all brings every
  row, Save as signal replays a datagram of any size byte for byte (it refused
  anything over 1 KiB before), and both exports write every byte kept (.jsonl as
  base64 data). The capture holds up to 8192 frames and 64 MiB; a frame larger
  than it keeps says so.

• Several nodes at once in the experiment editor. Shift or Ctrl and a click
  adds a node to the selection, Shift and a drag on the empty canvas selects with a
  frame, Ctrl+A selects everything. The selection moves, duplicates (Ctrl+D) and
  deletes together, each one step to undo, and Ctrl+C, Ctrl+X, Ctrl+V copy, cut
  and paste it with the wires between its nodes — into another experiment or window
  too. A pasted node that names another copied node names the copy; a copied Emulator
  or Impairment listens on the next free port.

• Updates. The desktop app finds a newer version among the releases published on
  GitHub — once a day, or Check for updates in About — says what is new in it and
  installs it when asked: what is pending is saved, running jobs stop, the download's
  signature is checked against the key built into the app, and Signal Lab starts again
  as the new version (Windows: the setup or the MSI; Linux: the AppImage, .deb or
  .rpm). It asks the studio's hub, which offers a release to a share of installs
  first and can hold it back, and GitHub when the hub cannot be reached; the check
  tells the hub the version, the system and a random number of this install. Drafts,
  pre-releases and commits are never offered. A server updates with its image.

• About. Who makes Signal Lab — ProAnimaStudio, Ian Panaev — and how to reach them
  (info@proanima.net), the version, the source and the license; the ? in the header.

• Write to the developers. A form (the ✉ in the header, and in About): a
  message, an address for the answer, screenshots pasted with Ctrl+V, picked or dropped,
  and the console log and the version and system attached on their own — shown before
  sending, each removable, with this computer's name, its address and your folders left
  out. It goes to the studio's hub, which mails it from signal-labs@proanima.net to
  info@proanima.net; the mailbox's password is on the hub and never in the app — see
  docs/hub.md.

• Emulators: Signal Lab as the other side. A new Emulators screen plays the API,
  device or service your system talks to. An HTTP API answers by routes — method,
  a path with :name segments, conditions on headers, query, body or JSON — with
  responses in sequence (500, 500, then 200, for retries), in turn, or a seeded mix by
  weight, with delays, jitter and faults (no answer, a closed connection). An OSC,
  UDP or TCP device answers by rules: on this address, payload or line, reply
  that, to the sender or elsewhere, after a delay; a TCP device greets and can hang up.
  Replies are templates read with what arrived ({{request.params.id}},
  {{request.args[0]}}, {{request.json.name}}). Every exchange is counted per rule,
  listed as it happens and goes to the Inspector. A starter set (an API, an OSC, a UDP
  and a TCP device) is in the library, on loopback. Mock this on the HTTP screen turns
  a response into a route that answers exactly so.

• Emulators in experiments. The Emulator node serves for the whole run — open
  before the first step, closed with the run — and the report counts what it received.
  Wait for HTTP request waits for a request to it (or to a listener of the run that
  answers 204) by method, path and conditions, so an experiment proves that the system
  under test called it, and with what. An OSC or UDP emulator shares its port with the
  run's waits. The template Retry a flaky API shows it end to end (document version 6).

• Emulators everywhere. signallab emulate <file|name> runs emulators from a file or
  the app's library until Ctrl+C or --for, printing every request and the counts at the
  end (--json for one object per line, --server to run them on a lab server);
  signallab emulators lists the library. An assistant gets start_emulator,
  emulator_exchanges and list_emulators over MCP. The server's API has the same
  commands (emulator_start, emulator_exchanges, emulators_load, …).

• An MQTT broker of its own. An emulator can be an MQTT 3.1.1 broker: clients
  connect (with a user name and password, when it asks for one), subscribe with + and
  #, publish at QoS 0, 1 and 2; retained messages, last wills and a client id taking
  over its old connection work as on any broker. Rules make it a device too: on a message
  to lab/+/set, publish lab/{{request.levels[1]}}/state. MQTT gear and experiments
  with Wait for MQTT need no broker installed any more; a demo broker is in the library.

• Dependencies that flap and break. Any emulator can go down now and then — up for
  so long, down for so long, from the start: HTTP answers 503 with Retry-After (or
  closes, or holds the request), TCP devices and the broker drop and refuse connections,
  OSC and UDP devices go silent; what met an outage is counted apart. A response can be
  malformed: complete HTTP whose JSON stops halfway.

• Faults on a schedule. Three new nodes break things on cue. Impairment puts a
  UDP impairment relay in front of a device for the whole run (Route through
  impairment on an OSC or UDP node inserts one and points the node at it); Change
  impairment switches it to another profile mid-run; Emulator down/up takes one of
  the run's emulators down and brings it back. The relay's decisions come from the run's
  seed — the same seed drops the same packets — each phase is counted in the report, and
  a run that ends in any way closes its relays. Templates Fault phases and Dependency
  outage show both (document version 7; run reports version 4).

• More ways a network fails. The impairment relay adds bursts of loss, reordering, a
  bandwidth limit and offline, has presets (LAN, Busy Wi-Fi, 4G, Satellite,
  Intermittent, Offline), takes edits while it runs without dropping its port, and
  counts what it received, throttled and reordered. A running emulator can be taken down
  and brought up by hand on the Emulators screen, over the API (emulator_down) and by an
  assistant (set_emulator_down).

• WebSocket. A new WebSocket screen connects to ws:// and wss:// services with
  the headers and subprotocols they expect, sends text or bytes (Ctrl+Enter) and lists
  every message as it comes, JSON formatted, with the close handshake and who closed.
  Experiments get WebSocket connect, WebSocket send, Wait for WebSocket (any,
  contains, regex, hex; the message as {{reply.text}}, {{reply.json.field}}) and
  WebSocket close; a token extracted earlier can be in the URL or a header, and a run
  that ends in any way closes its connections with a proper close frame. Send now on a
  send or a wait opens the connection its connect node describes. The template WebSocket
  echo; signallab send ws <url> --text … --expect … and the assistant's send_ws;
  the API's ws_connect, ws_send, ws_close, ws_exchange. Experiment files are now
  version 8 — this release's last; files of every earlier version open as before.

• **A parameter matrix for the command l...

Signal Lab 0.3.1 (pre-release)

First pre-release. Functionally the same as 0.3.0 — the signal library and the
MQTT client — but built from the commit that fixes two job-telemetry races and
makes Stop actually stop the work. The 0.3.0 installers predated those fixes, so
a scan could report an empty table and Stop could leave traffic running.

Verified on this release build, each against an independent reference:

• Scanner — returns exactly the ports a separate connect-sweep finds (28/28 over 1–10000).
• Stop — measured with UDP sinks: storm 1740 packets while running → 0 after stop; impairment relay 5/5 forwarded → 0/5 after; scan progress freezes and the registry empties.
• HTTP — methods, headers, body, status codes, timeout, 500 KB body truncation; burst sends exactly N (confirmed by the target's own hit counter), runs workers concurrently, and ends on its duration.
• Broadcast — list fan-out, byte-exact text and hex payloads, CIDR sweep (network and broadcast addresses excluded), the 1024-host cap, multicast delivery to a real group member, beacon rate, and discovery auto-reply.
• Impairment — loss, duplication and corruption ratios match the profile; corruption flips exactly one bit; latency lands within tolerance.
• Inspector — protocol/direction/text filters, .jsonl and .txt export, and honest overflow accounting under a 20 000 pkt/s flood (31 602 captured, 27 352 reported as not shown).
• MQTT — against a real eclipse-mosquitto, with the reference JS client on the far end: retained-value scan, QoS 1/2 exactly once, retained clearing, last-will on drop.

cargo test 37/37, zero compiler warnings, layout clean at 1280 px and 980 px in both locales.

Limitations

• Windows x64 only; macOS and Linux are not built or tested.
• Installers are unsigned — SmartScreen will warn about an unknown publisher.
• Tested on one development machine; not yet verified on a clean Windows install.

Responsible use: Storm, Scanner and Broadcast generate real traffic and probe
real hosts. Point them only at equipment you own or are authorised to test.

SHA-256

• Signal Lab_0.3.1_x64-setup.exe — 92d10a62dfbe6859908734d23bb14135809b0901f937d3b3ec9d35798cdeb86d
• Signal Lab_0.3.1_x64_en-US.msi — 910a8275de102d0fe34ffbc772bc085672ef718cb1c1bc280f4096de8798bbb1