@trillboards/edge-sdk 0.2.59 → 0.2.60

package/dist/connectorCadence.d.ts

@@ -163,8 +163,13 @@ export declare const STILL_FLOOR_SLOT_SHARE = 0.5;
  */
 export declare const MIN_ANALYZE_INTERVAL_MS = 30000;
 /**
- * Measured wall-clock cost of ONE LOOK, in ms — a real RTSP grab, not the
- * decode-and-detect that follows it.
+ * Measured wall-clock cost of ONE LOOK on the PER-GRAB capture path, in ms — a
+ * real RTSP grab, not the decode-and-detect that follows it.
+ *
+ * STILL LIVE, and still exactly right for the path it describes: the per-grab
+ * provider is what a feed runs when it cannot hold a persistent session (see
+ * `MEASURED_STREAM_LOOK_MS`), so this is the number `lookIntervalMsForFeedCount`
+ * uses in `'per_grab'` mode and nothing about it has changed.
  *
  * The cascade budget above quotes 3.6 ms for a look. That is the cost AFTER the
  * frame is in hand: pull it down to ~178x100 grey and run the detector. Getting
@@ -197,6 +202,75 @@ export declare const MIN_ANALYZE_INTERVAL_MS = 30000;
  * the connector is not running.
  */
 export declare const MEASURED_LOOK_MS = 2000;
