@lazily-hub/lazily-js 0.18.0 → 0.20.0

package/BENCHMARKS.md

@@ -19,7 +19,7 @@ like-for-like single-process counterpart here and are intentionally omitted.
 
 <!-- benchmark-results:start -->
 
-Generated for package `@lazily-hub/lazily-js` version `0.6.0`.
+Generated for package `@lazily-hub/lazily-js` version `0.19.0`.
 
 Environment: Node.js `26.4.0` on `linux x64`.
 
@@ -33,16 +33,16 @@ Mean wall-clock time per iteration; 95% CI half-width from the standard error.
 
 | Group | Case | Mean | 95% CI | p75 | p99 | Samples |
 |---|---|---:|---:|---:|---:|---:|
-| cached_reads | context | 57.798 ns | ± 20.941 ns | 46.398 ns | 124.744 ns | 100 |
-| cold_first_get | context | 669.220 ns | ± 8.630 ns | 670.000 ns | 802.610 ns | 100 |
-| dependency_fan_out | context / 32 | 7.448 us | ± 824.968 ns | 6.783 us | 34.205 us | 100 |
-| dependency_fan_out | context / 256 | 43.766 us | ± 1.064 us | 43.270 us | 49.513 us | 100 |
-| set_cell_invalidation | high_fan_out / 512 | 10.737 us | ± 376.524 ns | 10.113 us | 17.141 us | 100 |
-| memo_equality_suppression | context | 2.387 us | ± 193.801 ns | 2.310 us | 2.864 us | 100 |
-| effect_flushing | context | 211.187 ns | ± 20.150 ns | 221.482 ns | 524.491 ns | 100 |
-| batch_storms | context / 64 | 30.430 us | ± 1.295 us | 30.815 us | 49.775 us | 99 |
-| typed_cache_reads | context_cell | 31.325 ns | ± 1.052 ns | 30.255 ns | 58.102 ns | 100 |
-| typed_cache_reads | context_slot | 120.262 ns | ± 4.805 ns | 118.099 ns | 220.409 ns | 100 |
+| cached_reads | context | 31.707 ns | ± 1.826 ns | 29.867 ns | 78.222 ns | 100 |
+| cold_first_get | context | 698.810 ns | ± 46.591 ns | 600.000 ns | 1.410 us | 100 |
+| dependency_fan_out | context / 32 | 5.263 us | ± 858.863 ns | 4.753 us | 16.289 us | 100 |
+| dependency_fan_out | context / 256 | 47.575 us | ± 3.908 us | 45.595 us | 132.218 us | 100 |
+| set_cell_invalidation | high_fan_out / 512 | 6.692 us | ± 3.311 us | 5.840 us | 111.143 us | 100 |
+| memo_equality_suppression | context | 2.546 us | ± 256.417 ns | 2.553 us | 5.435 us | 100 |
+| effect_flushing | context | 129.166 ns | ± 11.208 ns | 131.217 ns | 406.377 ns | 100 |
+| batch_storms | context / 64 | 12.092 us | ± 123.522 ns | 12.286 us | 14.168 us | 100 |
+| typed_cache_reads | context_cell | 33.701 ns | ± 2.005 ns | 32.755 ns | 55.480 ns | 100 |
+| typed_cache_reads | context_slot | 42.440 ns | ± 2.855 ns | 40.074 ns | 106.268 ns | 100 |
 
 <!-- benchmark-results:end -->
 

package/README.md

@@ -38,7 +38,7 @@ notes and platform carve-outs lives in
 <!-- coverage-table:start -->
 | Feature | Rust | Python | Kotlin | JS | Dart | Zig | Go | C++ |
 | --------- | :----: | :------: | :------: | :--: | :----: | :---: | :--: | :---: |
