Cross-Language Feature Coverage

This is the canonical feature-coverage matrix for the lazily family. Each binding’s README reproduces it; this page is the source of truth. It is a status view (what each port ships today), distinct from the normative Binding Conformance Matrix, which fixes what every binding must eventually provide.

Legend: ✅ shipped · ~ partial · — absent · ⊘ not applicable (see notes).

The table below is generated from coverage.json by scripts/sync-coverage.mjs. Edit coverage.json and run make coverage-sync (or node scripts/sync-coverage.mjs) to update this table and every binding README in one shot; make coverage-check guards drift in CI.

Summary — family × language

Roll-up rule: a family cell is ✅ only when every required row in that family is ✅; ~ when the family is mixed (some shipped or partial); — when no required row is shipped or partial; ⊘ only when every required row in the family is not applicable. Rows the spec marks MAY (optional, shown as opt below) are excluded from the roll-up — declining an optional feature is not a gap.

Reactive graph

Materialization

Family sync

Statecharts

Keyed collections

Reactive queue

Broadcast topic

Work queue

CRDT data types

Lossless tree

Egress

Ingress

Wire codec

Transport & FFI

Message passing

Reliable sync

Durable owner

Durable capability tiers

Distributed plane

Causal receipts

Security boundary

Membership

Coordination

Presence

Temporal

Rate shaping

Windowing

Resilience

Portable stdlib

Service plane

Instrumentation

Convergence and the wire protocol are pinned by the shared conformance fixtures and JSON Schemas in this repo and the Lean models in lazily-formal.

Notes

• ᵃ Python reactive graph: Cell / Slot / Signal / Effect (sync) and the top-level batch(run) boundary ship; the != PartialEq memo guard applies to cells, slots, and signals. The async counterpart (AsyncEffect) queues reruns at the batch boundary for asyncio reactors.
• ᵇ Dart reactive graph: Context / Slot / Cell / Signal ship; there is no standalone Effect type (observers subscribe on cells) and batch is scoped to the async context.
• ᶜ Zig reactive graph: Cell / Slot / Signal / Effect and the public batch(run) boundary ship (context.zig coalesces the eager-recompute drain at the outermost batch exit).
• ᵈ Serialized context (JS / Dart) — decision: both are meaningful as serialized, realm-local execution flavors, not as shared-graph contexts. They are scored when their own surfaces replay the portable Core fixtures, and are excluded from cross-thread shared-graph stress/model-check tests. A duplicate wrapper is not sufficient by itself: unsupported Core features remain staged, and runner-local locks/dictionaries cannot stand in for them. Either binding may remove the flavor and declare it absent; while it advertises the flavor, it must join every feature peer group it actually supports. See protocol.md § Concurrency layers are required for the conditional layer requirement and reactive-graph.md § Declared context capabilities for the serialized / shared-graph distinction.
• ᵉ Zig async context: Zig removed language async and has no suspendable executor, so the layer is a task-queue + settle() drain surface — the synchronous graph’s pending_recompute/drainPendingRecompute generalized with revision tracking and the 4-state slot machine (async_context.zig).
• ᶠ Zig collections: SourceMap / ComputedMap with atomic move, SourceTree (per-level membership/order reactivity, atomic child move), and the LIS-move-minimized reconcile op-set all ship (collection.zig, cell_tree.zig, reconcile.zig).
• ᵍ Shared-memory blob path (JS / Dart): carry ShmBlobRef wire references but no host-side ShmBlobArena — the I/O-channel fallback of the shared-memory carve-out (see protocol.md § Shared-memory payload path is required).
• ʰ Dart distributed CRDT plane: the CrdtPlane engine (HLC / stamp frontier / stability watermark) ships, but is not yet wired to live merge: crdt root cells.
• ⁱ C-ABI FFI (JS): platform carve-out ffi = none — browser/Worker JS has no shared in-process C ABI. The full state plane (including CrdtSync) still flows over IPC / WebSocket / WebRTC (see protocol.md § C-ABI FFI is required).
• Distributed plane — WebRTC transport + signaling (Rust / Kotlin / JS / Zig): the portable stack (signaling protocol + client, the DataChannel seam, permission- filtering sink/source, in-memory loopback, and the CRDT plane runtime) ships and is conformance-tested; the concrete native WebRTC backend is a platform adapter (str0m in Rust; the browser RTCPeerConnection in JS; a consumer-provided seam in Kotlin and Zig), matching the reference design where the heavy transport is optional behind the seam.