+/**
+ * Measured wall-clock cost of ONE LOOK on the PERSISTENT capture path, in ms.
+ *
+ * `RTSPStreamCameraProvider` holds one long-lived ffmpeg per feed decoding into
+ * a bounded ring, so `getFrame()` is a memory read of the newest frame rather
+ * than a process start plus a DESCRIBE/SETUP/PLAY plus a wait for an IDR. The
+ * handshake is paid ONCE, at open.
+ *
+ * MEASURED 2026-08-18 against the same rig, same clip, same degraded profile
+ * (640x360 / 399 kbps / GOP 2 s), driving looks at the shipped cadence so a
+ * fresh frame is already in hand — which is the condition the connector runs
+ * in and the only one where "cost of a look" means anything:
+ *
+ *     per-grab      p50 2,000 ms
+ *     persistent    p50 0 ms   (sub-millisecond; the ring read is a pointer)
+ *
+ * Reproduce: `node scripts/measure-persistent-capture.mjs --feeds 1
+ * --seconds 60 --pace-ms 500`. The rig is committed — see that file's header
+ * for why, and for why a `file://` fixture cannot stand in for it.
+ *
+ * It is 1 rather than 0 so that `lookIntervalMsForFeedCount` can never divide
+ * by it, and so nobody reads a zero as "free" — a look still costs the
+ * detector's `MEASURED_LOOK_DETECT_MS`, which is what actually bounds the
+ * persistent path.
+ */
+export declare const MEASURED_STREAM_LOOK_MS = 1;
+/**
+ * Cost of a look AFTER the frame is in hand, in ms: pull it down to ~178x100
+ * grey and run `SceneChangeDetector`. Measured 3.6 ms median / 7.1 ms p95.
+ *
+ * This is the number the cascade budget has always quoted, and until the
+ * capture path changed it was irrelevant — a 3.6 ms stage behind a 2,000 ms
+ * one bounds nothing. On the persistent path it is the ONLY per-look cost
+ * left, so it becomes the binding term and gets named here rather than living
+ * in a comment.
+ */
+export declare const MEASURED_LOOK_DETECT_MS = 3.6;
+/**
+ * Share of ONE core the motion detector may take across every feed.
+ *
+ * The one judgement in the persistent derivation, stated rather than hidden —
+ * the same shape as `STILL_FLOOR_SLOT_SHARE`. Detection is the cheapest stage
+ * on the box and it must not become the noisy neighbour: the connector also
+ * runs one ffmpeg decode per feed (measured on the rig at ~2.4% of a core per
+ * feed at this profile) and one local VLM slot, and the VLM is the thing the
+ * product is actually spending money on.
+ *
+ * A quarter of a core does not bind at any realistic feed count — see
+ * `lookIntervalMsForFeedCount` — which is the point: it is a guard rail, not a
+ * throttle, and it exists so that a future 64-feed host derives a cadence it
+ * can serve instead of one it merely asked for.
+ */
+export declare const LOOK_DETECT_CPU_SHARE = 0.25;
+/**
+ * The persistent session's frame interval, in ms — the freshest a look can
+ * possibly be, because a look reads the newest DECODED frame.
+ *
+ * `RTSPStreamCameraProvider` defaults `streamFps` to 4, i.e. 250 ms. Restated
+ * here rather than imported because `edge-sdk` must not depend on a platform
+ * package, and asserted against the real default by `connectorCadence.test.ts`
+ * so the two cannot drift — the same treatment `LOOK_CAPTURE_CONCURRENCY` gets.
+ *
+ * `LOOK_INTERVAL_MS` must never be finer than this: asking for a 100 ms look
+ * cadence against a 250 ms stream would hand the same frame to the motion
+ * detector twice, which the provider refuses (it throws rather than repeat a
+ * frame) and which would report as a stale-stream fault on a perfectly healthy
+ * camera.
+ */
+export declare const MEASURED_STREAM_FRAME_INTERVAL_MS = 250;
 /**
  * Concurrent RTSP grabs one physical recorder will take —
  * `DEFAULT_MAX_CONCURRENT_CAPTURES_PER_SOURCE` in `RTSPCameraProvider`, which
@@ -246,32 +320,59 @@ export declare const LEGACY_LOOK_INTERVAL_MS = 30000;
  *     T        Instant   Brief   Sustained   State
  *     30 s        8.4%   18.6%       100%     100%
  *      5 s       50.2%   55.1%       100%     100%
- *      2.44 s    89.1%   71.2%       100%     100%
  *      2 s       95.5%   75.2%       100%     100%
  *      1 s      100.0%   86.6%       100%     100%
  *      0.75 s   100.0%   90.1%       100%     100%
- *
- * Two things fall out of that table and both are load bearing:
- *
- *   - The Instant group — "alert me if the door opens after hours", a 2.2 s
- *     median event — clears the 90% target at 2.4 s and is at 8.4% today. This
- *     is the promise the 30 s cadence was silently failing.
- *
- *   - The Brief group does NOT reach 90% until 0.75 s, and 0.75 s is well below
- *     the measured cost of a single grab (`MEASURED_LOOK_MS`). So 90% on every
- *     shape is NOT reachable by look cadence on the current capture
- *     architecture, and this constant does not pretend otherwise. Closing that
- *     gap needs a persistent RTSP session — one long-lived ffmpeg per feed
- *     instead of one per grab — which is an architecture change, not a number.
- *
- * 2 000 ms is therefore the fastest cadence that is BOTH an eval output and
- * physically deliverable: it is the measured single-grab floor, and at it the
- * Instant group clears the target. Do not lower it without first lowering
- * `MEASURED_LOOK_MS`, and do not raise it without re-running the replay — the
- * `sensing-catch-rate` guard re-reads this constant and fails if it drifts from
- * the cadence the corpus was measured at.
+ *      0.5 s    100.0%   93.2%       100%     100%
+ *
+ * ── 2 000 -> 500 ms ON 2026-08-18, AND THE REASON IS THE CAPTURE PATH ──────
+ *
+ * This constant was 2 000 ms, and the comment here said why in as many words:
+ * "the Brief group does NOT reach 90% until 0.75 s, and 0.75 s is well below
+ * the measured cost of a single grab. So 90% on every shape is NOT reachable by
+ * look cadence on the current capture architecture… Closing that gap needs a
+ * persistent RTSP session — one long-lived ffmpeg per feed instead of one per
+ * grab — which is an architecture change, not a number."
+ *
+ * That is now built (`RTSPStreamCameraProvider`), the constraint it named is
+ * gone, and this is the number that moves as a result. A look is a memory read
+ * of the newest decoded frame — `MEASURED_STREAM_LOOK_MS`, sub-millisecond —
+ * so the recorder no longer bounds the look cadence at all. Brief clears the
+ * 90% target at 0.75 s; 500 ms is the next value that is BOTH under it and a
+ * whole multiple of the persistent session's 250 ms frame interval
+ * (`MEASURED_STREAM_FRAME_INTERVAL_MS`), so a look always finds an unseen frame
+ * in hand and never blocks.
+ *
+ * ── WHY STOP AT 500 ms ────────────────────────────────────────────────────
+ *
+ * The same stopping rule that picked 2 000 ms: go until the last unmet target
+ * is met, and no further. At 500 ms every reporting group clears 90% — the
+ * first cadence in the product's history where that is true. Below it the
+ * corpus has nothing left to buy (Instant and Brief are saturated, Sustained
+ * and State were never look-limited) while the cost is real and linear: each
+ * halving doubles both the detector's CPU (`MEASURED_LOOK_DETECT_MS` per look
+ * per feed) and the session's JPEG-encode rate.
+ *
+ * ── AND IT MUST NOT COST ANALYSES ─────────────────────────────────────────
+ *
+ * Looking 4x more often must not analyse 4x more often, or the change has
+ * failed: one 7.30 s slot is 493 analyses/hour for the whole connector and
+ * there is no cloud path left to absorb an overflow. Three things hold that,
+ * and all three are asserted rather than assumed:
+ *   - `MIN_ANALYZE_INTERVAL_MS` (30 s) is a SEPARATE constant and is what
+ *     `MotionGate.minAnalyzeIntervalMs` floors on.
+ *   - `periodicIntervalMsForFeedCount` floors on the ANALYZE floor, never on
+ *     the look cadence, so the still-scene heartbeat does not move.
+ *   - a still scene contributes exactly ZERO motion-triggered analyses, which
+ *     is what makes the extra looks free at the model.
+ * The `sensing-catch-rate` guard's volume ratchet is the mechanical version:
+ * `volume.idleAnalyses` may only go DOWN.
+ *
+ * Do not raise or lower this without re-running the replay — the guard re-reads
+ * this constant and fails if it drifts from the cadence the corpus baseline was
+ * measured at.
  */
