@trillboards/edge-sdk 0.2.100 → 0.2.102

package/deploy/systemd/install.sh

@@ -91,10 +91,44 @@ sudo systemctl enable --now trillboards-litertlm \
   *** 'waiting for the on-device model'. Check: sudo systemctl status trillboards-litertlm"
 
 # The verification pass. Idempotent; the serve is up now, so the GPU probe runs.
+VERIFY_OK=1
 sudo -u trillboards HOME=/opt/trillboards bash \
   node_modules/@trillboards/edge-sdk/deploy/systemd/setup-litertlm.sh \
-  || echo "  *** Vision-backend verification did not finish. The connector still runs;
-  *** re-run install.sh to retry."
+  || { VERIFY_OK=0; echo "  *** Vision-backend verification did not finish. The connector still runs;
+  *** re-run install.sh to retry."; }
+
+# APPLY WHAT THE VERIFICATION DECIDED. The pass above can DECIDE but it cannot
+# ACT: `write_litertlm_config` succeeds as the `trillboards` user, and the
+# `restart_litertlm_serve` that would make the process re-read it does not —
+# same nologin / no-sudoers reason as the start. Measured on a fresh box, the
+# verification pass logs exactly this and then leaves the running engine on the
+# old backend:
+#
+#   WARN: GPU vision encoder did not answer a probe inference - falling back to
+#         the CPU encoder
+#   WARN: could not restart trillboards-litertlm
+#   local AI healthy on the CPU vision encoder (slower, but serving)
+#   -> config on disk says CPU, the loaded engine is still GPU, and a real image
+#      call still returns 500 Failed to create conversation
+#
+# A config the process never re-read is a decision nobody acted on. So the whole
+# sequence needs THREE root actions around one unprivileged provisioner: START
+# it (so the probe can run), let it VERIFY, then RESTART it (so the verdict is
+# loaded). install.sh holds root at each point; the provisioner holds it at none.
+# ONLY WHEN THE VERIFICATION ACTUALLY SUCCEEDED. If that pass exited nonzero —
+# `uv tool install --force` failing while repairing a drifted install is the
+# realistic case — there is no verdict to apply, and on an UPGRADE the old
+# in-memory engine is still serving. Restarting into a half-installed state
+# turns a degraded-but-serving box into a dead one, which is a worse outcome
+# than the bug this whole change fixes.
+if [ "$VERIFY_OK" -eq 1 ]; then
+  sudo systemctl restart trillboards-litertlm \
+    || echo "  *** Could not restart LiteRT-LM to apply the verified vision backend.
+  *** Run: sudo systemctl restart trillboards-litertlm"
+else
+  echo "  *** Skipping the LiteRT-LM restart: verification did not complete, so there is
+  *** no verified backend to apply and the running engine is left as it is."
+fi
 
 
 # The on-device OBJECT DETECTOR cascade gate (RF-DETR, 127.0.0.1:9380). Its own

package/dist/EdgeAgent.js

@@ -44,7 +44,7 @@ const edge_ads_1 = require("@trillboards/edge-ads");
 const CommandRouter_1 = require("./CommandRouter");
 const config_1 = require("./config");
 const dataDir_1 = require("./dataDir");
-const SDK_VERSION = '0.2.100';
+const SDK_VERSION = '0.2.102';
 class EdgeAgent extends events_1.EventEmitter {
     constructor(config, deps) {
         super();

package/dist/connectorCadence.d.ts

@@ -90,18 +90,22 @@
  * fire. A floor that ate the whole budget would starve them, and the connector
  * would degrade into reporting empty aisles on time while missing the incident.
  *
- * Two clamps, both from values the system already declares:
- *   - never faster than MIN_ANALYZE_INTERVAL_MS (30 s). This clamp used to read
- *     "never faster than the LOOK interval", which was the same 30 s constant;
- *     the two split on 2026-08-18 and this one is the ANALYZE floor. You still
- *     cannot analyze more often than you look, but the look cadence is now the
- *     faster of the two, so it is no longer what binds here.
+ * Two clamps, and NEITHER is a constant any more:
+ *   - never faster than `analyzeFloorMsForFeedCount` — the LOOK cadence, because
+ *     a frame nobody looked at cannot be analyzed. This clamp read
+ *     `MIN_ANALYZE_INTERVAL_MS` (a flat 30 s) until 2026-08-26; see that
+ *     constant's obituary above for the two claims that turned out not to hold
+ *     and for why removing it cannot saturate the admission slot.
  *   - never slower than the DOOH default (300 s): this can only make a
  *     connector sample MORE often than it does today, never less.
  *
- * Result, at the measured 7.30 s: 1-2 feeds 30 s, 4 feeds 59 s, 8 feeds 117 s,
- * 16 feeds 234 s, 21+ feeds pinned at 300 s. A deployment of seven or fewer
- * feeds per host resolves the 111-second threshold; past that the operator
+ * Result, on the 7.30 s BOOTSTRAP: 1 feed 14.6 s, 2 feeds 29.2 s, 4 feeds 59 s,
+ * 8 feeds 117 s, 16 feeds 234 s, 21+ feeds pinned at 300 s. The 4-feed row and
+ * everything slower are UNCHANGED by the 2026-08-26 removal — the flat floor only
+ * ever bound 1 and 2 feeds on the bootstrap. It bound far more on a box that had
+ * measured itself, which is the whole point: at the fleet's measured 2.75 s it
+ * bound every count up to 5, and at 0.50 s every count up to 30. A deployment of
+ * seven or fewer feeds per host resolves the 111-second threshold; past that the operator
  * needs a second connector host, and `getSensingHealth()` already reports the
  * honest effective interval so that shows up rather than hiding.
  *
@@ -252,28 +256,121 @@ export declare const STILL_FLOOR_SLOT_SHARE = 0.5;
  * magnitude, and is the only thing that would.
  */
 /**
- * The fastest a connector may ANALYZE one feed, in ms.
- *
- * SEPARATE FROM `LOOK_INTERVAL_MS` since 2026-08-18, and the separation is the
- * whole point. Both were 30 000 and one constant did both jobs, so nothing
- * anywhere distinguished "how often do we look at the scene" from "how often
- * may we spend an inference on it" — and the look cadence could not be lowered
- * without dragging the analyze floor down with it and multiplying VLM volume on
- * a 493/hour ceiling.
- *
- * 30 s is not a fresh judgement; it is the value the system already declares in
- * two independent places, now named once:
- *   - `faceTriggeredIntervalMs` (`DEFAULT_FACE_MS`, 30 s) is the default for
- *     `MotionGate.minAnalyzeIntervalMs` — the floor between two motion-driven
- *     analyses of one feed.
- *   - `vision_pacing_config.daily_limit_per_screen` is 2 880 for the connector
- *     fleet, i.e. 86 400 / 2 880 = one analysis per 30 s, enforced server-side.
- *
- * So a connector that analyzed faster than this would be throttled by the
- * server anyway. Lowering the LOOK cadence must not move this number, and the
- * `analyzeFloorUnmovedByLookCadence` test asserts exactly that.
+ * ── THE 30 s ANALYZE FLOOR IS GONE (2026-08-26), AND WHY IT WAS NEVER A BOUND ──
+ *
+ * `MIN_ANALYZE_INTERVAL_MS = 30_000` used to live here and clamp
+ * `periodicIntervalMsForFeedCount` from below. It is deleted rather than
+ * lowered, because the two things it claimed to restate do not hold:
+ *
+ *   1. "`faceTriggeredIntervalMs` (`DEFAULT_FACE_MS`, 30 s) is the default for
+ *      `MotionGate.minAnalyzeIntervalMs`."  TRUE, and irrelevant to THIS
+ *      number. `MotionGate.evaluate` resolves `heartbeatDue` FIRST and returns
+ *      before `isRateLimited` is ever consulted (SceneChangeDetector.ts:616 vs
+ *      :663), and `isRateLimited`'s own docblock says what it gates: "Is a
+ *      MOTION-triggered analysis throttled right now?". The motion floor bounds
+ *      the `motion` and `audio_onset` verdicts. It has never bounded the
+ *      heartbeat. Restating it here made one datum live in two files and then
+ *      let the copy govern a quantity the original does not.
+ *
+ *   2. "`vision_pacing_config.daily_limit_per_screen` is 2 880 for the
+ *      connector fleet ... enforced server-side."  FALSE for this connector,
+ *      three ways over. `checkRateLimit()` has exactly one call site —
+ *      `audienceVisionService.analyzeFrame`, the CLOUD path. The handler-top
+ *      capped gate skips local frames by construction
+ *      (`earner-misc.js`: `if (!hasPreAnalyzed && screenId)`). And
+ *      `ingestPreAnalyzedFrame`, which is the path every `local-vlm` row is
+ *      written by, says it in as many words: "we do NOT touch the rate limiter
+ *      or Vertex client". The connector has been local-inference only since
+ *      0.2.41, so the sentence "a connector that analyzed faster than this would
+ *      be throttled by the server anyway" described a path that no longer runs.
+ *      (It could not have obeyed one either: there is no 429 handling anywhere
+ *      in `AudienceAnalyzeClient`.)
+ *
+ * So the floor protected no resource that `required` does not already protect.
+ * What it cost is the product: at the fleet's MEASURED `local-vlm` p50 of
+ * 2 750 ms (`vision_call_log`, 2026-08-26) a one-feed connector can afford a
+ * 5 500 ms heartbeat and was pinned at 30 000 — 5.45x of hazard-persistence
+ * resolution thrown away against the 111-second constructive-notice bracket
+ * this whole file exists to resolve. On an M4 Max at 0.50 s/frame it was 30x,
+ * and every feed count up to 30 was pinned at the same 30 s.
+ *
+ * ── WHAT REPLACES IT: the look cadence, which is derived ────────────────────
+ *
+ * There is exactly one lower bound left that is not the slot budget, and it is
+ * a fact rather than a judgement: YOU CANNOT ANALYZE A FRAME YOU NEVER LOOKED
+ * AT. That is `lookIntervalMsForFeedCount`, already in this file, already
+ * derived per capture path and per feed count. See
+ * `analyzeFloorMsForFeedCount`.
+ *
+ * ── THE FAILURE MODE THIS MUST STILL AVOID, AND WHY IT DOES ────────────────
+ *
+ * `VlmAdmissionGate` holds ONE slot and DROPS rather than queues. On a box
+ * whose slot is saturated every feed is permanently heartbeat-due, so every
+ * look returns `analyze: true`, the motion gate stops gating anything, and the
+ * frames are dropped at admission having bought no measurement —
+ * `DetectorShadowProbe` measured that regime at 64 detector verdicts/second at
+ * 32 feeds.
+ *
+ * The derivation cannot enter it. `required` IS the cadence at which N feeds
+ * consume exactly `STILL_FLOOR_SLOT_SHARE` of the one slot, so flooring at
+ * `required` targets 50% utilisation by construction and can never saturate.
+ * Saturation comes only from a heartbeat set BELOW `required` — which is what a
+ * 5 s `sensing_profiles.capture_interval_ms` row asks for, and which the floor
+ * still refuses. What changed is only that the refusal is now computed from
+ * this machine instead of asserted at 30 s for every machine.
+ *
+ * Note also what the ceiling is NOT: analyses/hour for a whole connector is
+ * `feeds x 3600000 / required` = `3600 x SLOT_SHARE / perFrameSeconds`, which
+ * is INDEPENDENT of the feed count — 654/hour on the measured 2.75 s box,
+ * 3 600/hour on a 0.50 s one. Removing the clamp cannot produce unbounded load
+ * on any box; it can only let a box reach its own honest 50%.
  */
-export declare const MIN_ANALYZE_INTERVAL_MS = 30000;
+/**
+ * The floor between two MOTION-triggered analyses of ONE feed, in ms.
+ *
+ * This is the HALF of the deleted `MIN_ANALYZE_INTERVAL_MS` that was always
+ * real, separated out and named for what it is. That constant conflated two
+ * quantities — the motion floor and the still-scene heartbeat floor — and the
+ * conflation is what let a motion-path number govern a path it has never gated
+ * (`MotionGate.evaluate` resolves `heartbeatDue` first and returns before
+ * `isRateLimited` is consulted).
+ *
+ * `CloudSensingManager.DEFAULT_FACE_MS` is the SINGLE HOME of this value: it is
+ * what `faceTriggeredIntervalMs` defaults to and what the manager hands
+ * `MotionGate` as `minAnalyzeIntervalMs`. Restated here rather than imported so
+ * that `connectorCadence` stays a leaf with no manager dependency — the same
+ * treatment `LOOK_CAPTURE_CONCURRENCY` and `MEASURED_STREAM_FRAME_INTERVAL_MS`
+ * already get — and pinned against the real one by `connectorCadence.test.ts`
+ * so the two cannot drift.
+ *
+ * NOTHING IN THIS FILE'S DERIVATION MAY READ IT. It is exported for consumers
+ * that genuinely mean the motion path: the duration contract's `derivedFrom`,
+ * and `sense-e2e-soak.js`'s zero-hold rungs, whose six shapes all produce motion
+ * and are therefore analyzed on the motion path rather than by the heartbeat. A
+ * `periodicIntervalMsForFeedCount` that floored on this again would be the exact
+ * hack that came out on 2026-08-26, and the source scan in
+ * `connectorCadence.test.ts` fails the build if it does.
+ */
+export declare const MOTION_ANALYZE_FLOOR_MS = 30000;
+/**
+ * The fastest a connector may ANALYZE one feed, in ms — DERIVED, not declared.
+ *
+ * A look is what puts a frame in front of the model, so the analyze cadence can
+ * never be finer than the look cadence; asking for one produces no extra
+ * analyses, just a `getSensingHealth()` that reports a cadence the connector is
+ * not running. `lookIntervalMsForFeedCount` already derives that per feed count
+ * and per capture path, so this is a rename of an existing quantity rather than
+ * a new bound — which is the point. There is no constant here to drift.
+ *
+ * `captureMode` defaults to `'per_grab'` because that is the SLOWER of the two
+ * paths (2 000 ms against a sub-millisecond ring read) and a floor should be
+ * conservative when the caller does not know which path a feed is on. A feed
+ * reaches per-grab by DEGRADING, so assuming it is the honest default.
+ *
+ * Returns `null` on an uncountable feed count, exactly as its two siblings do,
+ * so a caller can omit the key rather than derive a cadence from nothing.
+ */
+export declare function analyzeFloorMsForFeedCount(feedCount: unknown, captureMode?: CaptureMode): number | null;
 /**
  * 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.
@@ -403,12 +500,12 @@ export declare const LOOK_CAPTURE_CONCURRENCY = 2;
  * The look cadence this connector ran until 2026-08-18, kept ONLY as the slow
  * clamp on `lookIntervalMsForFeedCount`.
  *
- * It is numerically equal to `MIN_ANALYZE_INTERVAL_MS` and that is a
+ * It is numerically equal to `MOTION_ANALYZE_FLOOR_MS` and that is a
  * coincidence of history, not a relationship: they were one constant, and the
- * whole point of the split is that they are free to move independently. Using
- * the analyze floor here would re-create exactly the conflation this change
- * removes — a future PR that lowers the analyze floor would silently speed up
- * the slowest look cadence with it.
+ * whole point of the split is that they are free to move independently. Using a
+ * motion-path number here would re-create exactly the conflation that change
+ * removes. The 2026-08-26 removal of the flat still-scene floor is the proof it
+ * was worth splitting: that number went away entirely and this one did not move.
  *
  * Its only job is a guarantee: deriving a look cadence can make a connector look
  * MORE often than it used to, never less. A 32-feed host cannot sustain even
@@ -471,10 +568,14 @@ export declare const LEGACY_LOOK_INTERVAL_MS = 30000;
  * 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.
+ *   - the MOTION floor is a SEPARATE quantity (`MOTION_ANALYZE_FLOOR_MS`, 30 s,
+ *     restating `DEFAULT_FACE_MS`) and is what `MotionGate.minAnalyzeIntervalMs`
+ *     floors on. It is untouched by anything on the look side.
+ *   - `periodicIntervalMsForFeedCount` floors on the SLOT BUDGET, and on the
+ *     look cadence only where the budget is smaller still — which is no feed
+ *     count on the bootstrap and none on any box measured to date. Since
+ *     2026-08-26 the look cadence IS the other term (`analyzeFloorMsForFeedCount`),
+ *     and it is the honest one: a frame nobody looked at cannot be analyzed.
  *   - 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:
@@ -509,7 +610,13 @@ export declare function periodicIntervalMsForFeedCount(feedCount: unknown,
  * path: the equation was always per-machine, and until 2026-08-19 only its
  * input was global.
  */
-analyzeMs?: number | null): number | null;
+analyzeMs?: number | null, 
+/**
+ * How this connector's feeds are acquired. Only reaches the LOOK-derived
+ * floor (`analyzeFloorMsForFeedCount`), and defaults conservatively — see
+ * that function for why `'per_grab'` is the honest default.
+ */
+captureMode?: CaptureMode): number | null;
 /**
  * How a feed's frames are acquired. The look cadence a connector can SUSTAIN
  * depends on this and on nothing else about the box.

package/dist/connectorCadence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connectorCadence.d.ts","sourceRoot":"","sources":["../src/connectorCadence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmHG;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;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,CAC5C,SAAS,EAAE,OAAO;AAClB;;;;;;;;;;GAUG;AACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GACxB,MAAM,GAAG,IAAI,CAkCf;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"}
+{"version":3,"file":"connectorCadence.d.ts","sourceRoot":"","sources":["../src/connectorCadence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuHG;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,OAAO,EAClB,WAAW,GAAE,WAAwB,GACpC,MAAM,GAAG,IAAI,CAEf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,SAAU,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,OAAO;AAClB;;;;;;;;;;GAUG;AACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;AACzB;;;;GAIG;AACH,WAAW,GAAE,WAAwB,GACpC,MAAM,GAAG,IAAI,CA+Cf;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

@@ -91,18 +91,22 @@
  * fire. A floor that ate the whole budget would starve them, and the connector
  * would degrade into reporting empty aisles on time while missing the incident.
  *
- * Two clamps, both from values the system already declares:
- *   - never faster than MIN_ANALYZE_INTERVAL_MS (30 s). This clamp used to read
- *     "never faster than the LOOK interval", which was the same 30 s constant;
- *     the two split on 2026-08-18 and this one is the ANALYZE floor. You still
- *     cannot analyze more often than you look, but the look cadence is now the
- *     faster of the two, so it is no longer what binds here.
+ * Two clamps, and NEITHER is a constant any more:
+ *   - never faster than `analyzeFloorMsForFeedCount` — the LOOK cadence, because
+ *     a frame nobody looked at cannot be analyzed. This clamp read
+ *     `MIN_ANALYZE_INTERVAL_MS` (a flat 30 s) until 2026-08-26; see that
+ *     constant's obituary above for the two claims that turned out not to hold
+ *     and for why removing it cannot saturate the admission slot.
  *   - never slower than the DOOH default (300 s): this can only make a
  *     connector sample MORE often than it does today, never less.
  *
- * Result, at the measured 7.30 s: 1-2 feeds 30 s, 4 feeds 59 s, 8 feeds 117 s,
- * 16 feeds 234 s, 21+ feeds pinned at 300 s. A deployment of seven or fewer
- * feeds per host resolves the 111-second threshold; past that the operator
+ * Result, on the 7.30 s BOOTSTRAP: 1 feed 14.6 s, 2 feeds 29.2 s, 4 feeds 59 s,
+ * 8 feeds 117 s, 16 feeds 234 s, 21+ feeds pinned at 300 s. The 4-feed row and
+ * everything slower are UNCHANGED by the 2026-08-26 removal — the flat floor only
+ * ever bound 1 and 2 feeds on the bootstrap. It bound far more on a box that had
+ * measured itself, which is the whole point: at the fleet's measured 2.75 s it
+ * bound every count up to 5, and at 0.50 s every count up to 30. A deployment of
+ * seven or fewer feeds per host resolves the 111-second threshold; past that the operator
  * needs a second connector host, and `getSensingHealth()` already reports the
  * honest effective interval so that shows up rather than hiding.
  *
@@ -116,7 +120,8 @@
  * what the operator wants; this says what the machine can deliver.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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.MOTION_ANALYZE_FLOOR_MS = exports.STILL_FLOOR_SLOT_SHARE = exports.MEASURED_LOCAL_ANALYZE_MS = void 0;
+exports.analyzeFloorMsForFeedCount = analyzeFloorMsForFeedCount;
 exports.periodicIntervalMsForFeedCount = periodicIntervalMsForFeedCount;
 exports.lookIntervalMsForFeedCount = lookIntervalMsForFeedCount;
 exports.streamFpsForLookIntervalMs = streamFpsForLookIntervalMs;
@@ -259,28 +264,123 @@ exports.STILL_FLOOR_SLOT_SHARE = 0.5;
  * magnitude, and is the only thing that would.
  */
 /**
- * The fastest a connector may ANALYZE one feed, in ms.
- *
- * SEPARATE FROM `LOOK_INTERVAL_MS` since 2026-08-18, and the separation is the
- * whole point. Both were 30 000 and one constant did both jobs, so nothing
- * anywhere distinguished "how often do we look at the scene" from "how often
- * may we spend an inference on it" — and the look cadence could not be lowered
- * without dragging the analyze floor down with it and multiplying VLM volume on
- * a 493/hour ceiling.
- *
- * 30 s is not a fresh judgement; it is the value the system already declares in
- * two independent places, now named once:
- *   - `faceTriggeredIntervalMs` (`DEFAULT_FACE_MS`, 30 s) is the default for
- *     `MotionGate.minAnalyzeIntervalMs` — the floor between two motion-driven
- *     analyses of one feed.
- *   - `vision_pacing_config.daily_limit_per_screen` is 2 880 for the connector
- *     fleet, i.e. 86 400 / 2 880 = one analysis per 30 s, enforced server-side.
- *
- * So a connector that analyzed faster than this would be throttled by the
- * server anyway. Lowering the LOOK cadence must not move this number, and the
- * `analyzeFloorUnmovedByLookCadence` test asserts exactly that.
+ * ── THE 30 s ANALYZE FLOOR IS GONE (2026-08-26), AND WHY IT WAS NEVER A BOUND ──
+ *
+ * `MIN_ANALYZE_INTERVAL_MS = 30_000` used to live here and clamp
+ * `periodicIntervalMsForFeedCount` from below. It is deleted rather than
+ * lowered, because the two things it claimed to restate do not hold:
+ *
+ *   1. "`faceTriggeredIntervalMs` (`DEFAULT_FACE_MS`, 30 s) is the default for
+ *      `MotionGate.minAnalyzeIntervalMs`."  TRUE, and irrelevant to THIS
+ *      number. `MotionGate.evaluate` resolves `heartbeatDue` FIRST and returns
+ *      before `isRateLimited` is ever consulted (SceneChangeDetector.ts:616 vs
+ *      :663), and `isRateLimited`'s own docblock says what it gates: "Is a
+ *      MOTION-triggered analysis throttled right now?". The motion floor bounds
+ *      the `motion` and `audio_onset` verdicts. It has never bounded the
+ *      heartbeat. Restating it here made one datum live in two files and then
+ *      let the copy govern a quantity the original does not.
+ *
+ *   2. "`vision_pacing_config.daily_limit_per_screen` is 2 880 for the
+ *      connector fleet ... enforced server-side."  FALSE for this connector,
+ *      three ways over. `checkRateLimit()` has exactly one call site —
+ *      `audienceVisionService.analyzeFrame`, the CLOUD path. The handler-top
+ *      capped gate skips local frames by construction
+ *      (`earner-misc.js`: `if (!hasPreAnalyzed && screenId)`). And
+ *      `ingestPreAnalyzedFrame`, which is the path every `local-vlm` row is
+ *      written by, says it in as many words: "we do NOT touch the rate limiter
+ *      or Vertex client". The connector has been local-inference only since
+ *      0.2.41, so the sentence "a connector that analyzed faster than this would
+ *      be throttled by the server anyway" described a path that no longer runs.
+ *      (It could not have obeyed one either: there is no 429 handling anywhere
+ *      in `AudienceAnalyzeClient`.)
+ *
+ * So the floor protected no resource that `required` does not already protect.
+ * What it cost is the product: at the fleet's MEASURED `local-vlm` p50 of
+ * 2 750 ms (`vision_call_log`, 2026-08-26) a one-feed connector can afford a
+ * 5 500 ms heartbeat and was pinned at 30 000 — 5.45x of hazard-persistence
+ * resolution thrown away against the 111-second constructive-notice bracket
+ * this whole file exists to resolve. On an M4 Max at 0.50 s/frame it was 30x,
+ * and every feed count up to 30 was pinned at the same 30 s.
+ *
+ * ── WHAT REPLACES IT: the look cadence, which is derived ────────────────────
+ *
+ * There is exactly one lower bound left that is not the slot budget, and it is
+ * a fact rather than a judgement: YOU CANNOT ANALYZE A FRAME YOU NEVER LOOKED
+ * AT. That is `lookIntervalMsForFeedCount`, already in this file, already
+ * derived per capture path and per feed count. See
+ * `analyzeFloorMsForFeedCount`.
+ *
+ * ── THE FAILURE MODE THIS MUST STILL AVOID, AND WHY IT DOES ────────────────
+ *
+ * `VlmAdmissionGate` holds ONE slot and DROPS rather than queues. On a box
+ * whose slot is saturated every feed is permanently heartbeat-due, so every
+ * look returns `analyze: true`, the motion gate stops gating anything, and the
+ * frames are dropped at admission having bought no measurement —
+ * `DetectorShadowProbe` measured that regime at 64 detector verdicts/second at
+ * 32 feeds.
+ *
+ * The derivation cannot enter it. `required` IS the cadence at which N feeds
+ * consume exactly `STILL_FLOOR_SLOT_SHARE` of the one slot, so flooring at
+ * `required` targets 50% utilisation by construction and can never saturate.
+ * Saturation comes only from a heartbeat set BELOW `required` — which is what a
+ * 5 s `sensing_profiles.capture_interval_ms` row asks for, and which the floor
+ * still refuses. What changed is only that the refusal is now computed from
+ * this machine instead of asserted at 30 s for every machine.
+ *
+ * Note also what the ceiling is NOT: analyses/hour for a whole connector is
+ * `feeds x 3600000 / required` = `3600 x SLOT_SHARE / perFrameSeconds`, which
+ * is INDEPENDENT of the feed count — 654/hour on the measured 2.75 s box,
+ * 3 600/hour on a 0.50 s one. Removing the clamp cannot produce unbounded load
+ * on any box; it can only let a box reach its own honest 50%.
  */
-exports.MIN_ANALYZE_INTERVAL_MS = 30000;
+/**
+ * The floor between two MOTION-triggered analyses of ONE feed, in ms.
+ *
+ * This is the HALF of the deleted `MIN_ANALYZE_INTERVAL_MS` that was always
+ * real, separated out and named for what it is. That constant conflated two
+ * quantities — the motion floor and the still-scene heartbeat floor — and the
+ * conflation is what let a motion-path number govern a path it has never gated
+ * (`MotionGate.evaluate` resolves `heartbeatDue` first and returns before
+ * `isRateLimited` is consulted).
+ *
+ * `CloudSensingManager.DEFAULT_FACE_MS` is the SINGLE HOME of this value: it is
+ * what `faceTriggeredIntervalMs` defaults to and what the manager hands
+ * `MotionGate` as `minAnalyzeIntervalMs`. Restated here rather than imported so
+ * that `connectorCadence` stays a leaf with no manager dependency — the same
+ * treatment `LOOK_CAPTURE_CONCURRENCY` and `MEASURED_STREAM_FRAME_INTERVAL_MS`
+ * already get — and pinned against the real one by `connectorCadence.test.ts`
+ * so the two cannot drift.
+ *
+ * NOTHING IN THIS FILE'S DERIVATION MAY READ IT. It is exported for consumers
+ * that genuinely mean the motion path: the duration contract's `derivedFrom`,
+ * and `sense-e2e-soak.js`'s zero-hold rungs, whose six shapes all produce motion
+ * and are therefore analyzed on the motion path rather than by the heartbeat. A
+ * `periodicIntervalMsForFeedCount` that floored on this again would be the exact
+ * hack that came out on 2026-08-26, and the source scan in
+ * `connectorCadence.test.ts` fails the build if it does.
+ */
+exports.MOTION_ANALYZE_FLOOR_MS = 30000;
+/**
+ * The fastest a connector may ANALYZE one feed, in ms — DERIVED, not declared.
+ *
+ * A look is what puts a frame in front of the model, so the analyze cadence can
+ * never be finer than the look cadence; asking for one produces no extra
+ * analyses, just a `getSensingHealth()` that reports a cadence the connector is
+ * not running. `lookIntervalMsForFeedCount` already derives that per feed count
+ * and per capture path, so this is a rename of an existing quantity rather than
+ * a new bound — which is the point. There is no constant here to drift.
+ *
+ * `captureMode` defaults to `'per_grab'` because that is the SLOWER of the two
+ * paths (2 000 ms against a sub-millisecond ring read) and a floor should be
+ * conservative when the caller does not know which path a feed is on. A feed
+ * reaches per-grab by DEGRADING, so assuming it is the honest default.
+ *
+ * Returns `null` on an uncountable feed count, exactly as its two siblings do,
+ * so a caller can omit the key rather than derive a cadence from nothing.
+ */
+function analyzeFloorMsForFeedCount(feedCount, captureMode = 'per_grab') {
+    return lookIntervalMsForFeedCount(feedCount, captureMode);
+}
 /**
  * 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.
@@ -410,12 +510,12 @@ exports.LOOK_CAPTURE_CONCURRENCY = 2;
  * The look cadence this connector ran until 2026-08-18, kept ONLY as the slow
  * clamp on `lookIntervalMsForFeedCount`.
  *
- * It is numerically equal to `MIN_ANALYZE_INTERVAL_MS` and that is a
+ * It is numerically equal to `MOTION_ANALYZE_FLOOR_MS` and that is a
  * coincidence of history, not a relationship: they were one constant, and the
- * whole point of the split is that they are free to move independently. Using
- * the analyze floor here would re-create exactly the conflation this change
- * removes — a future PR that lowers the analyze floor would silently speed up
- * the slowest look cadence with it.
+ * whole point of the split is that they are free to move independently. Using a
+ * motion-path number here would re-create exactly the conflation that change
+ * removes. The 2026-08-26 removal of the flat still-scene floor is the proof it
+ * was worth splitting: that number went away entirely and this one did not move.
  *
  * Its only job is a guarantee: deriving a look cadence can make a connector look
  * MORE often than it used to, never less. A 32-feed host cannot sustain even
@@ -478,10 +578,14 @@ exports.LEGACY_LOOK_INTERVAL_MS = 30000;
  * 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.
+ *   - the MOTION floor is a SEPARATE quantity (`MOTION_ANALYZE_FLOOR_MS`, 30 s,
+ *     restating `DEFAULT_FACE_MS`) and is what `MotionGate.minAnalyzeIntervalMs`
+ *     floors on. It is untouched by anything on the look side.
+ *   - `periodicIntervalMsForFeedCount` floors on the SLOT BUDGET, and on the
+ *     look cadence only where the budget is smaller still — which is no feed
+ *     count on the bootstrap and none on any box measured to date. Since
+ *     2026-08-26 the look cadence IS the other term (`analyzeFloorMsForFeedCount`),
+ *     and it is the honest one: a frame nobody looked at cannot be analyzed.
  *   - 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:
@@ -516,7 +620,13 @@ function periodicIntervalMsForFeedCount(feedCount,
  * path: the equation was always per-machine, and until 2026-08-19 only its
  * input was global.
  */
-analyzeMs) {
+analyzeMs, 
+/**
+ * How this connector's feeds are acquired. Only reaches the LOOK-derived
+ * floor (`analyzeFloorMsForFeedCount`), and defaults conservatively — see
+ * that function for why `'per_grab'` is the honest default.
+ */
+captureMode = 'per_grab') {
     const n = Number(feedCount);
     if (!Number.isFinite(n) || n < 1)
         return null;
@@ -545,12 +655,25 @@ analyzeMs) {
     // and the fix is a second connector host, which `getSensingHealth()` already
     // reports enough to see. Changing this constant would trade a measurable
     // alert-path regression for a cadence number that reads tidier.
-    // Floored at the ANALYZE floor, never at the LOOK cadence. Those were the
-    // same constant until 2026-08-18; clamping this at the look cadence now would
-    // let a faster look cadence pull the still-scene heartbeat down with it and
-    // double the analyses a 1-feed connector runs, which is the exact failure the
-    // look/analyze split exists to prevent.
-    return Math.min(exports.DOOH_PERIODIC_MS, Math.max(exports.MIN_ANALYZE_INTERVAL_MS, required));
+    // Floored at the LOOK cadence, which is the only lower bound left that is not
+    // the slot budget itself, and is a fact rather than a judgement: a frame
+    // nobody looked at cannot be analyzed.
+    //
+    // This read a flat `MIN_ANALYZE_INTERVAL_MS` (30 s) until 2026-08-26. The
+    // 2026-08-18 note that used to sit here warned that flooring on the look
+    // cadence would "let a faster look cadence pull the still-scene heartbeat down
+    // with it and double the analyses a 1-feed connector runs". That is exactly
+    // what this now does, deliberately, and the warning's arithmetic is what makes
+    // it safe rather than what makes it dangerous: the heartbeat lands at
+    // `required` — 50% of the one slot BY CONSTRUCTION — for every box on which
+    // `required` exceeds the look cadence, which is every box measured to date at
+    // every feed count. The look floor binds only where `required` is smaller
+    // still, i.e. on a machine fast enough that the CAPTURE path, not the model,
+    // is the scarce thing. Doubling a 1-feed connector's analyses is the product
+    // working: it is 5.45x of hazard-persistence resolution at the fleet's
+    // measured per-frame cost, against a 111-second bracket.
+    const lookFloor = analyzeFloorMsForFeedCount(n, captureMode) ?? 0;
+    return Math.min(exports.DOOH_PERIODIC_MS, Math.max(lookFloor, required));
 }
 /**
  * The fastest look cadence a connector running `feedCount` feeds can actually

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/deployedCadence.d.ts

@@ -65,6 +65,7 @@
  *
  * It is a 32-bit `setTimeout` overflow guard. See its own docs below.
  */
