XO 0.3.0

XO 0.3.0 — Python ↔ JavaScript semantic parity

XO 0.3.0 makes Python and JavaScript full peers for canonical state operations while preserving explicit host-only boundaries for executable policy such as formulas, validators, history, persistence, services, and transport serving.

Added

• JavaScript clear-value, subtree restore, ordered traversal, containment, default reads, path-scoped subscriptions, and atomic multi-operation transactions.
• A durable LANGUAGE_SUPPORT.md release gate mapping current language capabilities, host-versus-protocol boundaries, and the admission contract for future Bash, PowerShell, Mojo, Rust, C, C++, Go, Zig, and Ruby bindings.
• A shared language fixture consumed by Python and JavaScript.
• A real two-process Python↔JavaScript test proving both runtimes can read and write one live XO namespace in both directions.

Fixed

• Authoritative snapshot installation keeps the canonical Python root handle live.
• Python integers outside JavaScript's exact safe range fail closed at the language bridge rather than arriving with silent precision loss.
• JavaScript fatal protocol/codec failures retain the original error instead of being overwritten by a generic close event.

Verified

• Python: 121 passed, 1 intentionally skipped without a disposable Redis URL; strict thread-warning mode passed.
• JavaScript: 9 passed, 53 assertions.
• Live parity: Python and Bun exchanged values, bytes, fixed sequences, set, clear, delete, subtree restore, an atomic four-operation transaction, and subsequent Python writes over one namespace.
• Static gates: Ruff, Python compilation, and Node syntax passed.
• Portable performance: all six budgets passed.
• Python wheel/source distribution and JavaScript dry-pack passed.

XO 0.2.3

XO 0.2.3 — promise and disconnect hardening

XO 0.2.3 closes production-boundary defects found in a fresh audit of the JavaScript write API, RPC disconnect cleanup, and registry publication gates.

Fixed

• Keep explicit JavaScript writes promise-stable when value encoding or socket sends fail.
• Surface JavaScript assignment and delete failures through subscription error changes instead of unhandled promise rejections.
• Reject unsafe JavaScript integers before transport so Python/JavaScript state cannot silently lose numeric precision.
• Treat client disconnects during RPC stream termination as normal cleanup instead of leaking worker-thread exceptions.
• Paginate GitHub check runs before package publication so tags with more than 100 checks cannot bypass required-check verification.

Verified

• Python: 115 passed, 1 intentionally skipped without Redis; strict thread-warning mode passed.
• Real Redis contract: 24 passed.
• JavaScript: 7 passed, 30 assertions.
• Python 3.11, 3.12, 3.13, and 3.14 clean-package verification passed.
• Canonical Apple M3 Max performance gate passed all six budgets.
• Built v0.2.3 wheel installed into a clean environment and passed the package smoke scenario.
• Python wheel/source distribution and JavaScript dry-pack passed.

XO 0.2.2

XO 0.2.2 — production protocol hardening

XO 0.2.2 closes production-boundary defects found in an adversarial audit of the released v0.2.1 protocol, persistence, lifecycle, and publication paths.

Fixed

• Reject boolean, fractional, non-finite, zero, and negative resource limits or durations before opening Redis, RPC, or WebSocket resources.
• Cancel and retire expired RPC streams rather than retaining pending requests until connection shutdown.
• Reset JavaScript WebSocket message IDs on reconnect so valid new sessions beginning at message one remain interoperable.
• Use kernel-assigned TCP endpoints in the complete fusion test, removing stale and overlong Unix socket collisions.

Release integrity

• CI now includes a real Redis 7 integration job.
• Registry workflows require an explicit existing release tag, verify the complete Python 3.11–3.14 Linux/macOS matrix, JavaScript job, and Redis integration check on that tag commit, then publish that exact tag.

Verified

• Python: 115 passed, 1 intentionally skipped without Redis; real Redis contract: 24 passed.
• JavaScript: 5 passed, 22 assertions.
• Python 3.11, 3.12, 3.13, and 3.14 clean-package verification passed.
• Canonical Apple M3 Max performance gate passed all six budgets.
• Built wheel installed into a clean environment and passed the package smoke scenario.

XO 0.2.1

XO 0.2.1 — portable performance gates

XO 0.2.1 corrects the release automation discovered by the first v0.2.0 matrix run. The canonical Apple M3 Max budgets remain unchanged; heterogeneous shared CI runners now use explicit portable ceilings for the two host-sensitive measurements.

Fixed

• Kept canonical regression ceilings at 25 ms for import and 2 µs for clean formula reads on the reference workstation.
• Added a portable CI profile with 50 ms import and 5 µs clean-formula ceilings, derived from the observed Python 3.11–3.14 Ubuntu/macOS matrix while retaining the same root, lookup, and mutation ceilings.
• Kept local and CI profiles executable through the same benchmark command rather than suppressing or skipping the gate.

