@camstack/addon-benchmark 1.2.33 → 1.2.35

package/dist/index.mjs

@@ -15661,10 +15661,18 @@ async function orchestrateReplayRun(deps, input) {
       meta: { maxFrames: input.maxFrames, planned: framePlan.instants.length }
     });
   }
-  const sourceBytes = await deps.fetchSourceBytes(input.source);
+  const sourceFetch = await deps.fetchSourceBytes(input.source);
+  if (sourceFetch.kind === "refused") {
+    deps.logger.warn("replay: run refused \u2014 could not fetch source bytes", {
+      tags,
+      meta: { reason: sourceFetch.reason }
+    });
+    return { kind: "refused", reason: sourceFetch.reason };
+  }
+  const sourceBytes = sourceFetch.bytes;
   const first = framePlan.instants[0] ?? 0;
   const last = framePlan.instants[framePlan.instants.length - 1] ?? first;
-  const startSec = input.source.kind === "recording" ? (first - input.source.fromMs) / 1e3 : first / 1e3;
+  const startSec = (first - sourceFetch.startMs) / 1e3;
   const durationSec = Math.max(1 / input.fps, (last - first) / 1e3 + 1 / input.fps);
   const args = buildReplaySequenceArgs({
     startSec,
@@ -16172,27 +16180,98 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
       });
     return result;
   }
+  /**
+   * The profile a replay window is read from. `high` — same choice
+   * `RECORDED_STILL_PROFILE` makes in `addon-post-analysis` — because the
+   * whole point of `recording` over `upload` is NATIVE pixels (`-c:v copy`
+   * means the recorded frame IS the live frame); a window cut from a
+   * lower-rate rendition would be a worse version of the thing this source
+   * exists to avoid.
+   */
+  static REPLAY_RECORDING_PROFILE = "high";
   /**
    * Byte source for the replay decode step.
    *
-   * `upload` is fully wired: `storage.read` against the `replayClips`
-   * location. `recording` is NOT — it needs a recorder-side read port
-   * spanning a time WINDOW (locate + multi-GOP read, the plan's own
-   * comparison is `RecordedStillPorts`, which reads exactly ONE instant).
-   * Whether device 615's footage even covers 2026-08-26 18:12 was never
-   * verified against the live hub — the plan's Unknown #2. Reporting that
-   * clearly here beats guessing at a port shape nobody has confirmed.
+   * `upload` is `storage.read` against the `replayClips` location. `recording`
+   * is `recording.getDeviceConfig` → `recording.locateSegment` →
+   * `recording.readWindowBytes` — the same "cheap question first" ordering
+   * `RecordedStillService` uses (a camera that is not recording costs a
+   * settings read, never a disk read), through `ctx.api` because addons never
+   * import each other.
+   *
+   * Every expected failure — not recording, no footage covering `fromMs`, a
+   * window that runs past its covering segment — returns a NAMED `refused`,
+   * never a thrown error: "the window has no segments" is a RESULT this
+   * whole feature exists to make legible (see the plan's stated unknown about
+   * whether device 615's footage covers 2026-08-26 18:12), not a failure to
+   * hide behind a generic exception.
    */
   async fetchReplaySourceBytes(source) {
     if (source.kind === "upload") {
-      return this.api.storage.read.query({
-        location: _BenchmarkAddon.REPLAY_CLIPS_LOCATION,
-        relativePath: `${source.clipId}.bin`
+      try {
+        const bytes = await this.api.storage.read.query({
+          location: _BenchmarkAddon.REPLAY_CLIPS_LOCATION,
+          relativePath: `${source.clipId}.bin`
+        });
+        return { kind: "ok", bytes, startMs: 0 };
+      } catch (err) {
+        return { kind: "refused", reason: `clip-not-found: ${errMsg(err)}` };
+      }
+    }
+    const profile = _BenchmarkAddon.REPLAY_RECORDING_PROFILE;
+    const tags = { deviceId: source.deviceId };
+    const config2 = await this.api.recording.getDeviceConfig.query({ deviceId: source.deviceId });
+    if (config2.enabled === false) {
+      this.ctx.logger.warn("replay: recording source refused \u2014 camera is not recording", {
+        tags
       });
+      return {
+        kind: "refused",
+        reason: `no-recording: device ${source.deviceId} does not have recording enabled`
+      };
     }
-    throw new Error(
-      "replay: 'recording' source is not wired \u2014 needs a recorder read port spanning a time window (locate + multi-GOP read), and whether this camera\u2019s footage covers the requested window was never verified against the live hub. Use an uploaded clip today."
-    );
+    const located = await this.api.recording.locateSegment.query({
+      deviceId: source.deviceId,
+      profile,
+      epochMs: source.fromMs
+    });
+    if (located.kind !== "segment") {
+      this.ctx.logger.warn(
+        "replay: recording source refused \u2014 no footage covers the window start",
+        { tags, meta: { fromMs: source.fromMs, toMs: source.toMs, profile } }
+      );
+      return {
+        kind: "refused",
+        reason: `no-footage: device ${source.deviceId} has no ${profile} recording covering ${new Date(source.fromMs).toISOString()}`
+      };
+    }
+    const window = await this.api.recording.readWindowBytes.query({
+      deviceId: source.deviceId,
+      profile,
+      startMs: located.startMs,
+      fromMs: source.fromMs,
+      toMs: source.toMs
+    });
+    if (window.kind !== "ok") {
+      this.ctx.logger.warn(
+        "replay: recording source refused \u2014 window runs past the covering segment",
+        {
+          tags,
+          meta: { fromMs: source.fromMs, toMs: source.toMs, segmentEndMs: window.segmentEndMs }
+        }
+      );
+      return {
+        kind: "refused",
+        reason: `window-spans-multiple-segments: footage for device ${source.deviceId} changes segment at ${window.segmentEndMs}, before the requested end ${source.toMs} \u2014 shorten the window or align it to one segment`
+      };
+    }
+    if (!window.reachesRequestedEnd) {
+      this.ctx.logger.warn(
+        "replay: recording window bytes truncated by the recorder read safety cap",
+        { tags, meta: { fromMs: source.fromMs, toMs: source.toMs, gopDurMs: window.gopDurMs } }
+      );
+    }
+    return { kind: "ok", bytes: window.data, startMs: window.gopStartMs };
   }
   async listReplayRuns(input) {
     if (this.replayStore === null) return [];