-export declare const LOOK_INTERVAL_MS = 2000;
+export declare const LOOK_INTERVAL_MS = 500;
 /** The DOOH audience default (`DEFAULT_PERIODIC_MS`). The slow end of the clamp. */
 export declare const DOOH_PERIODIC_MS = 300000;
 /**
@@ -286,27 +387,86 @@ export declare const DOOH_PERIODIC_MS = 300000;
  */
 export declare function periodicIntervalMsForFeedCount(feedCount: unknown): number | null;
 /**
- * The fastest look cadence a connector running `feedCount` feeds against ONE
- * recorder can actually SUSTAIN, in ms.
+ * How a feed's frames are acquired. The look cadence a connector can SUSTAIN
+ * depends on this and on nothing else about the box.
+ *
+ *   'persistent'  one long-lived ffmpeg per feed into a bounded ring
+ *                 (`RTSPStreamCameraProvider`). A look is a memory read.
+ *   'per_grab'    one ffmpeg per grab (`RTSPCameraProvider`). A look is an RTSP
+ *                 handshake, and the RECORDER is the bound.
+ */
+export type CaptureMode = 'persistent' | 'per_grab';
+/**
+ * The fastest look cadence a connector running `feedCount` feeds can actually
+ * SUSTAIN, in ms.
  *
  * Same shape as `periodicIntervalMsForFeedCount` and for the same reason: a
  * cadence is only real if the machine can deliver it. That function divides one
- * inference slot among N feeds; this one divides one recorder's capture
- * capacity among N feeds.
+ * inference slot among N feeds; this one divides whatever the capture path's
+ * scarce resource is — and the whole point of the persistent session is that it
+ * CHANGES WHICH RESOURCE THAT IS.
+ *
+ * ── 'per_grab' — the RECORDER is the bound (unchanged) ────────────────────
  *
  *     N feeds x (1 look / T)  <=  LOOK_CAPTURE_CONCURRENCY / MEASURED_LOOK_MS
  *                          T  >=  N x MEASURED_LOOK_MS / LOOK_CAPTURE_CONCURRENCY
  *
  * Measured against that formula at 16 feeds on one recorder, GOP 2 s: predicted
- * 16.0 s/feed, observed 16.0 s/feed.
+ * 16.0 s/feed, observed 16.0 s/feed. This is still exactly right for a feed that
+ * could not hold a persistent session and degraded — see
+ * `RTSPStreamCameraProvider`'s degrade path — so the branch stays live rather
+ * than being deleted as legacy.
+ *
+ * ── 'persistent' — the recorder drops out and the DETECTOR is the bound ───
+ *
+ * A look no longer touches the recorder, so `LOOK_CAPTURE_CONCURRENCY` and
+ * `MEASURED_LOOK_MS` have nothing to say about it. What is left is the cost
+ * AFTER the frame is in hand:
+ *
+ *     N feeds x (1 look / T) x MEASURED_LOOK_DETECT_MS  <=  LOOK_DETECT_CPU_SHARE
+ *                                                  T  >=  N x 3.6 / 0.25 ms
+ *
+ * That is 230 ms at 16 feeds and 461 ms at 32 — both BELOW `LOOK_INTERVAL_MS`,
+ * so the clamp wins and a realistic connector simply gets the eval target. It
+ * begins to bind past ~34 feeds, which is the honest place for it to bind: a
+ * host with 34 cameras has other problems (its still-scene heartbeat pinned at
+ * `DOOH_PERIODIC_MS` since 21 feeds) and `getSensingHealth()` reports the
+ * effective interval either way.
  *
  * Never faster than `LOOK_INTERVAL_MS` (the eval target — looking finer than
  * that buys nothing the corpus can see) and never slower than
  * `LEGACY_LOOK_INTERVAL_MS`, so this can only make a connector look MORE often
- * than it did, never less. Returns `null` on an uncountable feed count so a caller can
- * omit the key rather than derive a cadence from nothing.
+ * than it did, never less. Returns `null` on an uncountable feed count so a
+ * caller can omit the key rather than derive a cadence from nothing.
+ */
+export declare function lookIntervalMsForFeedCount(feedCount: unknown, captureMode?: CaptureMode): number | null;
+/**
+ * Decoded frames a persistent session must produce per LOOK.
+ *
+ * TWO, and the second one is not waste. `RTSPStreamCameraProvider.getFrame()`
+ * refuses to hand back a frame it has already served — that refusal is the
+ * whole reason a frozen camera cannot report as healthy — so a look that
+ * arrives before the next frame does BLOCKS, and if it blocks past the
+ * staleness deadline it throws on a camera that is working perfectly.
+ *
+ * Running the stream at exactly the look rate makes that a coin flip on every
+ * tick, because neither clock is locked to the other: the session's frame
+ * cadence follows the CAMERA's timestamps and the look cadence follows a Node
+ * timer, and they drift. One frame of headroom removes the race for the cost of
+ * one extra scale+encode per look — the cheapest stage in the pipeline, and one
+ * that never touches the recorder or the model.
+ */
+export declare const STREAM_LOOK_HEADROOM = 2;
+/**
+ * Frames per second a persistent session should decode to serve a given look
+ * cadence. Derived, so the two can never be set independently and drift into
+ * the blocking case above.
+ *
+ * At the shipped 500 ms look cadence this is 4 fps — which is also the
+ * provider's own default (`MEASURED_STREAM_FRAME_INTERVAL_MS`), and
+ * `connectorCadence.test.ts` asserts the agreement rather than trusting it.
  */
