observedCertificates, observedCodecs, observedDataChannels,
observedIceCandidates, observedIceCandidatesPair, observedIceTransports,
observedInboundRtps, observedInboundTracks, observedMediaPlayouts,
observedMediaSources, observedOutboundRtps, observedOutboundTracks,
observedPeerConnectionTransports, observedRemoteInboundRtps, observedRemoteOutboundRtps

new Observer<AppData>(config?: ObserverConfig<AppData>)

type ObserverConfig<AppData = Record<string, unknown>> = {
    // a call updates when any client does; the observer when any call does. Default true.
    autoUpdateOnCallUpdate?: boolean;
    appData?: AppData;
    closeClientIfIdleForMs?: number;
    closeCallIfEmptyForMs?: number;

    // accumulate a per-call summary. Absent or null = off, and nothing subscribes
    // to anything. `{}` is valid: a summary with no built-in sections.
    callSummary?: Partial<CallSummaryConfig> | null;

    // appData factories — run when an entity is created without explicit appData
    // (including lazily by accept()). The accept context is offered, never written across.
    createCallAppData?: (p: { callId: string; observer: Observer; acceptCtx?: AcceptContext }) => Record<string, unknown>;
    createClientAppData?: (p: { clientId: string; observedCall: ObservedCall; acceptCtx?: AcceptContext }) => Record<string, unknown>;

    // per-client sink factory
    createClientSink?: (p: { clientId: string; observedCall: ObservedCall }) => ClientSampleSink | undefined;

    // a call's RemoteTrackResolver
    createRemoteTrackResolver?: (observedCall: ObservedCall) => RemoteTrackResolver | undefined;
};

observer.accept(sample, context?);

observer.addAcceptMiddleware(...mw);      // global pre-dispatch hooks
observer.removeAcceptMiddleware(...mw);

observer.getObservedCall<T>(callId);
observer.createObservedCall<T>(settings, acceptCtx?);
observer.getOrCreateObservedCall<T>(settings, acceptCtx?);

observer.addIssue(issue);                 // observer-level finding → 'observer-issue'; `scope` is stamped
observer.update();                        // force an aggregation tick

observer.addObserverDetector(name, config?);        // chainable
observer.addCallDetector(name, config?);            // applies to calls created from now on
observer.removeObserverDetector(name);              // → how many instances went
observer.removeCallDetector(name, { includeOpenCalls? });
observer.addValidator(name, config?);
observer.cancelValidator(nameOrInstance, reason?);

observer.close();

type ObservedCallSettings<AppData = Record<string, unknown>> = {
    autoUpdateOnClientUpdate?: boolean;   // default true
    callId: string;
    appData?: AppData;
    closeCallIfEmptyForMs?: number;
};

call.callId;  call.appData;
call.observedClients;  call.numberOfClients;

call.getObservedClient<T>(clientId);
call.createObservedClient<T>(settings, acceptCtx?);
call.getOrCreateObservedClient<T>(settings, acceptCtx?);

call.addIssue(issue);                     // call-level finding → 'call-issue'
call.addDetector(name, config?);          // this call only
call.removeDetector(name);

call.detectors;                           // empty by default
call.activeIssuesRegistry;                // this call's open client issues, propagating into the observer's
call.unconsumedOutboundTracks;            // Set<ObservedOutboundTrack>, maintained by the resolver
call.remoteTrackResolver?;                // set from createRemoteTrackResolver at call creation
call.summary?;                            // the live record, when summaries are on

call.scoreCalculator;  call.score;  call.calculatedScore;

// aggregates
call.numberOfIssues;  call.numberOfPeerConnections;
call.numberOfInboundRtpStreams;  call.numberOfOutboundRtpStreams;  call.numberOfDataChannels;
call.maxNumberOfClients;  call.clientsUsedTurn;
call.startedAt;  call.endedAt;  call.closedAt;  call.closed;

call.update();  call.close();

type ObservedClientSettings<AppData = Record<string, unknown>> = {
    clientId: string;
    appData?: AppData;
    closeClientIfIdleForMs?: number;
};

client.clientId;  client.appData;  client.call;
client.observedPeerConnections;
client.sink?;                     // the per-client sink, if createClientSink is configured
client.activeIssues;              // ObservedClientIssueRegistry, keyed by issue.key

// Injection — merged into the next sample processing
client.injectEvent(clientEvent);
client.injectIssue(clientIssue);
client.injectMetaData(clientMetaData);
client.injectExtensionStat(extensionStat);
client.injectAttachment(attachments);

// Direct add — processed immediately
client.addIssue(clientIssue);
client.addMetadata(clientMetaData);
client.addExtensionStats(extensionStat);

// Current / derived metrics
client.currentAvgRttInMs;  client.currentMinRttInMs;  client.currentMaxRttInMs;
client.receivingAudioBitrate;  client.receivingVideoBitrate;
client.sendingAudioBitrate;    client.sendingVideoBitrate;
client.usingTURN;  client.usingTCP;
client.availableIncomingBitrate;  client.availableOutgoingBitrate;

// Counts and per-tick deltas
client.numberOfInboundRtpStreams;  client.numberOfOutboundRtpStreams;
client.numberOfInbundTracks;  client.numberOfOutboundTracks;
client.numberOfDataChannels;  client.numberOfPeerConnections;
client.deltaReceivedAudioBytes;  client.deltaSentAudioBytes;  /* … */

// Lifecycle and metadata
client.joinedAt;  client.leftAt;  client.closedAt;  client.closed;  client.score;
client.browser;  client.engine;  client.platform;  client.operationSystem;
client.mediaDevices;  client.mediaConstraints;

client.accept(sample, context?);  client.close();

pc.peerConnectionId;  pc.client;  pc.appData;

// Array getters alongside the fifteen maps
pc.codecs;  pc.inboundRtps;  pc.outboundRtps;
pc.remoteInboundRtps;  pc.remoteOutboundRtps;
pc.mediaSources;  pc.mediaPlayouts;  pc.dataChannels;
pc.peerConnectionTransports;  pc.iceTransports;
pc.iceCandidates;  pc.iceCandidatePairs;  pc.certificates;
pc.selectedIceCandidatePairs;  pc.selectedIceCandiadtePairForTurn;

// State
pc.connectionState;  pc.iceConnectionState;  pc.iceGatheringState;
pc.usingTURN;  pc.usingTCP;

// Metrics
pc.currentRttInMs;  pc.iceRttInMs;  pc.rtcpRttInMs;  pc.sfuHopRttInMs;
pc.currentJitter;
pc.availableIncomingBitrate;  pc.availableOutgoingBitrate;
// …plus sending/receiving bitrates, packet rates, and total* / delta* counters

pc.accept(pcSample, context?);  pc.close();  pc.score;

import { CallHealthAggregator } from '@observertc/observer-js';

const health = new CallHealthAggregator(observedCall).aggregate();

health.degradedRatio;          // 0.82 — the number distinguishing shared faults from individual ones
health.inboundDegradedRatio;   // receiving side → egress / downstream suspicion
health.outboundDegradedRatio;  // sending side  → ingress suspicion
health.rttInMs?.median;        // percentile rollups, never means
health.qualityLimitation;      // { cpu, bandwidth, other } client counts
health.clients;                // per-client entries with `reasons`, direction flags, TURN/TCP

import { schemaVersion } from '@observertc/observer-js';
console.log(schemaVersion);   // '3.7.0'