-| Reactive graph — `Cell` / `Slot` / `Signal` / `Effect` / memo / batch | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Reactive graph — core `Cell` / `Slot` / `Effect` (+ derived `Signal` = `Slot.eager`) / memo / batch | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Keyed-map materialization (`SlotMap`) — mint-on-access derived slots: transparency + deferral (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Thread-safe keyed map (`ThreadSafeSlotMap`) — `Send + Sync` + materialization confluence (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Async keyed map (`AsyncSlotMap`) — eventual transparency (`#lzmatmode`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -78,6 +78,14 @@ notes and platform carve-outs lives in
 | Permission boundary (`PeerPermissions` / `RemoteOp`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Capability negotiation (`SessionHandshake`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Instrumentation / benchmarks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Temporal sources — `TimerCell` / `IntervalCell` / `CronCell` / `DeadlineCell` over a logical clock (`#lztime`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Rate-shaping operators — `DebounceCell` / `ThrottleCell` / `SampleCell` / `ProbabilisticSampleCell` (`#lzrateshape`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Membership + failure detection — `MembershipCell` (SWIM + Phi-accrual) / `PeerSet` / `PeerChangeEvent` (`#lzmemb`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Distributed coordination — `LeaseCell` / `LeaderCell` / `LockCell` / `SemaphoreCell` / `BarrierCell`+`QuorumCell` (`#lzcoord`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Presence + ephemeral plane — `PresenceCell` / `AwarenessCell` / `EphemeralCell` + `Ephemeral`/`Durable` markers (`#lzpresence`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Stream windowing — `TumblingWindow` / `SlidingWindow` / `SessionWindow` over the merge algebra (`#lzwindow`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Fault tolerance — `CircuitBreakerCell` / `RetryPolicyCell` / `BulkheadCell` / `TimeoutCell` (`#lzresilience`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Embedded-service plane — `HealthCell` / `ReadinessCell` / `DiscoveryCell` / `ServiceRegistry` (`#lzservice`) | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 <!-- coverage-table:end -->
 
 Two JS ✅ marks are backed by runtime-specific mechanisms while keeping the core isomorphic:
@@ -119,10 +127,12 @@ JavaScript. The family is:
 
 - **Slot** - lazy, memoized derived value;
 - **Cell** - mutable source value;
-- **Signal** - eager derived value that re-materializes as soon as a dependency
-  invalidates;
 - **Effect** - side-effecting observer with cleanup.
 
+The core primitives are **Cell** / **Slot** / **Effect**. **`Signal` is a
+derived construct, not a core primitive** — `Signal ≡ Slot.eager`, a memo Slot
+plus a puller Effect that re-materializes as soon as a dependency invalidates.
+
 Dependencies are discovered dynamically while a slot/effect/signal computes.
 Invalidation is pull-based and glitch-free; `memo`/`Signal` use equality guards
 to suppress downstream work when a recompute produces the same value. `batch`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazily-hub/lazily-js",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Native JavaScript port of the lazily reactive core: a full reactive graph (Cell/Slot/Signal/Effect), sync/async/thread-safe keyed reactive maps (ReactiveMap/CellMap/SlotMap), the lazily-spec IPC wire types + C-ABI FFI boundary (isomorphic channel + Node native binding), keyed cell collections + LIS reconciliation, the memoized semantic tree, the move-aware sequence CRDT, the Fugue/RGA text CRDT, manufactured text identity, full-Harel state charts, an FFI state-projection consumer, and an in-library instrumentation/benchmark API.",
   "license": "MIT",
   "repository": {
@@ -77,6 +77,38 @@
       "types": "./src/relay.d.ts",
       "default": "./src/relay.js"
     },
+    "./temporal": {
+      "types": "./src/temporal.d.ts",
+      "default": "./src/temporal.js"
+    },
+    "./rateshape": {
+      "types": "./src/rateshape.d.ts",
+      "default": "./src/rateshape.js"
+    },
+    "./membership": {
+      "types": "./src/membership.d.ts",
+      "default": "./src/membership.js"
+    },
+    "./coordination": {
+      "types": "./src/coordination.d.ts",
+      "default": "./src/coordination.js"
+    },
+    "./presence": {
+      "types": "./src/presence.d.ts",
+      "default": "./src/presence.js"
+    },
+    "./windowing": {
+      "types": "./src/windowing.d.ts",
+      "default": "./src/windowing.js"
+    },
+    "./resilience": {
+      "types": "./src/resilience.d.ts",
+      "default": "./src/resilience.js"
+    },
+    "./service": {
+      "types": "./src/service.d.ts",
+      "default": "./src/service.js"
+    },
     "./sem-tree": {
       "types": "./src/sem-tree.d.ts",
       "default": "./src/sem-tree.js"
@@ -116,7 +148,7 @@
     }
   },
   "scripts": {
-    "build": "node --check src/index.js && node --check src/transport.js && node --check src/shm-backend.js && node --check src/reactive.js && node --check src/reactive-async.js && node --check src/reactive-family.js && node --check src/async-reactive-family.js && node --check src/thread-safe.js && node --check src/thread-safe-reactive-family.js && node --check src/ffi.js && node --check src/ffi-node.js && node --check src/instrumentation.js && node --check src/state-machine.js && node --check src/statechart.js && node --check src/collections.js && node --check src/queue.js && node --check src/merge.js && node --check src/relay.js && node --check src/sem-tree.js && node --check src/stable-id.js && node --check src/seq-crdt.js && node --check src/text-crdt.js && node --check src/indexeddb-outbox.js && node --check src/utf8-offsets.js && node --check src/lossless-tree-crdt.js && node --check src/state-projection.js && node --check src/graph-view.js && node --check src/signaling.js && node --check src/distributed.js",
+    "build": "node --check src/index.js && node --check src/transport.js && node --check src/shm-backend.js && node --check src/reactive.js && node --check src/reactive-async.js && node --check src/reactive-family.js && node --check src/async-reactive-family.js && node --check src/thread-safe.js && node --check src/thread-safe-reactive-family.js && node --check src/ffi.js && node --check src/ffi-node.js && node --check src/instrumentation.js && node --check src/state-machine.js && node --check src/statechart.js && node --check src/collections.js && node --check src/queue.js && node --check src/merge.js && node --check src/relay.js && node --check src/rateshape.js && node --check src/membership.js && node --check src/coordination.js && node --check src/presence.js && node --check src/windowing.js && node --check src/resilience.js && node --check src/service.js && node --check src/temporal.js && node --check src/sem-tree.js && node --check src/stable-id.js && node --check src/seq-crdt.js && node --check src/text-crdt.js && node --check src/indexeddb-outbox.js && node --check src/utf8-offsets.js && node --check src/lossless-tree-crdt.js && node --check src/state-projection.js && node --check src/graph-view.js && node --check src/signaling.js && node --check src/distributed.js",
     "test:formal": "node scripts/formal-check.mjs",
     "bench": "node bench/context.bench.mjs",
     "bench:scale": "node --max-old-space-size=8192 bench/scale.bench.mjs",

package/src/coordination.d.ts

@@ -0,0 +1,81 @@
+// Distributed coordination (#lzcoord) — the JS port.
+// See coordination.js and `lazily-spec/docs/coordination.md`.
+
+import type { Context, CellHandle } from "./reactive.js";
+
+export class LeaseCore<P = unknown> {
+  fence: number;
+  isHeld(now: number): boolean;
+  holder(now: number): P | null;
+  acquire(peer: P, now: number, ttl: number): number | null;
+  renew(peer: P, now: number, ttl: number): boolean;
+  release(peer: P): void;
+  tick(now: number): boolean;
+}
+
+export class LeaseCell<P = unknown> {
+  constructor(ctx: Context);
+  readonly holderCell: CellHandle<P | null>;
+  acquire(peer: P, now: number, ttl: number): number | null;
+  renew(peer: P, now: number, ttl: number): boolean;
+  release(peer: P, now: number): void;
+  tick(now: number): boolean;
+  holder(now: number): P | null;
+  isHeld(now: number): boolean;
+  fence(): number;
+}
+
+export type LeaderRoleLabel = "Leader" | "Follower" | "Candidate";
+export const LeaderRole: Readonly<{ Leader: "Leader"; Follower: "Follower"; Candidate: "Candidate" }>;
+
+export class LeaderCell<P = unknown> {
+  constructor(ctx: Context, me: P);
+  readonly currentLeaderCell: CellHandle<P | null>;
+  campaign(now: number, ttl: number): LeaderRoleLabel;
+  contend(peer: P, now: number, ttl: number): LeaderRoleLabel;
+  tick(now: number): LeaderRoleLabel;
+  currentLeader(now: number): P | null;
+  role(now: number): LeaderRoleLabel;
+}
+
+export class LockCell<P = unknown> {
+  constructor(ctx: Context);
+  readonly isLockedCell: CellHandle<boolean>;
+  acquire(peer: P, now: number, ttl: number): number | null;
+  release(peer: P, now: number): void;
+  tick(now: number): boolean;
+  validate(fence: number): boolean;
+  isLocked(now: number): boolean;
+  fence(): number;
+}
+
+export class SemaphoreCore {
+  constructor(capacity: number);
+  available(): number;
+  acquire(): boolean;
+  release(): void;
+}
+
+export class SemaphoreCell {
+  constructor(ctx: Context, capacity: number);
+  readonly permitsAvailableCell: CellHandle<number>;
+  acquire(): boolean;
+  release(): void;
+  permitsAvailable(): number;
+}
+
+export class BarrierCore<P = unknown> {
+  constructor(required: number);
+  arrive(peer: P): boolean;
+  count(): number;
+  isOpen(): boolean;
+}
+
+export class BarrierCell<P = unknown> {
+  constructor(ctx: Context, required: number);
+  static quorum<P = unknown>(ctx: Context, total: number): BarrierCell<P>;
+  readonly isOpenCell: CellHandle<boolean>;
+  arrive(peer: P): boolean;
+  count(): number;
+  isOpen(): boolean;
+}

package/src/coordination.js

@@ -0,0 +1,283 @@
+// Distributed coordination (#lzcoord) — the JS port.
+//
+// See `lazily-spec/docs/coordination.md` and the formal model
+// `lazily-formal/LazilyFormal/Coordination.lean`. Lease / leader / lock /
+// semaphore / barrier + quorum primitives, each a pure compute core split from a
+// reactive cell projecting the salient reader. Time is the logical clock. A
+// holder of `null` means "no holder".
+
+// ---------------------------------------------------------------------------
+// Lease + fencing token
+// ---------------------------------------------------------------------------
+
+/** Single-writer lease authority with a monotone fencing token. */
+export class LeaseCore {
+  constructor() {
+    this.holderPeer = null;
+    this.expiry = 0;
+    this.fence = 0;
+  }
+  #isExpired(now) {
+    return this.holderPeer !== null && now >= this.expiry;
+  }
+  isHeld(now) {
+    return this.holderPeer !== null && !this.#isExpired(now);
+  }
+  holder(now) {
+    return this.isHeld(now) ? this.holderPeer : null;
+  }
+  acquire(peer, now, ttl) {
+    if (this.holderPeer === null || this.#isExpired(now)) {
+      this.fence += 1;
+      this.holderPeer = peer;
+      this.expiry = now + ttl;
+      return this.fence;
+    }
+    if (this.holderPeer === peer) {
+      this.expiry = now + ttl; // renew keeps fence
+      return this.fence;
+    }
+    return null;
+  }
+  renew(peer, now, ttl) {
+    if (this.isHeld(now) && this.holderPeer === peer) {
+      this.expiry = now + ttl;
+      return true;
+    }
+    return false;
+  }
+  release(peer) {
+    if (this.holderPeer === peer) this.holderPeer = null;
+  }
+  tick(now) {
+    if (this.#isExpired(now)) {
+      this.holderPeer = null;
+      return true;
+    }
+    return false;
+  }
+}
+
+/** Reactive lease: projects the holder onto a cell. */
+export class LeaseCell {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.core = new LeaseCore();
+    this.holderCell = ctx.cell(null);
+  }
+  #refresh(now) {
+    this.ctx.setCell(this.holderCell, this.core.holder(now));
+  }
+  acquire(peer, now, ttl) {
+    const r = this.core.acquire(peer, now, ttl);
+    this.#refresh(now);
+    return r;
+  }
+  renew(peer, now, ttl) {
+    const r = this.core.renew(peer, now, ttl);
+    this.#refresh(now);
+    return r;
+  }
+  release(peer, now) {
+    this.core.release(peer);
+    this.#refresh(now);
+  }
+  tick(now) {
+    const r = this.core.tick(now);
+    this.#refresh(now);
+    return r;
+  }
+  holder(now) {
+    return this.core.holder(now);
+  }
+  isHeld(now) {
+    return this.core.isHeld(now);
+  }
+  fence() {
+    return this.core.fence;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Leader / follower / candidate
+// ---------------------------------------------------------------------------
+
+export const LeaderRole = Object.freeze({
+  Leader: "Leader",
+  Follower: "Follower",
+  Candidate: "Candidate",
+});
+
+/** Reactive leadership over a lease from node `me`'s perspective. */
+export class LeaderCell {
+  constructor(ctx, me) {
+    this.ctx = ctx;
+    this.me = me;
+    this.core = new LeaseCore();
+    this.currentLeaderCell = ctx.cell(null);
+  }
+  #refresh(now) {
+    this.ctx.setCell(this.currentLeaderCell, this.core.holder(now));
+  }
+  campaign(now, ttl) {
+    this.core.acquire(this.me, now, ttl);
+    this.#refresh(now);
+    return this.role(now);
+  }
+  contend(peer, now, ttl) {
+    this.core.acquire(peer, now, ttl);
+    this.#refresh(now);
+    return this.role(now);
+  }
+  tick(now) {
+    this.core.tick(now);
+    this.#refresh(now);
+    return this.role(now);
+  }
+  currentLeader(now) {
+    return this.core.holder(now);
+  }
+  role(now) {
+    const h = this.core.holder(now);
+    if (h === null) return LeaderRole.Candidate;
+    return h === this.me ? LeaderRole.Leader : LeaderRole.Follower;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Distributed lock + fencing
+// ---------------------------------------------------------------------------
+
+/** Reactive distributed mutex over a lease + fencing token. */
+export class LockCell {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.core = new LeaseCore();
+    this.isLockedCell = ctx.cell(false);
+  }
+  #refresh(now) {
+    this.ctx.setCell(this.isLockedCell, this.core.isHeld(now));
+  }
+  acquire(peer, now, ttl) {
+    const r = this.core.acquire(peer, now, ttl);
+    this.#refresh(now);
+    return r;
+  }
+  release(peer, now) {
+    this.core.release(peer);
+    this.#refresh(now);
+  }
+  tick(now) {
+    const r = this.core.tick(now);
+    this.#refresh(now);
+    return r;
+  }
+  /** Whether `fence` is the current (non-stale) fencing token. */
+  validate(fence) {
+    return this.core.fence === fence;
+  }
+  isLocked(now) {
+    return this.core.isHeld(now);
+  }
+  fence() {
+    return this.core.fence;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Semaphore
+// ---------------------------------------------------------------------------
+
+/** Bounded permit pool compute core. */
+export class SemaphoreCore {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.acquired = 0;
+  }
+  available() {
+    return this.capacity - this.acquired;
+  }
+  acquire() {
+    if (this.acquired < this.capacity) {
+      this.acquired += 1;
+      return true;
+    }
+    return false;
+  }
+  release() {
+    if (this.acquired > 0) this.acquired -= 1;
+  }
+}
+
+/** Reactive semaphore: projects permitsAvailable onto a cell. */
+export class SemaphoreCell {
+  constructor(ctx, capacity) {
+    this.ctx = ctx;
+    this.core = new SemaphoreCore(capacity);
+    this.permitsAvailableCell = ctx.cell(capacity);
+  }
+  #refresh() {
+    this.ctx.setCell(this.permitsAvailableCell, this.core.available());
+  }
+  acquire() {
+    const r = this.core.acquire();
+    this.#refresh();
+    return r;
+  }
+  release() {
+    this.core.release();
+    this.#refresh();
+  }
+  permitsAvailable() {
+    return this.ctx.getCell(this.permitsAvailableCell);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Barrier / quorum
+// ---------------------------------------------------------------------------
+
+/** Wait-for-N gate over distinct arriving peers. */
+export class BarrierCore {
+  constructor(required) {
+    this.required = required;
+    this.arrived = new Set();
+  }
+  arrive(peer) {
+    this.arrived.add(peer);
+    return this.isOpen();
+  }
+  count() {
+    return this.arrived.size;
+  }
+  isOpen() {
+    return this.count() >= this.required;
+  }
+}
+
+/** Reactive wait-for-N gate. A quorum is a barrier with required = total/2 + 1. */
+export class BarrierCell {
+  constructor(ctx, required) {
+    this.ctx = ctx;
+    this.core = new BarrierCore(required);
+    this.isOpenCell = ctx.cell(this.core.isOpen());
+  }
+  /** A quorum gate: opens at strict majority of `total`. */
+  static quorum(ctx, total) {
+    return new BarrierCell(ctx, Math.floor(total / 2) + 1);
+  }
+  #refresh() {
+    this.ctx.setCell(this.isOpenCell, this.core.isOpen());
+  }
+  arrive(peer) {
+    const r = this.core.arrive(peer);
+    this.#refresh();
+    return r;
+  }
+  count() {
+    return this.core.count();
+  }
+  isOpen() {
+    return this.ctx.getCell(this.isOpenCell);
+  }
+}

package/src/membership.d.ts

@@ -0,0 +1,52 @@
+// Membership + failure detection (#lzmemb) — the JS port.
+// See membership.js and `lazily-spec/docs/membership.md`.
+
+import type { Context, CellHandle } from "./reactive.js";
+
+export type PeerStateLabel = "Alive" | "Suspect" | "Dead" | "Left";
+export const PeerState: Readonly<{
+  Alive: "Alive";
+  Suspect: "Suspect";
+  Dead: "Dead";
+  Left: "Left";
+}>;
+
+export interface MembershipConfig {
+  phiThreshold: number;
+  suspectTimeout: number;
+  maxSamples: number;
+  minStd: number;
+}
+export const defaultMembershipConfig: Readonly<MembershipConfig>;
+
+export type PeerChangeEvent<P> =
+  | { type: "Joined"; peer: P }
+  | { type: "Left"; peer: P }
+  | { type: "StateChanged"; peer: P; from: PeerStateLabel; to: PeerStateLabel };
+
+export class PhiAccrual {
+  constructor(maxSamples: number, minStd: number);
+  heartbeat(now: number): void;
+  phi(now: number): number;
+}
+
+export class MembershipCore<P = unknown> {
+  constructor(config?: Partial<MembershipConfig>);
+  aliveSet(): P[];
+  state(peer: P): PeerStateLabel | null;
+  join(peer: P, now: number): PeerChangeEvent<P>[];
+  heartbeat(peer: P, now: number): PeerChangeEvent<P>[];
+  leave(peer: P, now: number): PeerChangeEvent<P>[];
+  tick(now: number): PeerChangeEvent<P>[];
+}
+
+export class MembershipCell<P = unknown> {
+  constructor(ctx: Context, config?: Partial<MembershipConfig>);
+  readonly peerSetCell: CellHandle<P[]>;
+  join(peer: P, now: number): PeerChangeEvent<P>[];
+  heartbeat(peer: P, now: number): PeerChangeEvent<P>[];
+  leave(peer: P, now: number): PeerChangeEvent<P>[];
+  tick(now: number): PeerChangeEvent<P>[];
+  peerSet(): P[];
+  state(peer: P): PeerStateLabel | null;
+}