Verification

• Python: 87 contracts collected; 86 passed and one disposable-Redis test skipped without XO_TEST_REDIS_URL.
• Real Redis: all 11 Redis contracts passed against a dedicated loopback Redis server.
• JavaScript: 4 tests, 19 assertions, zero failures.
• Canonical M3 Max gate: 18.07 ms import, 1.97 µs root creation, 0.35 µs existing read, 1.46 µs scalar set, 1.83 µs five-segment set, and 1.68 µs clean formula read; zero failures.
• Published-channel install will be verified from the v0.2.1 wheel before this release is called complete.

Version 0.2.1 contains the complete v0.2 capability-fusion release plus this CI portability correction. PyPI and npm remain intentionally unclaimed until their publisher environments and post-publication installs are verified.

XO 0.2.0

XO 0.2.0 — the boundaries join the root

XO 0.2.0 closes the last integration gaps around the unified state graph: RPC now participates in capability composition, browser writes enter the same canonical mutation pipeline as Python writes, and the complete profile is exercised as one root with one revision.

What changed

• Added root-scoped rpc_server() composition over the same allow-listed ServiceRegistry used by local calls.
• Made writable WebSocket prefixes commit through XO directly by default; explicit callbacks remain policy hooks.
• Extended XO.recommended() and Profile.hybrid() with explicit service transports and projections.
• Added a full-fusion contract covering validation, branch-preserving history, strict durability, projection observers, RPC, and WebSocket on one root.
• Added executable architecture budgets to CI and the Python runtime matrix.

Verification

• Python: 87 contracts collected; 86 passed and one disposable-Redis test skipped without XO_TEST_REDIS_URL.
• Real Redis: all 11 Redis contracts passed against a dedicated loopback Redis server.
• JavaScript: 4 tests, 19 assertions, zero failures.
• Static gates: Ruff and Python bytecode compilation passed.
• Build: Python wheel/source distribution and JavaScript package dry-pack passed.
• Architecture budgets on Apple M3 Max: 17.58 ms import, 1.95 µs root creation, 0.37 µs existing read, 1.48 µs scalar set, 1.67 µs five-segment set, and 1.55 µs clean formula read; every enforced budget passed.

Compatibility

The canonical state/event model is unchanged. Version 0.2.0 is a feature release because it adds public composition APIs and changes writable WebSocket prefixes from callback-required to canonical-by-default. Custom write callbacks remain supported for authorization and policy.

The original 2021 implementation remains preserved on legacy-2021. See ARCHITECTURE.md for the exact capability and mutation contracts.

Package channels

The GitHub release contains installable Python artifacts. PyPI and npm remain intentionally unclaimed until their publisher environments are authorized and installs from those registries are verified.

XO 0.1.0 — one state graph, every boundary

XO 0.1.0 — one state graph, every boundary

XO's first unified release preserves the interaction that made the original experiments exceptional—one path can hold a value and children—while rebuilding every surrounding capability on one bounded contract.

What ships

• Dependency-free Python state graph with fluent paths, immutable events, transactions, snapshots, and subscriptions.
• Lazy formulas with dynamic read dependencies, cache invalidation, cycle detection, and single-flight evaluation.
• Deterministic capability fusion for validation, history, services, strict durability, and projections.
• Direct RESP Redis durability and replication with compare-and-swap and explicit ambiguous-outcome recovery.
• Allow-listed local RPC with deadlines, cancellation, bounded frames, and credit-controlled streams.
• Scoped WebSocket synchronization plus a dependency-free JavaScript Proxy peer.
• Compatibility facades for observed historical XO constructors, with unsafe prototype behaviors rejected explicitly.
• xo inspect, xo doctor, xo benchmark, and xo serve CLI commands.

Verification

• Python: 84 contracts collected; 83 passed and one disposable-Redis test skipped without XO_TEST_REDIS_URL.
• Real Redis: dedicated loopback integration scenario passed.
• JavaScript: 4 tests, 19 assertions, zero failures.
• Runtime matrix: clean package install and end-to-end scenario on Python 3.11, 3.12, 3.13, and 3.14.
• Build: Python wheel/source distribution and JavaScript package dry-pack passed.
• Performance on Apple M3 Max / Python 3.12.3: 0.325 µs existing read, 1.627 µs scalar set, 1.592 µs cached formula read (100,000 operations × 15 rounds, median).

Lineage

The original 2021 implementation is preserved on the legacy-2021 branch. Version 0.1.0 is a clean semantic refoundation rather than a bug-for-bug port. See origins.md, PRODUCT.md, and ARCHITECTURE.md for the recovered intent, product boundary, and exact contracts.

Package channels

The release contains installable Python artifacts. PyPI and JavaScript registry publication workflows are prepared for trusted publishing; those channels become live after their respective registry environments are authorized.