@trillboards/edge-sdk 0.2.76 → 0.2.79

package/dist/DetectorShadowProbe.d.ts

@@ -0,0 +1,381 @@
+/**
+ * DetectorShadowProbe — the on-device object detector running in SHADOW MODE.
+ *
+ * It records the decision the cascade gate WOULD have made and changes nothing.
+ * Nothing downstream of it may branch on its answer: not the cadence, not
+ * admission, not whether the VLM runs.
+ *
+ * ── WHY SHADOW FIRST, AND WHY THAT IS NOT A FORMALITY ──────────────────────
+ *
+ * The detector is a cascade GATE. When it says "nobody here" the VLM call is
+ * skipped, and no alert can fire from a frame nobody looked at. The numbers
+ * that justify it — ~84.7% of VLM calls removed for ~2.1% of events — were
+ * measured on 134 hand-labelled frames drawn from ALERT EPISODES, so the eval
+ * set is 64% positive while production is ~84.7% empty
+ * (docs/runbooks/cctv-detector-tier.md §1). Those are the right numbers for
+ * choosing BETWEEN detectors and the wrong population for sizing a suppressor.
+ *
+ * So the gate is measured against real fleet traffic before it is allowed to
+ * suppress anything. At ~63 ms on top of a ~5,645 ms analyze that measurement
+ * costs about 1% — and this class is what keeps it to about 1% when the service
+ * is missing, wedged, or answering slowly.
+ *
+ * ── THREE STATES, NEVER TWO ────────────────────────────────────────────────
+ *
+ *   person_present  at least one accepted person-class detection
+ *   empty           the service ANSWERED and found nobody — this is a RESULT
+ *   unavailable     transport failed, non-2xx, bad envelope, or nothing installed
+ *
+ * `unavailable` must never collapse into `empty`. That collapse is the entire
+ * failure mode this feature can have: once the gate is armed, a broken detector
+ * read as a quiet venue suppresses every VLM call — and therefore every alert —
+ * while `postCount`, `sensingState:'active'` and the portal's "AI active" tile
+ * all stay green (docs/runbooks/cctv-connector-runtime-edge-cases.md). The
+ * distinction is already load-bearing one layer down: `LocalDetectorClient`
+ * throws `DetectorUnavailableError` for a service failure and returns an empty
+ * `detections` array for an empty frame, and refuses to default a missing
+ * `detections` key to `[]`. This class is the consumer that has to honour it.
+ *
+ * ── WHY THE SERVICE BEING ABSENT MUST COST NOTHING ─────────────────────────
+ *
+ * The service exists as of edge-sdk 0.2.76 and ships in all three installers,
+ * but "the service shipped" and "this box is running it" are different events.
+ * A connector below 0.2.76 has no detector at all, and a FRESH 0.2.76 install
+ * answers `/health` with **503 by design** until the OTA'd ONNX lands — so for
+ * as long as the fleet takes to upgrade, "nothing usable on 9380" is the common
+ * case and shadow mode has to be free in it, or it is a fleet-wide latency
+ * regression bought with no measurement at all.
+ *
+ * Two bounds do that, and neither is a retry policy:
+ *
+ *   1. A HARD DEADLINE. The client is constructed with a short `timeoutMs`
+ *      (default 1000 ms) rather than its own 5 s default, so a wedged service
+ *      can never hold a capture tick for five seconds. ECONNREFUSED — the
+ *      overwhelmingly common case — settles in microseconds and never reaches
+ *      it.
+ *   2. A BACKOFF ON FAILURE, exponential to a ceiling. After a failure the
+ *      probe stops calling `detect()` entirely and reports `unavailable` at
+ *      zero cost until the window closes, at which point ONE cheap `/health`
+ *      GET decides whether to resume. So a box with no detector pays one
+ *      connection refusal per backoff window, not one per frame.
+ *
+ * A skipped frame still REPORTS `unavailable`. Reporting nothing would make a
+ * fleet with no detector look like a small sample rather than what it is, and
+ * the unavailable RATE is one of the three numbers the soak exists to produce.
+ *
+ * ── WHY IT NEVER THROWS ────────────────────────────────────────────────────
+ *
+ * It sits inside `CloudSensingManager.lookThenAdmit`, on the path to the only
+ * thing that produces alerts. A shadow measurement that can fail a real capture
+ * tick is strictly worse than no measurement. Every exit returns a verdict.
+ *
+ * @reuse-audit
+ *   considered: LocalDetectorClient (this package)
+ *     - reused wholesale, unchanged, as the transport and the parser. Its
+ *       DetectorUnavailableError-vs-empty-array distinction IS this class's
+ *       three-state vocabulary; re-deriving it here would be a second opinion
+ *       about the same bytes.
+ *   considered: LiteRtVlmProvider's accelerator probe
+ *     - rejected: it caches a CAPABILITY answered once at startup. This caches a
+ *       LIVENESS verdict that must be able to return to healthy while the
+ *       process runs — a detector installed by an MDM push at 3 a.m. has to be
+ *       picked up without a restart, which is the same reason enterpriseTrust
+ *       drops its cache on a classified failure.
+ */
+import { type DetectResult } from './LocalDetectorClient';
+/** The decision the armed gate WOULD have made about one frame. */
+export type DetectorShadowVerdict = 'person_present' | 'empty' | 'unavailable';
+/**
+ * What travels to the server with the frame, and nothing more.
+ *
+ * Exactly four fields because exactly four columns read them
+ * (`vision_call_log.detector_shadow_verdict / _min_confidence / _inference_ms /
+ * _wall_ms`).
+ * Everything else the probe knows — why a call was unavailable, how many people
+ * were found, which artifact answered — stays in `getStats()` for the local
+ * health surface. A field on the wire with no column at the other end is the
+ * telemetry-producer-substrate defect wearing its other face.
+ */
+export interface DetectorShadowWire {
+    verdict: DetectorShadowVerdict;
+    /**
+     * The confidence threshold this verdict was produced at.
+     *
+     * Carried per frame, not restated server-side: a fleet mid-upgrade across two
+     * connector versions can be running two thresholds at once, and pooling those
+     * into one rate averages two different gates with nothing saying so. The soak
+     * groups on it and refuses to pool. See DETECTOR_GATE_CONFIDENCE.
+     */
+    minConfidence: number;
+    /**
+     * Wall-clock ms the SERVICE reports it spent on inference, or null when it
+     * did not answer. Distinct from `wallMs` on purpose: the difference between
+     * them is loopback + base64 + JSON, which is the part a gate would still pay
+     * after it stopped paying for the VLM.
+     */
+    inferenceMs: number | null;
+    /**
+     * Wall-clock ms SHADOW MODE cost this capture tick, measured by the caller
+     * that paid it. This is the number that says whether the ~1% overhead claim
+     * survived contact with real hardware, and it is 0 for a frame skipped under
+     * backoff.
+     */
+    wallMs: number;
+}
+/** The full local reading, including the parts that do not go on the wire. */
+export interface DetectorShadowObservation extends DetectorShadowWire {
+    /** Accepted person-class detections. Null when the service did not answer. */
+    personCount: number | null;
+    /** Highest accepted confidence, for calibrating a threshold later. */
+    topConfidence: number | null;
+    /** The artifact that answered, as it names itself. */
+    model: string | null;
+    /** Why `unavailable`. Null on every other verdict. */
+    unavailableReason: string | null;
+}
+export interface DetectorShadowStats {
+    enabled: boolean;
+    /** Frames the probe was asked about, whatever the outcome. */
+    observed: number;
+    /**
+     * Frames declined by the per-feed cadence bound WITHOUT any detector call.
+     *
+     * Non-zero means this box is starved: `analyze: true` is arriving faster than
+     * the analyze cadence the detector is scored at. See `minIntervalMs`.
+     */
+    rateLimited: number;
+    personPresent: number;
+    empty: number;
+    unavailable: number;
+    /** Unavailable frames the backoff answered without touching the network. */
+    skippedUnderBackoff: number;
+    /** ms this probe has cost capture ticks, summed. */
+    totalWallMs: number;
+    /** Whether the probe is currently in its failure backoff. */
+    backingOff: boolean;
+    /** Most recent reason a frame came back `unavailable`. */
+    lastUnavailableReason: string | null;
+    /** The artifact that most recently answered. */
+    lastModel: string | null;
+}
+/**
+ * Labels that count as a person.
+ *
+ * The same set the offline scoring harness accepts
+ * (`trillboard-api/scripts/vision/detector-arm-eval.mjs#PERSON_LABELS`), so a
+ * shadow verdict and an eval score mean the same thing by the same rule. Held
+ * as LABELS and never as a class index: an eval run once defaulted an absent
+ * class to index 0 and scored buses as people for a whole run, and the table
+ * looked entirely plausible (cctv-detector-tier.md §5).
+ *
+ * The SHIPPED artifact emits COCO names, so `person` is the only member it can
+ * currently produce (`deploy/detector/trillboards_detector/labels.py`). The
+ * other three are kept because they are what the SCORING harness accepts and
+ * because none of them is a COCO name — so a future artifact with a different
+ * vocabulary is graded the same way, and today's cannot be mis-classified by
+ * their presence.
+ */
+export declare const PERSON_LABELS: ReadonlySet<string>;
+/**
+ * Ceiling on how long shadow mode may hold a capture tick.
+ *
+ * NOT the client's own 5 s default. `lookThenAdmit` runs this between the
+ * motion verdict and the admission gate, so every ms here is a ms the frame is
+ * older when it reaches the model. The detector's measured cost is ~63 ms, so
+ * 1000 ms is ~16x headroom for the slowest plausible answer and still ~0.02% of
+ * a 5,645 ms analyze in the worst case — and it is paid at most once per
+ * backoff window, because a breach opens the backoff.
+ */
+export declare const DEFAULT_SHADOW_TIMEOUT_MS = 1000;
+/** First backoff step after a failure. */
+export declare const DEFAULT_BACKOFF_INITIAL_MS = 30000;
+/**
+ * Backoff ceiling.
+ *
+ * Five minutes rather than "give up": the detector service arrives by MDM push
+ * or by an installer run while the connector is already running, so a probe
+ * that latched off permanently would need a restart to notice its own product
+ * shipping. Same reasoning as the enterprise trust-store cache.
+ */
+export declare const DEFAULT_BACKOFF_MAX_MS = 300000;
+/**
+ * Minimum wall time between shadow observations OF ONE FEED. 15 s.
+ *
+ * ── WHY THIS BOUND EXISTS AND WHY IT IS NOT A TUNING KNOB ──────────────────
+ *
+ * `cctv-detector-tier.md` §2 is unambiguous: **the detector gates the ANALYZE,
+ * not the LOOK.** At the 500 ms look cadence, 6 cameras never clears at p95 on
+ * any thread configuration measured; at the analyze cadence nothing binds.
+ *
+ * The call site — one observation per `analyze: true` verdict — is the right
+ * PLACE and, on a starved box, the wrong RATE. `MotionGate.evaluate` resolves
+ * `heartbeatDue` before it consults the motion verdict, and `markAnalyzed()`
+ * only fires when an inference actually LANDS. So on a connector whose single
+ * inference slot is saturated, every feed is permanently heartbeat-due and
+ * every look returns `analyze: true`. That is the LOOK cadence: measured on the
+ * shipped constants, **64 verdicts/second at 32 feeds** — ~4 CPU-seconds per
+ * wall second of detector at ~63 ms each, on the exact box the runbook already
+ * describes as starved. Worse, almost all of those frames are dropped at
+ * admission and never POST, so the calls buy no measurement at all.
+ *
+ * 15 s is `MIN_ANALYZE_INTERVAL_MS / 2`. Half, not equal, so it cannot bind on
+ * a HEALTHY feed: `MotionGate`'s own `minAnalyzeIntervalMs` floor already keeps
+ * `analyze: true` at least 30 s apart there, so every analyzed frame is
+ * observed and coverage is 100% — which is the fleet the measurement is for.
+ * On a starved feed it caps the cost at 1 call per feed per 15 s (2.13/s at 32
+ * feeds, ~13% of one core) and the frames it declines simply carry no verdict:
+ * the column's NULL already means "not reported", and the soak counts only
+ * non-null rows, so the ratio it reports is unchanged.
+ *
+ * The sampling is by TIME and never by content, so it cannot move the
+ * disagreement or savings rates. What it does cost is COVERAGE on a starved
+ * box, and that is the deliberate trade: a bounded loss of sample there against
+ * an unbounded CPU regression §2 already measured as not clearing.
+ */
+export declare const DEFAULT_MIN_OBSERVE_INTERVAL_MS = 15000;
+/**
+ * The confidence threshold the QUOTED GATE RESULT was produced at. 0.2918.
+ *
+ * NOT `LocalDetectorClient`'s 0.25 default, and the difference is the whole
+ * point of measuring. The committed evaluation
+ * (`trillboard-api/scripts/ai/eval-baselines/detector-arm-results-2026-08-23.json`,
+ * arm `rfdetr-medium`) carries TWO numbers that are easy to conflate:
+ *
+ *   pooled_at_0.25   precision 98.8 / recall 98.8      — a DETECTOR score
+ *   cascade_gate     2.1% events lost / 84.7% saved    — a GATE score, and its
+ *                    own `at` field says "the TRAIN-selected threshold, applied
+ *                    to the TEST half" = held_out.threshold_chosen_on_train
+ *                    = 0.2918
+ *
+ * §1 of the runbook is explicit that those are different questions and that the
+ * ranking inverts between them. A shadow run at 0.25 would therefore measure a
+ * DIFFERENT gate and hand back rates presented as comparable to 2.1%/84.7%,
+ * which is the exact "quoted under other conditions" error the shadow phase
+ * exists to stop.
+ *
+ * The value travels ON THE WIRE per frame (`minConfidence` below) rather than
+ * being restated server-side, because a fleet is routinely mid-upgrade across
+ * two connector versions and a soak that pooled two thresholds would average
+ * two different gates into one number with nothing saying so — the
+ * `agent_version` trap in docs/runbooks/ctv-agent-version-map.md, one column
+ * over.
+ */
+export declare const DETECTOR_GATE_CONFIDENCE = 0.2918;
+/**
+ * Ceiling on the WHOLE observation, enforced by this class rather than by the
+ * transport. 1500 ms.
+ *
+ * `LocalDetectorClient`'s `timeoutMs` is an INACTIVITY timeout — its own header
+ * says so, and names the case it cannot cover: a server dribbling bytes slowly
+ * under a large Content-Length keeps the socket busy, the inactivity timer
+ * never fires, and the call is genuinely unbounded. That is tolerable for a
+ * client nothing calls on the hot path and NOT tolerable here, because this
+ * runs on the path to every admitted analysis — the only path that produces
+ * alerts.
+ *
+ * So the elapsed-time bound lives here, above the transport, where "how long
+ * may a shadow measurement hold a capture tick" is actually decided. Slightly
+ * above the client's own 1000 ms so the transport still wins the ordinary
+ * timeout and reports it as one.
+ */
+export declare const DEFAULT_OBSERVE_DEADLINE_MS = 1500;
+export interface DetectorShadowProbeOptions {
+    /** Off entirely. Nothing is called and every observe() returns null. */
+    enabled?: boolean;
+    /** Detector service base URL. Defaults to the client's loopback default. */
+    baseUrl?: string;
+    /** Hard per-frame deadline. Default DEFAULT_SHADOW_TIMEOUT_MS. */
+    timeoutMs?: number;
+    /**
+     * Confidence floor applied AT THE SERVICE. Default DETECTOR_GATE_CONFIDENCE
+     * (0.2918) — the threshold the quoted gate result was produced at, NOT the
+     * client's 0.25 default. See that constant for why the difference matters.
+     */
+    minConfidence?: number;
+    /**
+     * Ceiling on the whole observation. Default DEFAULT_OBSERVE_DEADLINE_MS —
+     * the transport's timeout is an INACTIVITY timeout and cannot bound a
+     * dribbling response. 0 disables it, which is only correct on a bench rig.
+     */
+    deadlineMs?: number;
+    backoffInitialMs?: number;
+    backoffMaxMs?: number;
+    /**
+     * Minimum wall time between observations OF ONE FEED. Default 15 s — see
+     * DEFAULT_MIN_OBSERVE_INTERVAL_MS for why this is a safety bound rather than
+     * a tuning knob. 0 disables it, which is only correct on a bench rig.
+     */
+    minIntervalMs?: number;
+    /** Clock injection for tests. Default Date.now. */
+    now?: () => number;
+}
+/** The slice of LocalDetectorClient this probe uses — injectable for tests. */
+export interface DetectorLike {
+    detect(jpeg: Buffer): Promise<DetectResult>;
+    isHealthy(): Promise<boolean>;
+}
+export declare class DetectorShadowProbe {
+    private readonly client;
+    private readonly enabled;
+    private readonly backoffInitialMs;
+    private readonly backoffMaxMs;
+    private readonly minIntervalMs;
+    private readonly minConfidence;
+    private readonly deadlineMs;
+    private readonly now;
+    /** Last observation per feed, for the cadence bound. */
+    private readonly lastObservedAtMs;
+    /** null ⇒ not backing off. Otherwise the clock reading backoff expires at. */
+    private backoffUntilMs;
+    private backoffStepMs;
+    private observed;
+    private rateLimited;
+    private personPresent;
+    private empty;
+    private unavailable;
+    private skippedUnderBackoff;
+    private totalWallMs;
+    private lastUnavailableReason;
+    private lastModel;
+    constructor(options?: DetectorShadowProbeOptions, client?: DetectorLike);
+    isEnabled(): boolean;
+    /**
+     * Record the decision the armed gate WOULD have made about this frame.
+     *
+     * NEVER THROWS, never returns a promise that rejects, and never returns
+     * `empty` for a service that did not answer.
+     *
+     * Returns null for the two cases that are NOT a verdict — the probe is
+     * disabled, or this feed is inside its cadence bound — so a caller can tell
+     * "no reading" from "the detector is down". Those must not share a value:
+     * `unavailable` is a claim about the detector, and null means nobody asked.
+     * The caller sends nothing for a null, and the column's NULL already means
+     * "not reported".
+     *
+     * @param jpeg the exact bytes the VLM is about to analyze
+     * @param feedKey which feed this frame came from; the cadence bound is
+     *   PER FEED, because a busy camera must not spend a quiet camera's budget
+     */
+    observe(jpeg: Buffer, feedKey?: string): Promise<DetectorShadowObservation | null>;
+    /** The wire slice — exactly the fields a column reads. */
+    static toWire(observation: DetectorShadowObservation): DetectorShadowWire;
+    getStats(): DetectorShadowStats;
+    private recordUnavailable;
+    /**
+     * Bound a detector call by ELAPSED time, which the transport cannot do.
+     *
+     * `LocalDetectorClient`'s timeout is an inactivity timer, and its own header
+     * names the hole: a server dribbling bytes under a large Content-Length keeps
+     * the socket busy forever. On the path to every admitted analysis, that is an
+     * unbounded stall on the only path that produces alerts.
+     *
+     * The loser's rejection is swallowed rather than left to become an unhandled
+     * rejection — the underlying request still settles on its own timeout and its
+     * result is simply discarded, which is the correct outcome for a measurement
+     * whose window has passed.
+     */
+    private withDeadline;
+    private openBackoff;
+    private closeBackoff;
+}
+//# sourceMappingURL=DetectorShadowProbe.d.ts.map

package/dist/DetectorShadowProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetectorShadowProbe.d.ts","sourceRoot":"","sources":["../src/DetectorShadowProbe.ts"],"names":[],"mappings":"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"}