Interface EngineTelemetry

Remarks

Each field is a snapshot count of an engine-internal collection or scalar at the moment the producing stats() call was made. The shape is intentionally flat — one counter per audit-relevant collection — so devtools consumers and bench leak gates can diff two records by field rather than walk a tree. All counts are non-negative integers; the lastCommitTime field is a GraphTime.

The fields map onto graph-internal state as follows:

Node-cardinality counters (#696):

• inputs — count of user-registered input nodes (excludes the engine-owned commitLog derived).
• deriveds — count of user-registered derived nodes (plain derived(...), liveDerived(...), and commitMetadataDerived(...); excludes the engine-owned commitLog derived).

Subscription counters (#757 first cut + #696 transient breakdown):

• subscribersTotal — size of the flat per-node subscriptions Set (one entry per live subscribe(node, observer) registration; each member of a subscribeMany(...) group contributes one entry).
• subscribersByNodeKeys — size of the per-node subscriber index Map (i.e., the number of distinct nodes with at least one live per-node subscription).
• transientSubscribers — count of live subscribe(...) / subscribeMany(...) registrations whose options.transient === true slot is set. A transient observer auto-disposes after its first Phase G fire (#766); this counter is the number of such registrations not yet fired (and therefore still pinned in subscriptions). On a steady-state graph this is almost always 0; a non-zero residual between commit boundaries means a transient registration is waiting for its first non-initial fire. The count is a WRAPPER fact on every engine, and #279 slice S3 is why this says so. { transient: true } does not cross the FFI — the BackendEngine.subscribe seam carries no options, so the facade hosts the one-shot itself — and the Rust core's transientSubscribers slot is structurally 0, which is the true count of what the ENGINE owns because no transient registration was ever made with it. That 0 was read as an engine defect for two waves. It is the count of a thing that lives in TypeScript, and the facade takes it.
• commitObservers — size of the subscribeCommits listener Set (one entry per live subscribeCommits(observer) registration; commit-bus observers are NOT counted in subscribersTotal). Under rust-ssot a registration crosses to the engine's own Set instead, and the facade reports the union of the two — keyed by function identity on both sides, so one function subscribed twice is one live observer whichever engine is running (#279).

Engine-internal index counters:

• commitMetadataDeriveds — size of the registered commitMetadataDerived id Set (#452 Phase F.5 seed set).
• commitLogConsumerCount — current value of the consumer counter that gates Phase F.4 commit-log refresh under commitHistoryCap > 0 (#715).
• entries — size of the canonical id → entry Map (registered nodes including the engine-owned commitLog derived; for user-only counts use inputs + deriveds).

Commit-history counters (#696):

• lastCommitTime — current GraphTime; equals 0 at engine genesis and advances by exactly 1 per successfully published commit. A failed commit leaves this byte-identical to its pre-commit value (atomicity rollback). Useful as the "did anything commit between snapshots?" predicate (after.lastCommitTime !== before.lastCommitTime).
• retainedCommits — current length of the bounded commitHistory ring (capped by commitHistoryCap; 0 when the engine was constructed with commitHistoryCap: 0, the post-#778 default).

Optional engine-status counters (audit-flagged, host-dependent):

• deopts — count of V8 deoptimisations attributed to the engine since construction. undefined when the host backend cannot surface this counter at runtime (the canonical TS engine does not wire --trace-deopt into its retained state; the bench harness captures this externally — see packages/bench/report/engine-status-deopts/SUMMARY.md). Future host-supported paths (e.g. a worker-side --trace-deopt adapter) may populate the field; the contract guarantees the field name, not its presence on every backend.
• gcPauses — count of GC pause events attributed to the engine since construction. undefined on the canonical TS engine for the same host-dependence reason as deopts. The WASM backend does not run inside a JS GC and SHOULD report gcPauses: 0 (linear-memory allocation is bump-pointer; "pauses" is not a Rust-side concept).