1. Reactive graph — two cell kinds (nodes SourceCell / ComputedCell; handles Source<T, M> / Computed<T>) + Effect sink + eager Computed (computed().eager()) / all cells guarded / batch ↩

2. Thread-safe context (lock-backed) ↩

3. Async reactive context ↩

4. Merge algebra + Source<T, M> — associative MergePolicy (KeepLatest/Sum/Max/SetUnion/RawFifo), Cell ≡ Source<KeepLatest>, read-any-cell/write-Source split (#relaycell) ↩

5. Replay-equivalence harness — a log-bound fingerprint revalidated before any value compare, first-checkpoint divergence localization, canonical observation encoding (MAY, #lzreplayproof) ↩

6. Consumer simulation testkit — one materialized generated history through a deterministic in-memory baseline and explicitly selected real or external-process adapters, with per-action observation, history-prefix, and world-execution proof (MAY, #lzconsumerstestkit) ↩

7. Keyed-map materialization (ComputedMap) — mint-on-access derived slots: transparency + deferral (#lzmatmode) ↩

8. Thread-safe keyed map (ThreadSafeComputedMap) — Send + Sync + materialization confluence (#lzmatmode) ↩

9. Async keyed map (AsyncComputedMap) — eventual transparency (#lzmatmode) ↩

10. Keyed-map sync — membership propagation + materialize-on-ingest + derived-aggregate transparency (#lzfamilysync) ↩

11. Flat state machine ↩

12. Harel state charts ↩

13. Keyed reactive maps (ReactiveMap: SourceMap / ComputedMap) + SourceTree + reconcile ↩

14. ReactiveMap Core surface — single-threaded flavor (cell-model.md § Core surface vs. binding extensions) ↩

15. ReactiveMap Core surface — thread-safe flavor (ordering + membership reactivity) ↩

16. ReactiveMap Core surface — async flavor (ordering + membership reactivity) ↩

17. Exact-key dependency availability (DependencyMap: observe before publish, unrelated-key isolation, stable identity; #lzdependencyavailability) ↩

18. Atomic ordered move replayed against all three flavors (cellmap_atomic_move + cellmap_independence) ↩

19. Memoized semantic tree (SemTree) ↩

20. Stable-id alignment (manufactured identity) ↩

21. Reactive queue (QueueCell SPSC/MPSC + QueueStorage adapter) Core surface — single-threaded flavor ↩

22. Reactive queue (QueueCell SPSC/MPSC + QueueStorage adapter) Core surface — thread-safe flavor (reader kinds + closure lifecycle) ↩

23. Reactive queue (QueueCell SPSC/MPSC + QueueStorage adapter) Core surface — async flavor (reader kinds + eventual transparency) ↩

24. Broadcast topic (TopicCell) Core surface — single-threaded flavor — independent cursors + durable replay + safe GC (#lztopiccell) ↩

25. Broadcast topic (TopicCell) Core surface — thread-safe flavor (reader kinds + closure lifecycle) ↩

26. Broadcast topic (TopicCell) Core surface — async flavor (reader kinds + eventual transparency) ↩

27. Competing-consumer work queue (WorkQueueCell) Core surface — single-threaded flavor — exclusive leases + ack/nack + redelivery + DLQ (#lzworkqueue) ↩

28. Competing-consumer work queue (WorkQueueCell) Core surface — thread-safe flavor (reader kinds + closure lifecycle) ↩

29. Competing-consumer work queue (WorkQueueCell) Core surface — async flavor (reader kinds + eventual transparency) ↩

30. Free-text character CRDT (TextCrdt) ↩

31. TextCrdt delta sync (version_vector / delta_since / apply_delta) ↩

32. CrdtTree lossless document contract (#lzcrdttree) ↩

33. Move-aware sequence CRDT (SeqCrdt) ↩

34. Registers (LWW / MV) + PnCounter + CellCrdt ↩

35. Lossless tree CRDT core (LosslessTreeCrdt, M1) ↩

36. Lossless tree — dotted-frontier anti-entropy ↩

37. Lossless tree — concurrent merge convergence ↩

38. Transport-agnostic reactive egress (EgressCore) — monotone sequence assignment, bounded unacknowledged window, cumulative ACK watermark, bounded retry/backoff/exhaustion, producer-generation fence (#lzegress) ↩

39. Keyed latest durable projection (LatestDurableProjectionCore) — monotone caller epochs, one in-flight effect per key, pending-value supersession without false acknowledgement, monotone durable_through, retryable failure, and sink-generation fencing (#lzlatestdurableprojection) ↩

40. Egress family — Send + Sync flavor (ThreadSafeEgressCell): delivery authority stays in the shared core, one attached transport Effect per incarnation (#lzegress) ↩

41. Egress family — async flavor (AsyncEgressCell): the delivery-state readers stay synchronous Computeds; only the transport attachment is async-coloured (#lzegress) ↩

42. RelayCell — conflating relay + BackpressurePolicy + SpillStore + Transport + Inbox/Outbox + Rate/Window/Expiry/Priority/keyed policies (#relaycell) ↩

43. Transport-agnostic reactive ingress (IngressCell) — keyed lifecycle scopes, generation/sequence/freshness envelopes, reorder buffer, accepted/dropped/error receipt readers (#designimplementtransport) ↩

44. Ingress family — Send + Sync flavor (ThreadSafeIngressCell): one frontier walk per admission (#designimplementtransport) ↩

45. Ingress family — async flavor (AsyncIngressCell): admission is not async-coloured (#designimplementtransport) ↩

46. Boundary-ingress adapter (BoundaryIngressAdapter) — the non-reactive/reactive seam ahead of IngressCell: one monotone channel cursor per producer generation, snapshot-plus-event bootstrap applied as one batch, derived ReplayRequired(from) on a cursor gap, generation fence + hot resubscribe (#designimplementtransport) ↩

47. IPC wire — Snapshot + Delta + CrdtSync ↩

48. Frame codec — json reference codec: dependency-free interop floor, FFI baseline form, byte-canonical (MUST) — executable round-trip obligation (conformance/codec/frame_roundtrip_json.json, #lzmsgpackparity) ↩

49. Frame codec — msgpack cross-language binary default: externally-tagged frame over named-field maps, semantic (not byte-identical) round-trip (MUST) — executable round-trip obligation (conformance/codec/frame_roundtrip_msgpack.json, #lzmsgpackparity). Shipping a MessagePack codec does not earn this mark: lazily-cpp read ~ here while its private internally-tagged framing wore the token, and only flipped once it shipped the spec wire (#lzcppmsgpackwire) ↩

50. Frame codec — postcard positional same-schema fast path: smallest + byte-canonical, not cross-language (MAY) ↩

51. NodeId / PeerId exact-representation bound (MUST) — a decoder that cannot represent a received identifier exactly rejects the frame rather than rounding it (conformance/codec/nodeid_exact_range.json, #lzspecdecoderbound). A binding’s exact range MAY be narrower than the u64 wire type; ✅ means it refuses outside that range instead of substituting a neighbouring id, not that it carries the full u64. Exact ranges: full u64 in Rust / Zig / C#, unbounded in Python, [0, 2^63) in Kotlin / Go / C++, [0, 2^53) in JS, and platform-split in Dart (63-bit on the VM, 53-bit on web). protocol.md stated only the PRODUCER half until this audit, and two C++ decoders were substituting rather than refusing. ↩

52. NodeKey null-leniency on decode (MUST) — omit-when-absent binds the ENCODER; a decoder reads both an omitted key and an explicit key: null as absent, refusing neither and constructing a key from neither (conformance/codec/nodekey_null_leniency.json, #lzkeynullstrict). Replayed on BOTH optional-key sites (NodeSnapshot, the NodeAdd delta op) in both codecs, and the fixture pins the RE-ENCODED field set as well: reading null as absent and writing it back out is a correct decode with a non-conforming encoder. Before the audit lazily-py and lazily-zig refused the null form, and lazily-kt decoded it into a real key named null — all three had the same field right on CrdtOp, in the same file. ↩

53. Capability negotiation (SessionHandshake) ↩

54. Shared-memory blob path (ShmBlobArena) ↩

55. Cross-process zero-copy transport (BlobBackend / shm / arrow) ↩

56. C-ABI FFI boundary ↩

57. Message-passing + RPC command plane (command-plane-v1) ↩

58. Reliable sync — resync coordinator + at-least-once durable outbox + OR-set/LWW liveness (#lzsync) ↩

59. Storage-independent durable outbox (OutboxStore + shared outbox protocol; SQLite/Room/IndexedDB/file adapters) ↩

60. Reliable-sync transport seam + full-duplex SyncDriver loop (IpcSink/IpcSource, #sync-driver) ↩

61. Backend-neutral durable owner — ordered history or snapshot state, monotone positions, exact CAS/fencing, versioned payloads, atomic inbox/outbox/receipt boundary, crash recovery, and source-bound projection fingerprints (#lzdurablespec) ↩

62. Reactive graph plus typed state and decision semantics (#lzdurablefamily) ↩

63. Typed NATS envelope through an injected compatible transport; no durable-owner authority (#lzdurablefamily) ↩

64. Database-authoritative durable owner with atomic inbox/state/outbox/receipt boundary (#lzdurablefamily) ↩

65. Durable Host plus leased broker delivery/relay, recovery, drain, and poison disposition (#lzdurablefamily) ↩

66. Distributed Host plus bypassable Valkey acceleration with cache-loss equivalence (#lzdurablefamily) ↩

67. Distributed CRDT plane (CrdtPlaneRuntime / anti-entropy) ↩

68. Distributed plane — WebRTC transport + signaling ↩

69. State projection / mirror ↩

70. Causal receipts (CausalReceipts outcome projection) ↩

71. Permission boundary (PeerPermissions / RemoteOp) ↩

72. Membership + failure detection — MembershipCell (SWIM + Phi-accrual) / PeerSet / PeerChangeEvent (#lzmemb) ↩

73. Distributed coordination — LeaseCell / LeaderCell / LockCell / SemaphoreCell / BarrierCell+QuorumCell (#lzcoord) ↩

74. Presence + ephemeral plane — PresenceCell / AwarenessCell / EphemeralCell + Ephemeral/Durable markers (#lzpresence) ↩

75. Temporal sources — TimerCell / IntervalCell / CronCell / DeadlineCell over a logical clock (#lztime) ↩

76. Rate-shaping operators — DebounceCell / ThrottleCell / SampleCell / ProbabilisticSampleCell (#lzrateshape) ↩

77. Stream windowing — TumblingWindow / SlidingWindow / SessionWindow over the merge algebra (#lzwindow) ↩

78. Fault tolerance — CircuitBreakerCell / RetryPolicyCell / BulkheadCell / TimeoutCell (#lzresilience) ↩

79. Portable stdlib Timer (stdlib_timer_v1) — canonical fixture + mutation-gate verified ↩

80. Portable stdlib caller-driven Timeout<T> (stdlib_timeout_v1) — distinct from reactive TimeoutCell ↩

81. Portable stdlib RevisionBarrier (stdlib_revision_barrier_v1) — register/recheck lost-wakeup guard ↩

82. Embedded-service plane — HealthCell / ReadinessCell / DiscoveryCell / ServiceRegistry (#lzservice) ↩

83. Instrumentation / benchmarks ↩