-export declare function lookIntervalMsForFeedCount(feedCount: unknown): number | null;
+export declare function streamFpsForLookIntervalMs(lookIntervalMs: unknown): number;
 /**
  * The still-scene analyses/hour a whole connector demands at a heartbeat, and
  * what fraction of the single slot that is. Exposed so the derivation is

package/dist/connectorCadence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connectorCadence.d.ts","sourceRoot":"","sources":["../src/connectorCadence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AAEtC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AAEtC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,SAAU,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CA4BhF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAK5E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,OAAO,GAC1B;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAOhD"}
+{"version":3,"file":"connectorCadence.d.ts","sourceRoot":"","sources":["../src/connectorCadence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iCAAiC,MAAM,CAAC;AAErD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,SAAU,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CA4BhF;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,UAAU,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,OAAO,EAClB,WAAW,GAAE,WAAwB,GACpC,MAAM,GAAG,IAAI,CA0Bf;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM,CAI1E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,OAAO,GAC1B;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAOhD"}

package/dist/connectorCadence.js

@@ -107,9 +107,10 @@
  * what the operator wants; this says what the machine can deliver.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DOOH_PERIODIC_MS = exports.LOOK_INTERVAL_MS = exports.LEGACY_LOOK_INTERVAL_MS = exports.LOOK_CAPTURE_CONCURRENCY = exports.MEASURED_LOOK_MS = exports.MIN_ANALYZE_INTERVAL_MS = exports.STILL_FLOOR_SLOT_SHARE = exports.MEASURED_LOCAL_ANALYZE_MS = void 0;
+exports.STREAM_LOOK_HEADROOM = exports.DOOH_PERIODIC_MS = exports.LOOK_INTERVAL_MS = exports.LEGACY_LOOK_INTERVAL_MS = exports.LOOK_CAPTURE_CONCURRENCY = exports.MEASURED_STREAM_FRAME_INTERVAL_MS = exports.LOOK_DETECT_CPU_SHARE = exports.MEASURED_LOOK_DETECT_MS = exports.MEASURED_STREAM_LOOK_MS = exports.MEASURED_LOOK_MS = exports.MIN_ANALYZE_INTERVAL_MS = exports.STILL_FLOOR_SLOT_SHARE = exports.MEASURED_LOCAL_ANALYZE_MS = void 0;
 exports.periodicIntervalMsForFeedCount = periodicIntervalMsForFeedCount;
 exports.lookIntervalMsForFeedCount = lookIntervalMsForFeedCount;
+exports.streamFpsForLookIntervalMs = streamFpsForLookIntervalMs;
 exports.stillSceneLoad = stillSceneLoad;
 /**
  * Measured median seconds per on-device analysis, in ms. See the header for the
@@ -169,8 +170,13 @@ exports.STILL_FLOOR_SLOT_SHARE = 0.5;
  */
 exports.MIN_ANALYZE_INTERVAL_MS = 30000;
 /**
- * Measured wall-clock cost of ONE LOOK, in ms — a real RTSP grab, not the
- * decode-and-detect that follows it.
+ * Measured wall-clock cost of ONE LOOK on the PER-GRAB capture path, in ms — a
+ * real RTSP grab, not the decode-and-detect that follows it.
+ *
+ * STILL LIVE, and still exactly right for the path it describes: the per-grab
+ * provider is what a feed runs when it cannot hold a persistent session (see
+ * `MEASURED_STREAM_LOOK_MS`), so this is the number `lookIntervalMsForFeedCount`
+ * uses in `'per_grab'` mode and nothing about it has changed.
  *
  * The cascade budget above quotes 3.6 ms for a look. That is the cost AFTER the
  * frame is in hand: pull it down to ~178x100 grey and run the detector. Getting
@@ -203,6 +209,75 @@ exports.MIN_ANALYZE_INTERVAL_MS = 30000;
  * the connector is not running.
  */
 exports.MEASURED_LOOK_MS = 2000;
