Relay 0.2.1 — Furnished schemas and cleaner installation

Relay 0.2.1

After publishing 0.2.0, I went through the project again from the point of view of somebody who
had not built it locally. The analyser was there, the wheel worked, and the report format had a
version—but an integration still had to infer the contract from examples. I thought too on that
point that “stable” should mean Relay can hand you the exact schema, not only tell you its number.

What I furnished

Relay now bundles two JSON Schemas:

• report validates machine-readable relay check --format json output with schema version
  2.0;
• config describes the data model produced by parsing relay.toml.

You can print either schema or write it atomically:

relay schema report --output relay-report.schema.json
relay schema config --output relay-config.schema.json

Oh! On this part, I kept runtime validation authoritative. The configuration schema is useful for
editors and CI, while Relay still checks relationships such as the aggregate byte limit being at
least as large as the per-file limit.

Installation and compatibility

The README now begins with a directly installable GitHub release wheel instead of treating an
editable development checkout as the normal installation path. The schemas are included inside
that wheel and tested through the installed command.

This patch also accepts supported pathspec 1.x releases while retaining a <2 upper bound. The
dependency update passed Relay’s complete Python 3.9–3.14 matrix before it was merged.

Clean repository state

The example commands create relay-report.md and timing-summary.md locally. Those generated
files no longer live in version control, and the documented root-level names are ignored so trying
Relay does not leave a dirty checkout.

Compatibility

• Relay runtime: Python 3.9–3.14
• Analysed languages: Python, C, C++, Arduino, JavaScript, TypeScript, Java, C#, Go, Rust,
  Kotlin, Swift, Ruby, and PHP
• JSON report schema: 2.0 (unchanged)
• SARIF: 2.1.0 (unchanged)
• Operation: local and offline after installation

This remains an alpha review assistant, not a compiler, scheduler simulator, hardware model, or
safety certification system. The patch makes Relay easier to install and integrate without making
its semantic claims any larger.

Relay 0.2.0 — Semantic recovery and polyglot review

Relay 0.2.0

This release started with a hard critique: Relay looked like a static analyser, but too many of
its conclusions came from names and structural patterns. I thought about that point carefully,
and the right response was not to soften the wording around the edges. The model itself needed to
be more honest and more useful.

The important correction

Relay 0.2.0 is a conservative source-review tool. Python uses its standard AST with file-local,
qualified symbols. C/C++, Arduino, JavaScript, TypeScript, Java, C#, Go, Rust, Kotlin, Swift,
Ruby, and PHP use explicitly labelled structural models. Those models are useful for direct
blocking patterns and local structure, but they are not compilers and their findings are capped
accordingly.

Every text, Markdown, JSON, and SARIF report now names the analysis model. Ambiguous method calls
are left unresolved instead of being collapsed into a convenient but potentially false path.

What now works differently

• await asyncio.sleep() is recognised as cooperative and is not reported as blocking.
• Python classes and nested functions keep qualified identities.
• C-family class and namespace methods no longer collapse solely because their basenames match.
• Known blocking waits are reviewed across the supported language profiles.
• Timeout checking uses actual Python keyword and positional argument structure.
  timeout=None is still missing; an unrelated argument containing the word “timeout” is not
  accepted.
• Durations can include arithmetic, signed values, common numeric suffixes, min/max, Go time
  units, and common duration constructors.
• A maximum-latency task is not automatically called emergency logic. Critical reachability
  requires safety_critical = true.
• Timing consequences are attached only to a task that can reach the wait. Execution contexts are
  recorded as user-supplied provenance.

Oh—and the old timeline name was too authoritative. relay summary now lists declared periods
and reachable waits without pretending to simulate release times, priorities, execution costs,
pre-emption, interrupts, cores, or deadline response time. The old command remains as a deprecated
alias for this release.

Operational hardening

• Symlink analysis roots are refused before resolution.
• Discovery has a 50 MB aggregate default in addition to per-file and file-count limits.
• Root .gitignore rules use Git wildmatch ordering, negation, rooted patterns, and directory
  semantics.