+import { type CaptureMode } from './connectorCadence';
 /**
  * Kept as a single-member type rather than deleted: it names the axis (WHICH
  * run mode is being metered) that the callers still pass, and re-introducing a
@@ -110,12 +111,16 @@ export type CadenceReason =
 /** Slowed to fit the single local inference slot. */
  | 'local_inference_budget'
 /**
- * Faster than the connector may ANALYZE one feed.
+ * Faster than the connector may ANALYZE one feed, because it is faster than
+ * the connector LOOKS at one — a frame nobody looked at cannot be analyzed.
  *
  * Named `look_interval` until 2026-08-18, when the look cadence and the
- * analyze floor stopped being the same 30 000 ms constant. The old name now
- * describes the wrong quantity: the connector looks every 2 s and this clamp
- * is about the 30 s floor between two inferences.
+ * analyze floor stopped being the same 30 000 ms constant, and pointed at a
+ * flat `MIN_ANALYZE_INTERVAL_MS = 30_000` until 2026-08-26, when that constant
+ * was deleted for restating a motion-gate floor that never bounded the
+ * heartbeat. It now means what its 2018-era name meant again: the capture path,
+ * not the model, is the scarce thing on this box. That is rare and it is
+ * REPORTED rather than assumed — `local_inference_budget` is the ordinary case.
  */
  | 'analyze_floor'
 /** SPED UP to `MAX_CADENCE_MS`: the request was slower than a capture loop can express. */