+/**
+ * Measured wall-clock cost of ONE LOOK on the PERSISTENT capture path, in ms.
+ *
+ * `RTSPStreamCameraProvider` holds one long-lived ffmpeg per feed decoding into
+ * a bounded ring, so `getFrame()` is a memory read of the newest frame rather
+ * than a process start plus a DESCRIBE/SETUP/PLAY plus a wait for an IDR. The
+ * handshake is paid ONCE, at open.
+ *
+ * MEASURED 2026-08-18 against the same rig, same clip, same degraded profile
+ * (640x360 / 399 kbps / GOP 2 s), driving looks at the shipped cadence so a
+ * fresh frame is already in hand — which is the condition the connector runs
+ * in and the only one where "cost of a look" means anything:
+ *
+ *     per-grab      p50 2,000 ms
+ *     persistent    p50 0 ms   (sub-millisecond; the ring read is a pointer)
+ *
+ * Reproduce: `node scripts/measure-persistent-capture.mjs --feeds 1
+ * --seconds 60 --pace-ms 500`. The rig is committed — see that file's header
+ * for why, and for why a `file://` fixture cannot stand in for it.
+ *
+ * It is 1 rather than 0 so that `lookIntervalMsForFeedCount` can never divide
+ * by it, and so nobody reads a zero as "free" — a look still costs the
+ * detector's `MEASURED_LOOK_DETECT_MS`, which is what actually bounds the
+ * persistent path.
+ */
+exports.MEASURED_STREAM_LOOK_MS = 1;
+/**
+ * Cost of a look AFTER the frame is in hand, in ms: pull it down to ~178x100
+ * grey and run `SceneChangeDetector`. Measured 3.6 ms median / 7.1 ms p95.
+ *
+ * This is the number the cascade budget has always quoted, and until the
+ * capture path changed it was irrelevant — a 3.6 ms stage behind a 2,000 ms
+ * one bounds nothing. On the persistent path it is the ONLY per-look cost
+ * left, so it becomes the binding term and gets named here rather than living
+ * in a comment.
+ */
+exports.MEASURED_LOOK_DETECT_MS = 3.6;
+/**
+ * Share of ONE core the motion detector may take across every feed.
+ *
+ * The one judgement in the persistent derivation, stated rather than hidden —
+ * the same shape as `STILL_FLOOR_SLOT_SHARE`. Detection is the cheapest stage
+ * on the box and it must not become the noisy neighbour: the connector also
+ * runs one ffmpeg decode per feed (measured on the rig at ~2.4% of a core per
+ * feed at this profile) and one local VLM slot, and the VLM is the thing the
+ * product is actually spending money on.
+ *
+ * A quarter of a core does not bind at any realistic feed count — see
+ * `lookIntervalMsForFeedCount` — which is the point: it is a guard rail, not a
+ * throttle, and it exists so that a future 64-feed host derives a cadence it
+ * can serve instead of one it merely asked for.
+ */
+exports.LOOK_DETECT_CPU_SHARE = 0.25;
+/**
+ * The persistent session's frame interval, in ms — the freshest a look can
+ * possibly be, because a look reads the newest DECODED frame.
+ *
+ * `RTSPStreamCameraProvider` defaults `streamFps` to 4, i.e. 250 ms. Restated
+ * here rather than imported because `edge-sdk` must not depend on a platform
+ * package, and asserted against the real default by `connectorCadence.test.ts`
+ * so the two cannot drift — the same treatment `LOOK_CAPTURE_CONCURRENCY` gets.
+ *
+ * `LOOK_INTERVAL_MS` must never be finer than this: asking for a 100 ms look
+ * cadence against a 250 ms stream would hand the same frame to the motion
+ * detector twice, which the provider refuses (it throws rather than repeat a
+ * frame) and which would report as a stale-stream fault on a perfectly healthy
+ * camera.
+ */
+exports.MEASURED_STREAM_FRAME_INTERVAL_MS = 250;
 /**
  * Concurrent RTSP grabs one physical recorder will take —
  * `DEFAULT_MAX_CONCURRENT_CAPTURES_PER_SOURCE` in `RTSPCameraProvider`, which
@@ -252,32 +327,59 @@ exports.LEGACY_LOOK_INTERVAL_MS = 30000;
  *     T        Instant   Brief   Sustained   State
  *     30 s        8.4%   18.6%       100%     100%
  *      5 s       50.2%   55.1%       100%     100%
- *      2.44 s    89.1%   71.2%       100%     100%
  *      2 s       95.5%   75.2%       100%     100%
  *      1 s      100.0%   86.6%       100%     100%
  *      0.75 s   100.0%   90.1%       100%     100%
- *
- * Two things fall out of that table and both are load bearing:
- *
- *   - The Instant group — "alert me if the door opens after hours", a 2.2 s
- *     median event — clears the 90% target at 2.4 s and is at 8.4% today. This
- *     is the promise the 30 s cadence was silently failing.
- *
- *   - The Brief group does NOT reach 90% until 0.75 s, and 0.75 s is well below
- *     the measured cost of a single grab (`MEASURED_LOOK_MS`). So 90% on every
- *     shape is NOT reachable by look cadence on the current capture
- *     architecture, and this constant does not pretend otherwise. Closing that
- *     gap needs a persistent RTSP session — one long-lived ffmpeg per feed
- *     instead of one per grab — which is an architecture change, not a number.
- *
- * 2 000 ms is therefore the fastest cadence that is BOTH an eval output and
- * physically deliverable: it is the measured single-grab floor, and at it the
- * Instant group clears the target. Do not lower it without first lowering
- * `MEASURED_LOOK_MS`, and do not raise it without re-running the replay — the
- * `sensing-catch-rate` guard re-reads this constant and fails if it drifts from
- * the cadence the corpus was measured at.
+ *      0.5 s    100.0%   93.2%       100%     100%
+ *
+ * ── 2 000 -> 500 ms ON 2026-08-18, AND THE REASON IS THE CAPTURE PATH ──────
+ *
+ * This constant was 2 000 ms, and the comment here said why in as many words:
+ * "the Brief group does NOT reach 90% until 0.75 s, and 0.75 s is well below
+ * the measured cost of a single grab. So 90% on every shape is NOT reachable by
+ * look cadence on the current capture architecture… Closing that gap needs a
+ * persistent RTSP session — one long-lived ffmpeg per feed instead of one per
+ * grab — which is an architecture change, not a number."
+ *
+ * That is now built (`RTSPStreamCameraProvider`), the constraint it named is
+ * gone, and this is the number that moves as a result. A look is a memory read
+ * of the newest decoded frame — `MEASURED_STREAM_LOOK_MS`, sub-millisecond —
+ * so the recorder no longer bounds the look cadence at all. Brief clears the
+ * 90% target at 0.75 s; 500 ms is the next value that is BOTH under it and a
+ * whole multiple of the persistent session's 250 ms frame interval
+ * (`MEASURED_STREAM_FRAME_INTERVAL_MS`), so a look always finds an unseen frame
+ * in hand and never blocks.
+ *
+ * ── WHY STOP AT 500 ms ────────────────────────────────────────────────────
+ *
+ * The same stopping rule that picked 2 000 ms: go until the last unmet target
+ * is met, and no further. At 500 ms every reporting group clears 90% — the
+ * first cadence in the product's history where that is true. Below it the
+ * corpus has nothing left to buy (Instant and Brief are saturated, Sustained
+ * and State were never look-limited) while the cost is real and linear: each
+ * halving doubles both the detector's CPU (`MEASURED_LOOK_DETECT_MS` per look
+ * per feed) and the session's JPEG-encode rate.
+ *
+ * ── AND IT MUST NOT COST ANALYSES ─────────────────────────────────────────
+ *
+ * Looking 4x more often must not analyse 4x more often, or the change has
+ * failed: one 7.30 s slot is 493 analyses/hour for the whole connector and
+ * there is no cloud path left to absorb an overflow. Three things hold that,
+ * and all three are asserted rather than assumed:
+ *   - `MIN_ANALYZE_INTERVAL_MS` (30 s) is a SEPARATE constant and is what
+ *     `MotionGate.minAnalyzeIntervalMs` floors on.
+ *   - `periodicIntervalMsForFeedCount` floors on the ANALYZE floor, never on
+ *     the look cadence, so the still-scene heartbeat does not move.
+ *   - a still scene contributes exactly ZERO motion-triggered analyses, which
+ *     is what makes the extra looks free at the model.
+ * The `sensing-catch-rate` guard's volume ratchet is the mechanical version:
+ * `volume.idleAnalyses` may only go DOWN.
+ *
+ * Do not raise or lower this without re-running the replay — the guard re-reads
+ * this constant and fails if it drifts from the cadence the corpus baseline was
+ * measured at.
  */