• Reports use atomic same-directory replacement and refuse source or symlink targets.
• Reproducibility verification builds the wheel and source archive twice and compares SHA-256
  digests.
• JSON schema 2.0 includes analysis models; SARIF includes stable finding fingerprints.

Compatibility

• Relay runtime: Python 3.9–3.14
• Analysed languages: Python, C, C++, Arduino, JavaScript, TypeScript, Java, C#, Go, Rust,
  Kotlin, Swift, Ruby, and PHP
• Operation: local and offline after installation
• Breaking report change: JSON schema version is now 2.0
• Configuration now rejects unknown keys and rule IDs

Install

python -m pip install relay_lint-0.2.0-py3-none-any.whl
relay --version
relay check .
relay summary . --duration 5s

Relay still cannot prove real-time or physical-machine safety. It is designed to make review
questions sharper—and to make the limits behind those questions impossible to miss.

Relay 0.1.2 — A more personal explanation

Relay 0.1.2

Relay started with a question I kept asking while reading control code: when a call waits here,
what quietly stops running somewhere else?

Version 0.1.2 tells that story more clearly. I rewrote the public documentation in the voice I
use when explaining the project to another person—direct, personal, and honest about what the
analysis can and cannot prove.

What changed

• The README now explains why I built Relay and walks through how an analysis works.
• Tutorials connect each command to the reason I would use it during a review.
• Architecture, configuration, timing, and limitation pages explain the decisions behind their
  technical details.
• Support, contributing, security, conduct, roadmap, and GitHub templates now sound like a
  maintainer speaking directly to a contributor.
• Commands, rule meanings, report formats, and safety boundaries remain precise and unchanged.

Oh—and that last point is important. This release changes how I explain Relay, not what Relay
claims to know. Findings are still conservative review prompts; timing values are still estimates;
and source is still analysed locally without being executed, imported, compiled, or uploaded.

How Relay works

Relay first discovers supported files within explicit bounds. It parses Python with the standard
AST and C-family sources with a position-preserving structural parser. From there, it identifies
blocking patterns, connects simple direct calls, and compares reachable delays with any timing
contracts you provide. The output keeps source facts, inferred paths, and timing estimates
separate so each conclusion can be reviewed.

Compatibility

• Python 3.9–3.14
• Arduino, ESP32, embedded C++, MicroPython, and Python sources
• Local and offline operation after installation
• No analyser rule, report schema, Python API, or CLI behaviour changes from 0.1.1

Install

python -m pip install relay_lint-0.1.2-py3-none-any.whl
relay --version
relay check examples

Relay does not guarantee real-time or physical-machine safety. Test every change on the actual
target before deployment.

Relay 0.1.1

Relay 0.1.1

Relay 0.1.1 is a maintenance and release-engineering update to the local-first alpha.

Highlights

• Package metadata and relay --version now use one version source.
• GitHub community health is complete with structured issue forms, pull-request guidance,
  ownership, support, conduct, security, and roadmap documentation.
• CI uses current official GitHub Actions and validates Python 3.9 through 3.14.
• Strict Mypy remains compatible with the declared Python 3.9 target.
• Dependabot maintains compatible dependencies without reopening an incompatible Mypy update.
• The public repository uses protected main, vulnerability alerts, automated security fixes,
  release checksums, and clean-wheel smoke tests.

Analyzer rules, finding severity, report schemas, and CLI behaviour are unchanged from 0.1.0.

Compatibility

• Python: 3.9–3.14
• Sources: .ino, .cpp, .cc, .cxx, .h, .hpp, .py, and .pyw
• Operation: local and offline after installation
• Runtime dependency on Python 3.9/3.10 only: tomli

Install

python -m pip install relay_lint-0.1.1-py3-none-any.whl
relay --version
relay check examples

Relay does not execute analysed source and does not guarantee real-time or physical-machine
safety. Verify findings and remediations on the actual target.

Relay 0.1.0

Changelog

0.1.0 — 2026-07-29

• Initial alpha release.
• Local structural analysis for Arduino, embedded C++, MicroPython, and Python.
• Fifteen stable rules, call paths, timing contracts, timeline estimates, four report formats,
  reviewable suggestions, public Python API, and security bounds.