@@ -150,5 +155,11 @@ export declare function resolveDeployedCadence(input: {
      * while it is still on the bootstrap constant. See `AnalyzeCostObserver`.
      */
     analyzeMs?: number | null;
+    /**
+     * How this connector's feeds are acquired, when the caller knows. Reaches
+     * only the LOOK-derived floor; omitted falls back to the conservative
+     * `'per_grab'` — see `analyzeFloorMsForFeedCount`.
+     */
+    captureMode?: CaptureMode;
 }): DeployedCadence;
 //# sourceMappingURL=deployedCadence.d.ts.map

package/dist/deployedCadence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deployedCadence.d.ts","sourceRoot":"","sources":["../src/deployedCadence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAQH;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,QAAmB,CAAC;AAE/C,MAAM,MAAM,aAAa;AACvB,4EAA4E;AAC1E,YAAY;AACd;;;GAGG;GACD,iBAAiB;AACnB,uEAAuE;GACrE,kBAAkB;AACpB,qDAAqD;GACnD,wBAAwB;AAC1B;;;;;;;GAOG;GACD,eAAe;AACjB,2FAA2F;GACzF,iBAAiB,CAAC;AAEtB,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,mFAAmF;IACnF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;CACvB;AASD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GAAG,eAAe,CAoFlB"}
+{"version":3,"file":"deployedCadence.d.ts","sourceRoot":"","sources":["../src/deployedCadence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAEH,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,QAAmB,CAAC;AAE/C,MAAM,MAAM,aAAa;AACvB,4EAA4E;AAC1E,YAAY;AACd;;;GAGG;GACD,iBAAiB;AACnB,uEAAuE;GACrE,kBAAkB;AACpB,qDAAqD;GACnD,wBAAwB;AAC1B;;;;;;;;;;;GAWG;GACD,eAAe;AACjB,2FAA2F;GACzF,iBAAiB,CAAC;AAEtB,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,mFAAmF;IACnF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;CACvB;AASD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,GAAG,eAAe,CA+FlB"}

package/dist/deployedCadence.js

@@ -118,18 +118,21 @@ function resolveDeployedCadence(input) {
     // cadence derived from nothing.
     // `analyzeMs` is what THIS box measured for itself; undefined/null means it has
     // not measured itself yet and the conservative bootstrap constant governs.
-    const floorMs = (0, connectorCadence_1.periodicIntervalMsForFeedCount)(input.feedCount, input.analyzeMs) ?? connectorCadence_1.DOOH_PERIODIC_MS;
-    // A cadence finer than the connector may ANALYZE is not deliverable, so it is
-    // a floor in every case. This read `LOOK_INTERVAL_MS` until 2026-08-18, when
-    // the two constants split: both were 30 000 ms, so the substitution changes no
-    // value today — but the look cadence is now 2 000 ms, and leaving this pointed
-    // at it would let a 5 s profile row land a 5 s heartbeat and multiply the
-    // still-scene analyses of every connector in the fleet.
+    const floorMs = (0, connectorCadence_1.periodicIntervalMsForFeedCount)(input.feedCount, input.analyzeMs, input.captureMode) ?? connectorCadence_1.DOOH_PERIODIC_MS;
+    // `periodicIntervalMsForFeedCount` already carries BOTH lower bounds — the
+    // slot budget and the look cadence — so there is nothing to re-floor here.
     //
-    // The ceiling wins over the floor: honouring a floor slower than a whole day
-    // would hand a capture loop a delay it cannot express (see MAX_CADENCE_MS) —
-    // the one clamp that must never be negotiable.
-    const effectiveFloor = Math.min(exports.MAX_CADENCE_MS, Math.max(floorMs, connectorCadence_1.MIN_ANALYZE_INTERVAL_MS));
+    // Until 2026-08-26 this line read `Math.max(floorMs, MIN_ANALYZE_INTERVAL_MS)`
+    // and applied a flat 30 s a second time. That was already a no-op in every
+    // reachable state (the derivation floored at the same constant internally, and
+    // its only other outcome is the 300 000 ms fallback), so deleting the constant
+    // changes no value on this line — but it does stop a second copy of the same
+    // assertion from silently becoming the binding one when the first stops being.
+    //
+    // The ceiling still wins over the floor: honouring a floor slower than a whole
+    // day would hand a capture loop a delay it cannot express (see MAX_CADENCE_MS)
+    // — the one clamp that must never be negotiable.
+    const effectiveFloor = Math.min(exports.MAX_CADENCE_MS, floorMs);
     if (requestedMs === null) {
         // The profile answered and asked for nothing. Fall back to the cadence this
         // machine can afford, NOT to whatever the manager happened to be built with.
@@ -178,7 +181,13 @@ function resolveDeployedCadence(input) {
         reason = 'cadence_ceiling';
     }
     else if (clamped) {
-        if (effectiveFloor === connectorCadence_1.MIN_ANALYZE_INTERVAL_MS && floorMs <= connectorCadence_1.MIN_ANALYZE_INTERVAL_MS)
+        // WHICH of the two derived bounds actually bit? Both are per-box, so this is
+        // a real distinction and not a spelling one: `analyze_floor` means the
+        // CAPTURE path is the scarce thing (the box outruns its own cameras),
+        // `local_inference_budget` means the MODEL is. An operator who is told the
+        // wrong one buys the wrong hardware.
+        const lookFloorMs = (0, connectorCadence_1.analyzeFloorMsForFeedCount)(input.feedCount, input.captureMode);
+        if (lookFloorMs !== null && effectiveFloor === lookFloorMs)
             reason = 'analyze_floor';
         else
             reason = 'local_inference_budget';

package/dist/deployedCadence.js.map

@@ -1 +1 @@
-{"version":3,"file":"deployedCadence.js","sourceRoot":"","sources":["../src/deployedCadence.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"deployedCadence.js","sourceRoot":"","sources":["../src/deployedCadence.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.100";
+declare const SDK_VERSION = "0.2.102";
 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.100';
+const SDK_VERSION = '0.2.102';
 exports._SDK_VERSION = SDK_VERSION;
 // ---------------------------------------------------------------------------
 // ANSI helpers (no external deps)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trillboards/edge-sdk",
-  "version": "0.2.100",
+  "version": "0.2.102",
   "description": "Composable cross-platform Edge AI SDK for audience sensing on DOOH/CTV devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@trillboards/edge-core": "^0.4.1",
+    "@trillboards/edge-core": "^0.4.5",
     "@trillboards/edge-sensing": "^0.2.4",
     "@trillboards/edge-federated": "^0.2.0 || ^1.0.0",
     "@trillboards/edge-ads": "^0.2.0",