-exports.LOOK_INTERVAL_MS = 2000;
+exports.LOOK_INTERVAL_MS = 500;
 /** The DOOH audience default (`DEFAULT_PERIODIC_MS`). The slow end of the clamp. */
 exports.DOOH_PERIODIC_MS = 300000;
 /**
@@ -321,32 +423,107 @@ function periodicIntervalMsForFeedCount(feedCount) {
     return Math.min(exports.DOOH_PERIODIC_MS, Math.max(exports.MIN_ANALYZE_INTERVAL_MS, required));
 }
 /**
- * The fastest look cadence a connector running `feedCount` feeds against ONE
- * recorder can actually SUSTAIN, in ms.
+ * The fastest look cadence a connector running `feedCount` feeds can actually
+ * SUSTAIN, in ms.
  *
  * Same shape as `periodicIntervalMsForFeedCount` and for the same reason: a
  * cadence is only real if the machine can deliver it. That function divides one
- * inference slot among N feeds; this one divides one recorder's capture
- * capacity among N feeds.
+ * inference slot among N feeds; this one divides whatever the capture path's
+ * scarce resource is — and the whole point of the persistent session is that it
+ * CHANGES WHICH RESOURCE THAT IS.
+ *
+ * ── 'per_grab' — the RECORDER is the bound (unchanged) ────────────────────
  *
  *     N feeds x (1 look / T)  <=  LOOK_CAPTURE_CONCURRENCY / MEASURED_LOOK_MS
  *                          T  >=  N x MEASURED_LOOK_MS / LOOK_CAPTURE_CONCURRENCY
  *
  * Measured against that formula at 16 feeds on one recorder, GOP 2 s: predicted
- * 16.0 s/feed, observed 16.0 s/feed.
+ * 16.0 s/feed, observed 16.0 s/feed. This is still exactly right for a feed that
+ * could not hold a persistent session and degraded — see
+ * `RTSPStreamCameraProvider`'s degrade path — so the branch stays live rather
+ * than being deleted as legacy.
+ *
+ * ── 'persistent' — the recorder drops out and the DETECTOR is the bound ───
+ *
+ * A look no longer touches the recorder, so `LOOK_CAPTURE_CONCURRENCY` and
+ * `MEASURED_LOOK_MS` have nothing to say about it. What is left is the cost
+ * AFTER the frame is in hand:
+ *
+ *     N feeds x (1 look / T) x MEASURED_LOOK_DETECT_MS  <=  LOOK_DETECT_CPU_SHARE
+ *                                                  T  >=  N x 3.6 / 0.25 ms
+ *
+ * That is 230 ms at 16 feeds and 461 ms at 32 — both BELOW `LOOK_INTERVAL_MS`,
+ * so the clamp wins and a realistic connector simply gets the eval target. It
+ * begins to bind past ~34 feeds, which is the honest place for it to bind: a
+ * host with 34 cameras has other problems (its still-scene heartbeat pinned at
+ * `DOOH_PERIODIC_MS` since 21 feeds) and `getSensingHealth()` reports the
+ * effective interval either way.
  *
  * Never faster than `LOOK_INTERVAL_MS` (the eval target — looking finer than
  * that buys nothing the corpus can see) and never slower than
  * `LEGACY_LOOK_INTERVAL_MS`, so this can only make a connector look MORE often
- * than it did, never less. Returns `null` on an uncountable feed count so a caller can
- * omit the key rather than derive a cadence from nothing.
+ * than it did, never less. Returns `null` on an uncountable feed count so a
+ * caller can omit the key rather than derive a cadence from nothing.
  */
