@trillboards/edge-sdk 0.2.61 → 0.2.64

package/dist/connectorCadence.js

@@ -45,11 +45,13 @@
  *             of 493 analyses/hour for the WHOLE connector, however many
  *             cameras it runs.
  *             STALE — see the block under MEASURED_LOCAL_ANALYZE_MS. The same
- *             harness measures 1.90 s (and 1.22 s with the 2026-08-19
- *             config.json change) on the pinned 0.16.0, so the real ceiling on
- *             this machine class is ~1,895/hour and ~2,951/hour respectively.
- *             The constant is kept as a conservative FLEET default because the
- *             fleet varies ~7x; do not quote 493 as this machine's ceiling.
+ *             harness measures 1.90 s, then 1.22 s with the 2026-08-19
+ *             config.json change, then a further paired 2.42x with the 2026-08-19
+ *             fast-conversation shim, on the pinned 0.16.0 — so the real ceiling
+ *             on this machine class is ~1,895/hour, ~2,951/hour and higher again
+ *             respectively. The constant is kept as a conservative FLEET default
+ *             because the fleet varies ~7x; do not quote 493 as this machine's
+ *             ceiling.
  *             (The DOOH audience schema measured 12.48 s median and ranged to
  *             23.8 s because it emits a free-text narrative. The SOP field set
  *             is both cheaper and far tighter — 6.0-7.5 s — which is a second,
@@ -113,9 +115,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
@@ -147,25 +150,81 @@ exports.MEASURED_LOCAL_ANALYZE_MS = 7300;
  * the box can afford, which costs hazard-persistence resolution against the
  * 111 s constructive-notice bracket — the one thing this file exists to protect.
  *
- * ── Why it is NOT simply lowered here ──────────────────────────────────────
- *
- * Because this is ONE constant for a fleet that varies ~7x, and every number
- * above is one desk. `cctv-local-inference-hardware-floor.md` §7 measures
- * 34.78 s/frame on the `windows-latest` class. Replacing 7.30 s with 1.22 s (the
- * M4 Max WITH the 2026-08-19 config.json change) would demand ~28x what that box
- * can deliver, and replacing it with the slow box's number makes every heartbeat
- * worse than today. A single global constant cannot be right for both, and
- * picking the fast desk is exactly the error `.claude/lessons/2026-08-18-a-
- * benchmark-with-no-machine-axis-is-a-spec-for-one-desk.md` was written about.
- *
- * The fix is to DERIVE this per machine — the connector already measures its own
- * frame cost, and `deployedCadence` already exists to reconcile a deployed
- * cadence with what a machine can afford. Until that lands, treat 7.30 s as a
- * deliberately conservative fleet default and NOT as a measurement of any
- * machine: quoting it as one is what this block exists to stop. Changing the
- * value also moves `sensingCatchRate.DEFAULT_SAMPLER.analyzeS`, so it requires
- * re-running `replay-catch-rate.mjs` and regenerating
- * `.github/contracts/sensing-catch-rate-baseline.json` in the same change.
+ * ── AND IT MOVED AGAIN, 2026-08-19 (the shim) ──────────────────────────────
+ *
+ * `litert-lm serve` built `ConstrainedDecodingConfig(enable=True, …)` for every
+ * request even when nothing asked for a `response_format`, so every frame paid
+ * a constraint build for a grammar nothing used. Removing it (see
+ * `deploy/litertlm/trillboards_litertlm_shim.py`) is worth a further **paired
+ * 2.42x** on the shipped path — two stock serves on two ports, interleaved,
+ * n=16, 16/16 schema-valid and 16/16 BYTE-IDENTICAL generations on both arms.
+ * `bench-local-vlm.mjs --arms gpu-sop`, back to back in the same window, moves
+ * **1.32 -> 0.72 s/frame, i.e. 2,727 -> 5,000 analyses/hour**, at load 22-25
+ * where the same harness measures the stock arm at 1.32 s against the 1.22 s
+ * this file already records for it — so that window is close to the regime the
+ * 1.22 s was taken in, and 0.72 s is the nearest thing to a quotable per-frame
+ * number this machine class has.
+ *
+ * TWO CAVEATS THAT TRAVEL WITH IT. The ratio is itself load-dependent — 3.734x
+ * at 0.0% CPU idle against 2.42x at load 25 — because the removed work is
+ * CPU-bound and the retained work is GPU-bound, so a figure taken under
+ * contention flatters the change. And 0.72 s/frame is still BELOW the capacity
+ * target: 4 cameras resolving a 2 s bracket needs 0.5 s/frame (7,200
+ * analyses/hour), and this serves 2-3.
+ *
+ * ── IT IS NOT LOWERED HERE. IT IS NOW A BOOTSTRAP. (2026-08-19) ───────────
+ *
+ * This is ONE constant for a fleet whose measured spread on the SHIPPED path is
+ * 0.50 s/frame (M4 Max, post-#12567/#12594) against tens of seconds on a
+ * GPU-less x86 box. No constant is right for both: the fast desk's number would
+ * demand ~70x what the slow box can deliver, and the slow box's number makes
+ * every heartbeat worse than today. Picking the fast desk is exactly the error
+ * `.claude/lessons/2026-08-18-a-benchmark-with-no-machine-axis-is-a-spec-for-
+ * one-desk.md` was written about.
+ *
+ * So the fix was never a better constant, and as of 2026-08-19 it is built: the
+ * box DERIVES this for itself. `AnalyzeCostObserver` (analyzeCostObserver.ts)
+ * times every successful `analyze()` in `LocalSensingClient`, reports a rolling
+ * median over 16 frames, and `periodicIntervalMsForFeedCount` /
+ * `resolveDeployedCadence` take it as an optional input. A connector that has
+ * measured itself uses its OWN number; one that has not uses this one.
+ *
+ * NOTE WHAT THAT MAKES THIS CONSTANT. It is the value to assume BEFORE a machine
+ * has measured itself, so it should be conservative rather than accurate — and
+ * 7.30 s is exactly that. Guessing FAST on a slow box oversubscribes the single
+ * admission slot from the first minute; guessing slow costs only heartbeat
+ * resolution, and only until the observer settles (8 frames). It is therefore
+ * deliberately NOT lowered, and quoting it as a measurement of any machine is
+ * still what this block exists to stop.
+ *
+ * A CONSEQUENCE WORTH KNOWING: because this value does not move, neither does
+ * `sensingCatchRate.DEFAULT_SAMPLER.analyzeS`, so none of this required a
+ * corpus replay or a `.github/contracts/sensing-catch-rate-baseline.json`
+ * regeneration. If you ever DO move it, all of that becomes mandatory in the
+ * same change — and the catch-rate ratchet is shrink-only, so a baseline may
+ * never be regenerated merely to clear red.
+ *
+ * ── The idle-box objection, and why it does not block the derivation ────────
+ *
+ * The 2026-08-19 predecessor of this block held the per-machine derivation back
+ * for want of a per-frame number taken on an idle box, on the grounds that a
+ * figure measured at 0.0% CPU idle would hardcode one session's contention into
+ * every connector. That objection is answered twice over.
+ *
+ * First, it no longer applies to the DERIVATION at all: nothing global is
+ * derived from a measured number any more. Each box measures itself, in situ,
+ * under whatever load it actually runs at — which is the right load by
+ * definition, and is the one thing a bench on someone else's desk can never
+ * reproduce.
+ *
+ * Second, the verdict turned out not to depend on it. Three measurements of the
+ * shipped arm on one M4 Max across a 3x load range: 0.45 s at load 7.77, 0.50 s
+ * at load 11.87, 0.72 s at load 22-25. All three clear the 13.88 s/frame budget
+ * for 4 cameras by 19-31x, so "this class clears 4 cameras" is invariant across
+ * everything that could be measured. Load moves the quotable figure, not the
+ * verdict — and the post-merge path is markedly LESS load-sensitive than the one
+ * that motivated the objection, because the work #12594 removed was CPU-bound
+ * and what remains is GPU-bound.
  */
 /**
  * Share of the single admission slot the STILL-scene heartbeat floor may take.
@@ -219,8 +278,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
@@ -253,6 +317,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
@@ -302,32 +435,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;
 /**
@@ -340,11 +500,28 @@ exports.DOOH_PERIODIC_MS = 300000;
  * Returns `null` when the count is not a positive integer, so a caller can omit
  * the key entirely rather than write a cadence derived from a bad count.
  */
-function periodicIntervalMsForFeedCount(feedCount) {
+function periodicIntervalMsForFeedCount(feedCount, 
+/**
+ * What a frame ACTUALLY costs on this box, in ms, when this box has measured
+ * itself (`AnalyzeCostObserver.medianMs()`). Omitted or `null` falls back to
+ * `MEASURED_LOCAL_ANALYZE_MS`, which is the BOOTSTRAP — deliberately
+ * conservative, and not a measurement of any machine.
+ *
+ * This parameter is the whole reason a fleet spanning 0.45 s/frame to tens of
+ * seconds can share one code path: the equation was always per-machine, and
+ * until 2026-08-19 only its input was global.
+ */
+analyzeMs) {
     const n = Number(feedCount);
     if (!Number.isFinite(n) || n < 1)
         return null;
-    const required = Math.ceil((Math.trunc(n) * exports.MEASURED_LOCAL_ANALYZE_MS) / exports.STILL_FLOOR_SLOT_SHARE);
+    const measured = Number(analyzeMs);
+    // A non-positive or non-finite measurement is not a fast box, it is a broken
+    // reading — fall back rather than derive a cadence from it.
+    const perFrameMs = Number.isFinite(measured) && measured > 0
+        ? measured
+        : exports.MEASURED_LOCAL_ANALYZE_MS;
+    const required = Math.ceil((Math.trunc(n) * perFrameMs) / exports.STILL_FLOOR_SLOT_SHARE);
     // MEASURED 2026-08-18, and left as it is ON PURPOSE — see below.
     //
     // The `DOOH_PERIODIC_MS` cap stops honouring `STILL_FLOOR_SLOT_SHARE` past
@@ -371,32 +548,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/deployedCadence.d.ts

@@ -29,8 +29,9 @@
  * 493 analyses/hour however many cameras it runs. (The SINGLE SLOT is now a
  * measured fact — two concurrent sessions on one engine make the second return
  * an EMPTY generation, silently; see CloudSensingManager. The 7.30 s is NOT:
- * the shipped path measures 1.90 s on the pinned 0.16.0, and 1.22 s with the
- * 2026-08-19 config.json change. The argument below is unaffected — the profile's
+ * the shipped path measures 1.90 s on the pinned 0.16.0, 1.22 s with the
+ * 2026-08-19 config.json change, and a further paired 2.42x with the 2026-08-19
+ * fast-conversation shim (0.72 s/frame through bench-local-vlm). The argument below is unaffected — the profile's
  * 5-30 s values still oversubscribe by ~4-24x rather than ~23x — but do not
  * quote 493/hour as this machine's ceiling; see MEASURED_LOCAL_ANALYZE_MS.) That ceiling is what
  * `connectorCadence.periodicIntervalMsForFeedCount` already computes, and it is
@@ -144,5 +145,10 @@ export declare function resolveDeployedCadence(input: {
     requestedMs: unknown;
     mode: SensingRunModeName;
     feedCount: number;
+    /**
+     * This machine's own measured per-frame analyze cost in ms, or null/undefined
+     * while it is still on the bootstrap constant. See `AnalyzeCostObserver`.
+     */
+    analyzeMs?: number | null;
 }): 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;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;CACnB,GAAG,eAAe,CAkFlB"}
+{"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"}

package/dist/deployedCadence.js

@@ -30,8 +30,9 @@
  * 493 analyses/hour however many cameras it runs. (The SINGLE SLOT is now a
  * measured fact — two concurrent sessions on one engine make the second return
  * an EMPTY generation, silently; see CloudSensingManager. The 7.30 s is NOT:
- * the shipped path measures 1.90 s on the pinned 0.16.0, and 1.22 s with the
- * 2026-08-19 config.json change. The argument below is unaffected — the profile's
+ * the shipped path measures 1.90 s on the pinned 0.16.0, 1.22 s with the
+ * 2026-08-19 config.json change, and a further paired 2.42x with the 2026-08-19
+ * fast-conversation shim (0.72 s/frame through bench-local-vlm). The argument below is unaffected — the profile's
  * 5-30 s values still oversubscribe by ~4-24x rather than ~23x — but do not
  * quote 493/hour as this machine's ceiling; see MEASURED_LOCAL_ANALYZE_MS.) That ceiling is what
  * `connectorCadence.periodicIntervalMsForFeedCount` already computes, and it is
@@ -115,7 +116,9 @@ function resolveDeployedCadence(input) {
     // measured. periodicIntervalMsForFeedCount returns null on a bad count; a
     // connector with no countable feeds gets the DOOH default rather than a
     // cadence derived from nothing.
-    const floorMs = (0, connectorCadence_1.periodicIntervalMsForFeedCount)(input.feedCount) ?? connectorCadence_1.DOOH_PERIODIC_MS;
+    // `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

package/dist/deployedCadence.js.map

@@ -1 +1 @@
-{"version":3,"file":"deployedCadence.js","sourceRoot":"","sources":["../src/deployedCadence.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;;;AA+FH,wDAsFC;AAnLD,yDAI4B;AAU5B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,cAAc,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAwC/C,8EAA8E;AAC9E,SAAS,gBAAgB,CAAC,KAAc;IACtC,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACvB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CAAC,KAItC;IACC,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IAExD,sEAAsE;IACtE,0EAA0E;IAC1E,wEAAwE;IACxE,gCAAgC;IAChC,MAAM,OAAO,GAAG,IAAA,iDAA8B,EAAC,KAAK,CAAC,SAAS,CAAC,IAAI,mCAAgB,CAAC;IAEpF,8EAA8E;IAC9E,6EAA6E;IAC7E,+EAA+E;IAC/E,+EAA+E;IAC/E,0EAA0E;IAC1E,wDAAwD;IACxD,EAAE;IACF,6EAA6E;IAC7E,6EAA6E;IAC7E,+CAA+C;IAC/C,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,sBAAc,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,0CAAuB,CAAC,CAAC,CAAC;IAE5F,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;QACzB,4EAA4E;QAC5E,6EAA6E;QAC7E,EAAE;QACF,oEAAoE;QACpE,yEAAyE;QACzE,sEAAsE;QACtE,uEAAuE;QACvE,2EAA2E;QAC3E,sEAAsE;QACtE,qBAAqB;QACrB,EAAE;QACF,qCAAqC;QACrC,wEAAwE;QACxE,qEAAqE;QACrE,2EAA2E;QAC3E,oEAAoE;QACpE,oEAAoE;QACpE,yEAAyE;QACzE,4EAA4E;QAC5E,mEAAmE;QACnE,kEAAkE;QAClE,EAAE;QACF,4EAA4E;QAC5E,2EAA2E;QAC3E,wEAAwE;QACxE,uEAAuE;QACvE,2EAA2E;QAC3E,qDAAqD;QACrD,EAAE;QACF,wEAAwE;QACxE,sCAAsC;QACtC,OAAO;YACL,UAAU,EAAE,cAAc;YAC1B,WAAW,EAAE,IAAI;YACjB,OAAO,EAAE,cAAc;YACvB,SAAS,EAAE,sBAAc;YACzB,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,iBAAiB;SAC1B,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,sBAAc,EAAE,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;IACnF,MAAM,OAAO,GAAG,UAAU,KAAK,WAAW,CAAC;IAE3C,IAAI,MAAM,GAAkB,kBAAkB,CAAC;IAC/C,IAAI,UAAU,GAAG,WAAW,EAAE,CAAC;QAC7B,MAAM,GAAG,iBAAiB,CAAC;IAC7B,CAAC;SAAM,IAAI,OAAO,EAAE,CAAC;QACnB,IAAI,cAAc,KAAK,0CAAuB,IAAI,OAAO,IAAI,0CAAuB;YAAE,MAAM,GAAG,eAAe,CAAC;;YAC1G,MAAM,GAAG,wBAAwB,CAAC;IACzC,CAAC;IAED,OAAO;QACL,UAAU;QACV,WAAW;QACX,OAAO,EAAE,cAAc;QACvB,SAAS,EAAE,sBAAc;QACzB,OAAO;QACP,MAAM;KACP,CAAC;AACJ,CAAC"}
+{"version":3,"file":"deployedCadence.js","sourceRoot":"","sources":["../src/deployedCadence.ts"],"names":[],"mappings":"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"}

package/dist/deployedCadenceSource.d.ts

@@ -36,6 +36,16 @@ export interface DeployedCadenceSourceOptions {
     mode: SensingRunModeName;
     /** Total feeds this connector runs (drives the LOCAL single-slot floor). */
     feedCount: number;
+    /**
+     * This machine's own per-frame analyze cost, read AT RESOLVE TIME.
+     *
+     * A getter and not a number on purpose: the observer settles minutes after the
+     * connector starts and then keeps rolling, so a value captured at construction
+     * would pin every future cadence to the cold-start estimate — the one reading
+     * we specifically know is high. Omitted leaves the conservative bootstrap
+     * constant governing, which is exactly today's behaviour.
+     */
+    observedAnalyzeMs?: () => number | null;
 }
 /**
  * Build the connector's cadence source. Returns `undefined` when there are no

package/dist/deployedCadenceSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deployedCadenceSource.d.ts","sourceRoot":"","sources":["../src/deployedCadenceSource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,4BAA4B;IAC3C,kFAAkF;IAClF,cAAc,EAAE,oBAAoB,EAAE,CAAC;IACvC,IAAI,EAAE,kBAAkB,CAAC;IACzB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,4BAA4B,GACpC,aAAa,GAAG,SAAS,CAkC3B"}
+{"version":3,"file":"deployedCadenceSource.d.ts","sourceRoot":"","sources":["../src/deployedCadenceSource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,4BAA4B;IAC3C,kFAAkF;IAClF,cAAc,EAAE,oBAAoB,EAAE,CAAC;IACvC,IAAI,EAAE,kBAAkB,CAAC;IACzB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACzC;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,4BAA4B,GACpC,aAAa,GAAG,SAAS,CA6C3B"}

package/dist/deployedCadenceSource.js

@@ -62,10 +62,21 @@ function buildDeployedCadenceSource(options) {
             // running cadence, and returning null is how the manager is told so.
             if (!anyAnswered)
                 return null;
+            // Read the machine's own cost NOW, not at construction. A throwing getter
+            // must not take the cadence down with it: an unmeasured box is a box on
+            // the bootstrap, which is the state it was in a moment ago anyway.
+            let analyzeMs = null;
+            try {
+                analyzeMs = options.observedAnalyzeMs ? options.observedAnalyzeMs() : null;
+            }
+            catch {
+                analyzeMs = null;
+            }
             return (0, deployedCadence_1.resolveDeployedCadence)({
                 requestedMs: fastest,
                 mode: options.mode,
                 feedCount: options.feedCount,
+                analyzeMs,
             });
         },
     };

package/dist/deployedCadenceSource.js.map

@@ -1 +1 @@
-{"version":3,"file":"deployedCadenceSource.js","sourceRoot":"","sources":["../src/deployedCadenceSource.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;AAuBH,gEAoCC;AAvDD,uDAI2B;AAU3B;;;;GAIG;AACH,SAAgB,0BAA0B,CACxC,OAAqC;IAErC,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC/D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAE3C,OAAO;QACL,KAAK,CAAC,OAAO;YACX,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CACvD,CAAC;YAEF,qEAAqE;YACrE,gDAAgD;YAChD,IAAI,OAAO,GAAkB,IAAI,CAAC;YAClC,IAAI,WAAW,GAAG,KAAK,CAAC;YACxB,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE,CAAC;gBAC9B,IAAI,CAAC,OAAO;oBAAE,SAAS;gBACvB,WAAW,GAAG,IAAI,CAAC;gBACnB,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC;gBACrC,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;oBAAE,SAAS;gBACxE,IAAI,OAAO,KAAK,IAAI,IAAI,EAAE,GAAG,OAAO;oBAAE,OAAO,GAAG,EAAE,CAAC;YACrD,CAAC;YAED,uEAAuE;YACvE,wEAAwE;YACxE,qEAAqE;YACrE,IAAI,CAAC,WAAW;gBAAE,OAAO,IAAI,CAAC;YAE9B,OAAO,IAAA,wCAAsB,EAAC;gBAC5B,WAAW,EAAE,OAAO;gBACpB,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,SAAS,EAAE,OAAO,CAAC,SAAS;aAC7B,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"deployedCadenceSource.js","sourceRoot":"","sources":["../src/deployedCadenceSource.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;AAiCH,gEA+CC;AA5ED,uDAI2B;AAoB3B;;;;GAIG;AACH,SAAgB,0BAA0B,CACxC,OAAqC;IAErC,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC/D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAE3C,OAAO;QACL,KAAK,CAAC,OAAO;YACX,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CACvD,CAAC;YAEF,qEAAqE;YACrE,gDAAgD;YAChD,IAAI,OAAO,GAAkB,IAAI,CAAC;YAClC,IAAI,WAAW,GAAG,KAAK,CAAC;YACxB,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE,CAAC;gBAC9B,IAAI,CAAC,OAAO;oBAAE,SAAS;gBACvB,WAAW,GAAG,IAAI,CAAC;gBACnB,MAAM,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC;gBACrC,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;oBAAE,SAAS;gBACxE,IAAI,OAAO,KAAK,IAAI,IAAI,EAAE,GAAG,OAAO;oBAAE,OAAO,GAAG,EAAE,CAAC;YACrD,CAAC;YAED,uEAAuE;YACvE,wEAAwE;YACxE,qEAAqE;YACrE,IAAI,CAAC,WAAW;gBAAE,OAAO,IAAI,CAAC;YAE9B,0EAA0E;YAC1E,wEAAwE;YACxE,mEAAmE;YACnE,IAAI,SAAS,GAAkB,IAAI,CAAC;YACpC,IAAI,CAAC;gBACH,SAAS,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAC7E,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS,GAAG,IAAI,CAAC;YACnB,CAAC;YAED,OAAO,IAAA,wCAAsB,EAAC;gBAC5B,WAAW,EAAE,OAAO;gBACpB,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,SAAS;aACV,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/diagnose.d.ts

@@ -31,7 +31,7 @@ export interface DiagnosticReport {
         skipped: number;
     };
 }
-declare const SDK_VERSION = "0.2.61";
+declare const SDK_VERSION = "0.2.64";
 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.61';
+const SDK_VERSION = '0.2.64';
 exports._SDK_VERSION = SDK_VERSION;
 // ---------------------------------------------------------------------------
 // ANSI helpers (no external deps)