-function lookIntervalMsForFeedCount(feedCount) {
+function lookIntervalMsForFeedCount(feedCount, captureMode = 'per_grab') {
     const n = Number(feedCount);
     if (!Number.isFinite(n) || n < 1)
         return null;
-    const sustainable = Math.ceil((Math.trunc(n) * exports.MEASURED_LOOK_MS) / exports.LOOK_CAPTURE_CONCURRENCY);
-    return Math.min(exports.LEGACY_LOOK_INTERVAL_MS, Math.max(exports.LOOK_INTERVAL_MS, sustainable));
+    const feeds = Math.trunc(n);
+    if (captureMode === 'persistent') {
+        const sustainable = Math.ceil((feeds * exports.MEASURED_LOOK_DETECT_MS) / exports.LOOK_DETECT_CPU_SHARE);
+        return Math.min(exports.LEGACY_LOOK_INTERVAL_MS, Math.max(exports.LOOK_INTERVAL_MS, sustainable));
+    }
+    // The per-grab branch keeps its OWN floor at `MEASURED_LOOK_MS`, not at
+    // `LOOK_INTERVAL_MS`, and that is deliberate rather than tidy.
+    //
+    // Those were the same 2 000 ms until this function learned about capture mode,
+    // so the distinction did not exist and the eval target did the flooring. Now
+    // that `LOOK_INTERVAL_MS` is 500 ms, flooring here would ask a 1-feed per-grab
+    // connector for a look every 1 000 ms instead of every 2 000 ms — DOUBLE the
+    // RTSP session churn on a recorder, derived from a constant that describes a
+    // capture path this branch is not on. And a feed reaches this branch by
+    // DEGRADING (`RTSPStreamCameraProvider` could not hold a persistent session),
+    // i.e. because that recorder has already refused something; doubling its
+    // session rate is precisely the wrong response.
+    //
+    // So: this change moves the per-grab cadence by zero milliseconds at every
+    // feed count, which `connectorCadence.test.ts` asserts against the values that
+    // shipped.
+    const sustainable = Math.ceil((feeds * exports.MEASURED_LOOK_MS) / exports.LOOK_CAPTURE_CONCURRENCY);
+    return Math.min(exports.LEGACY_LOOK_INTERVAL_MS, Math.max(exports.MEASURED_LOOK_MS, sustainable));
+}
+/**
+ * Decoded frames a persistent session must produce per LOOK.
+ *
+ * TWO, and the second one is not waste. `RTSPStreamCameraProvider.getFrame()`
+ * refuses to hand back a frame it has already served — that refusal is the
+ * whole reason a frozen camera cannot report as healthy — so a look that
+ * arrives before the next frame does BLOCKS, and if it blocks past the
+ * staleness deadline it throws on a camera that is working perfectly.
+ *
+ * Running the stream at exactly the look rate makes that a coin flip on every
+ * tick, because neither clock is locked to the other: the session's frame
+ * cadence follows the CAMERA's timestamps and the look cadence follows a Node
+ * timer, and they drift. One frame of headroom removes the race for the cost of
+ * one extra scale+encode per look — the cheapest stage in the pipeline, and one
+ * that never touches the recorder or the model.
+ */
+exports.STREAM_LOOK_HEADROOM = 2;
+/**
+ * Frames per second a persistent session should decode to serve a given look
+ * cadence. Derived, so the two can never be set independently and drift into
+ * the blocking case above.
+ *
+ * At the shipped 500 ms look cadence this is 4 fps — which is also the
+ * provider's own default (`MEASURED_STREAM_FRAME_INTERVAL_MS`), and
+ * `connectorCadence.test.ts` asserts the agreement rather than trusting it.
+ */
+function streamFpsForLookIntervalMs(lookIntervalMs) {
+    const t = Number(lookIntervalMs);
+    if (!Number.isFinite(t) || t <= 0)
+        return 1000 / exports.MEASURED_STREAM_FRAME_INTERVAL_MS;
+    return (exports.STREAM_LOOK_HEADROOM * 1000) / t;
 }
 /**
  * The still-scene analyses/hour a whole connector demands at a heartbeat, and

package/dist/connectorCadence.js.map

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

package/dist/diagnose.d.ts

@@ -31,7 +31,7 @@ export interface DiagnosticReport {
         skipped: number;
     };
 }
-declare const SDK_VERSION = "0.2.59";
+declare const SDK_VERSION = "0.2.60";
 declare function checkNodeVersion(): CheckResult;
 declare function checkPlatform(): CheckResult;
 declare function checkMemory(): CheckResult;

package/dist/diagnose.js

@@ -63,7 +63,7 @@ const localNetworkAccess_1 = require("./localNetworkAccess");
 // ---------------------------------------------------------------------------
 // SDK version — mirrors package.json; kept in sync by CI
 // ---------------------------------------------------------------------------
-const SDK_VERSION = '0.2.59';
+const SDK_VERSION = '0.2.60';
 exports._SDK_VERSION = SDK_VERSION;
 // ---------------------------------------------------------------------------
 // ANSI helpers (no external deps)

package/dist/localSensing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localSensing.d.ts","sourceRoot":"","sources":["../src/localSensing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EACL,qBAAqB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,UAAU,EAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAehD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,mBAAmB,CAElG;AAED,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAE/B;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,MAAM,EAAE,GAC7D,OAAO,CAsCT;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IAuCpD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAvC/B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAuB;IACtD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;IACrD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,YAAY,CAAS;IAC7B;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B,CAA0C;IAC5E,OAAO,CAAC,kBAAkB,CAAK;IAC/B,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAU;IAC9C;;;;;;;;;OASG;IACH,OAAO,CAAC,wBAAwB,CAAK;IACrC,6DAA6D;IAC7D,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAQ;IACxC;;;;OAIG;IACH,cAAc,EAAE,mBAAmB,CAAc;gBAG9B,aAAa,EAAE,iBAAiB,EAChC,YAAY,EAAE,qBAAqB,EACpD,OAAO,GAAE,yBAA8B;IAWzC,WAAW,IAAI,MAAM;IAIrB,kBAAkB,CAAC,YAAY,EAAE,kBAAkB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAItF;;;;;;;;;OASG;YACW,qBAAqB;IAsBnC;;;;;OAKG;IACH,oBAAoB,IAAI,uBAAuB;IAK/C,8EAA8E;IAC9E,sBAAsB,IAAI;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;IAIzC,OAAO,CACX,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,eAAe,GAChE,OAAO,CAAC,uBAAuB,CAAC;CAyDpC;AAED,0EAA0E;AAC1E,MAAM,WAAW,qBAAqB;IACpC,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,cAAc,CAAC;IAC7D,iBAAiB,CAAC,EAAE,CAClB,IAAI,EAAE,YAAY,EAClB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,KAAK,KACT,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC5B,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,iBAAiB,CAAC;IACjE,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,qBAAqB,CAAC;IACpE,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,oBAAoB,GAAG,SAAS,CAAC;IAChF,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;mFAC+E;IAC/E,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;CAChD;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,eAAe,EACvB,IAAI,CAAC,EAAE,qBAAqB,GAC3B,eAAe,EAAE,CA8FnB"}
+{"version":3,"file":"localSensing.d.ts","sourceRoot":"","sources":["../src/localSensing.ts"],"names":[],"mappings":"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"}