@camstack/addon-benchmark 1.2.149 → 1.2.151

package/dist/index.mjs

@@ -5,10 +5,14 @@ var __export = (target, all) => {
 };
 
 // src/benchmark-addon.ts
-import * as fs2 from "fs";
-import { fileURLToPath } from "url";
-import * as path2 from "path";
-import { BaseAddon, addonPagesSourceCapability, parseJsonUnknown, errMsg } from "@camstack/types";
+import {
+  BackgroundRunRegistry,
+  BaseAddon,
+  addonPagesSourceCapability,
+  errMsg,
+  nodePin,
+  parseJsonUnknown
+} from "@camstack/types";
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -776,10 +780,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path) {
+  if (!path)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1188,11 +1192,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path);
     return iss;
   });
 }
@@ -1339,16 +1343,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path3 = []) => {
+  const processError = (error52, path = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1375,17 +1379,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path3 = []) => {
+  const processError = (error52, path = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path, ...issue2.path]);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1417,8 +1421,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -11500,42 +11504,42 @@ function extractDefs(ctx, schema) {
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const idToSchema = /* @__PURE__ */ new Map();
-  for (const entry of ctx.seen.entries()) {
-    const id = ctx.metadataRegistry.get(entry[0])?.id;
+  for (const entry2 of ctx.seen.entries()) {
+    const id = ctx.metadataRegistry.get(entry2[0])?.id;
     if (id) {
       const existing = idToSchema.get(id);
-      if (existing && existing !== entry[0]) {
+      if (existing && existing !== entry2[0]) {
         throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
       }
-      idToSchema.set(id, entry[0]);
+      idToSchema.set(id, entry2[0]);
     }
   }
-  const makeURI = (entry) => {
+  const makeURI = (entry2) => {
     const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
     if (ctx.external) {
-      const externalId = ctx.external.registry.get(entry[0])?.id;
+      const externalId = ctx.external.registry.get(entry2[0])?.id;
       const uriGenerator = ctx.external.uri ?? ((id2) => id2);
       if (externalId) {
         return { ref: uriGenerator(externalId) };
       }
-      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
-      entry[1].defId = id;
+      const id = entry2[1].defId ?? entry2[1].schema.id ?? `schema${ctx.counter++}`;
+      entry2[1].defId = id;
       return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
     }
-    if (entry[1] === root) {
+    if (entry2[1] === root) {
       return { ref: "#" };
     }
     const uriPrefix = `#`;
     const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
-    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
+    const defId = entry2[1].schema.id ?? `__schema${ctx.counter++}`;
     return { defId, ref: defUriPrefix + defId };
   };
-  const extractToDef = (entry) => {
-    if (entry[1].schema.$ref) {
+  const extractToDef = (entry2) => {
+    if (entry2[1].schema.$ref) {
       return;
     }
-    const seen = entry[1];
-    const { ref, defId } = makeURI(entry);
+    const seen = entry2[1];
+    const { ref, defId } = makeURI(entry2);
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
@@ -11546,8 +11550,8 @@ function extractDefs(ctx, schema) {
     schema2.$ref = ref;
   };
   if (ctx.cycles === "throw") {
-    for (const entry of ctx.seen.entries()) {
-      const seen = entry[1];
+    for (const entry2 of ctx.seen.entries()) {
+      const seen = entry2[1];
       if (seen.cycle) {
         throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
 
@@ -11555,31 +11559,31 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
   }
-  for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
-    if (schema === entry[0]) {
-      extractToDef(entry);
+  for (const entry2 of ctx.seen.entries()) {
+    const seen = entry2[1];
+    if (schema === entry2[0]) {
+      extractToDef(entry2);
       continue;
     }
     if (ctx.external) {
-      const ext = ctx.external.registry.get(entry[0])?.id;
-      if (schema !== entry[0] && ext) {
-        extractToDef(entry);
+      const ext = ctx.external.registry.get(entry2[0])?.id;
+      if (schema !== entry2[0] && ext) {
+        extractToDef(entry2);
         continue;
       }
     }
-    const id = ctx.metadataRegistry.get(entry[0])?.id;
+    const id = ctx.metadataRegistry.get(entry2[0])?.id;
     if (id) {
-      extractToDef(entry);
+      extractToDef(entry2);
       continue;
     }
     if (seen.cycle) {
-      extractToDef(entry);
+      extractToDef(entry2);
       continue;
     }
     if (seen.count > 1) {
       if (ctx.reused === "ref") {
-        extractToDef(entry);
+        extractToDef(entry2);
         continue;
       }
     }
@@ -11651,8 +11655,8 @@ function finalize(ctx, schema) {
       path: seen.path ?? []
     });
   };
-  for (const entry of [...ctx.seen.entries()].reverse()) {
-    flattenRef(entry[0]);
+  for (const entry2 of [...ctx.seen.entries()].reverse()) {
+    flattenRef(entry2[0]);
   }
   const result = {};
   if (ctx.target === "draft-2020-12") {
@@ -11675,8 +11679,8 @@ function finalize(ctx, schema) {
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
-  for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
+  for (const entry2 of ctx.seen.entries()) {
+    const seen = entry2[1];
     if (seen.def && seen.defId) {
       if (seen.def.id === seen.defId)
         delete seen.def.id;
@@ -12292,8 +12296,8 @@ function toJSONSchema(input, params) {
     const registry2 = input;
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
-    for (const entry of registry2._idmap.entries()) {
-      const [_, schema] = entry;
+    for (const entry2 of registry2._idmap.entries()) {
+      const [_, schema] = entry2;
       process2(schema, ctx2);
     }
     const schemas = {};
@@ -12303,8 +12307,8 @@ function toJSONSchema(input, params) {
       defs
     };
     ctx2.external = external;
-    for (const entry of registry2._idmap.entries()) {
-      const [key, schema] = entry;
+    for (const entry2 of registry2._idmap.entries()) {
+      const [key, schema] = entry2;
       extractDefs(ctx2, schema);
       schemas[key] = finalize(ctx2, schema);
     }
@@ -14110,13 +14114,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path3 = ref.slice(1).split("/").filter(Boolean);
-  if (path3.length === 0) {
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path3[0] === defsKey) {
-    const key = path3[1];
+  if (path[0] === defsKey) {
+    const key = path[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14528,14 +14532,159 @@ config(en_default());
 import { customAction, defineCustomActions, PipelineRunResultBridge } from "@camstack/types";
 
 // src/benchmark-schemas.ts
-import { HWACCEL_OPTIONS, PipelineStepInputSchema } from "@camstack/types";
-var PipelineBenchmarkHistoryEntrySchema = external_exports.object({
-  kind: external_exports.literal("pipeline").default("pipeline"),
-  id: external_exports.string(),
-  date: external_exports.string(),
+import { PipelineStepInputSchema as PipelineStepInputSchema2 } from "@camstack/types";
+
+// src/session-replay/schemas.ts
+import { PipelineStepInputSchema } from "@camstack/types";
+var NormBoxSchema = external_exports.object({
+  x: external_exports.number(),
+  y: external_exports.number(),
+  w: external_exports.number(),
+  h: external_exports.number()
+});
+var ReplayBoxSchema = external_exports.object({
+  className: external_exports.string(),
+  score: external_exports.number(),
+  box: NormBoxSchema
+});
+var StoredPositionSchema = external_exports.object({
+  trackId: external_exports.string(),
+  className: external_exports.string(),
+  t: external_exports.number(),
+  box: NormBoxSchema,
+  score: external_exports.number().nullable()
+});
+var ReferenceBasisSchema = external_exports.enum(["exact", "interpolated", "uncertain"]);
+var ReferenceEntrySchema = StoredPositionSchema.extend({ basis: ReferenceBasisSchema });
+var TimelineReplayBoxSchema = ReplayBoxSchema.extend({
+  /** `unreferenced`: no stored track was alive at this instant — nothing to contradict. */
+  outcome: external_exports.enum(["matched", "class-changed", "added", "unreferenced"])
+});
+var TimelineStoredBoxSchema = ReferenceEntrySchema.extend({
+  outcome: external_exports.enum(["matched", "class-changed", "missed"])
+});
+var TimelineFrameSchema = external_exports.object({
+  t: external_exports.number(),
+  /** Some stored track was alive at `t` — the instant HAS a reference. */
+  referenced: external_exports.boolean(),
+  replay: external_exports.array(TimelineReplayBoxSchema).readonly(),
+  stored: external_exports.array(TimelineStoredBoxSchema).readonly(),
+  inferenceMs: external_exports.number().nullable()
+});
+var ClassCountsSchema = external_exports.object({
+  replay: external_exports.number(),
+  stored: external_exports.number(),
+  matched: external_exports.number(),
+  added: external_exports.number(),
+  missed: external_exports.number(),
+  unreferenced: external_exports.number(),
+  /** Comparisons (matched / class-changed / missed) made on a non-exact stored box. */
+  interpolated: external_exports.number()
+});
+var ReplaySummarySchema = external_exports.object({
+  totals: external_exports.object({
+    matched: external_exports.number(),
+    classChanged: external_exports.number(),
+    added: external_exports.number(),
+    missed: external_exports.number(),
+    unreferenced: external_exports.number(),
+    interpolated: external_exports.number()
+  }),
+  perClass: external_exports.record(external_exports.string(), ClassCountsSchema),
+  scoreDelta: external_exports.object({ mean: external_exports.number(), p10: external_exports.number(), p50: external_exports.number(), p90: external_exports.number() }).nullable(),
+  inferenceMs: external_exports.object({ p50: external_exports.number(), p95: external_exports.number(), count: external_exports.number() }).nullable()
+});
+var CadenceSourceSchema = external_exports.enum(["operator", "stored-positions", "default"]);
+var ReplayCadenceSchema = external_exports.object({ fps: external_exports.number(), source: CadenceSourceSchema });
+var SessionReplayReportSchema = external_exports.object({
+  deviceId: external_exports.number(),
+  motionEventId: external_exports.number(),
+  window: external_exports.object({
+    startMs: external_exports.number(),
+    endMs: external_exports.number(),
+    motionStartMs: external_exports.number(),
+    motionEndMs: external_exports.number(),
+    /** Where the pre-roll / tail came from: the camera's own settings, or the fleet default. */
+    prerollSource: external_exports.enum(["camera", "default"]),
+    tailSource: external_exports.enum(["camera", "default"])
+  }),
+  pin: external_exports.object({
+    nodeId: external_exports.string(),
+    deviceKey: external_exports.string().nullable(),
+    modelId: external_exports.string(),
+    cameraModelId: external_exports.string().nullable()
+  }),
+  rootStep: PipelineStepInputSchema,
+  cadence: ReplayCadenceSchema,
+  frameSize: external_exports.object({ width: external_exports.number(), source: external_exports.enum(["stored-tracks", "default"]) }),
+  frames: external_exports.object({
+    planned: external_exports.number(),
+    decoded: external_exports.number(),
+    ran: external_exports.number(),
+    failed: external_exports.number(),
+    withoutFootage: external_exports.number(),
+    notDecoded: external_exports.number(),
+    truncated: external_exports.boolean(),
+    truncatedBySafetyCap: external_exports.boolean(),
+    aborted: external_exports.boolean()
+  }),
+  reference: external_exports.object({
+    tracks: external_exports.number(),
+    positionsCompared: external_exports.number(),
+    recoveryExcluded: external_exports.number(),
+    withoutGeometry: external_exports.number(),
+    models: external_exports.record(external_exports.string(), external_exports.number()),
+    /** The stored-track read: how many came back, and whether its limit cut it short. */
+    read: external_exports.object({ tracks: external_exports.number(), truncated: external_exports.boolean() })
+  }),
+  confirmation: external_exports.object({
+    liveVerdicts: external_exports.record(external_exports.string(), external_exports.number()),
+    /** Added or unreferenced detections near a live SUPPRESSED birth of their class. */
+    nearSuppressedBirth: external_exports.number()
+  }),
+  summary: ReplaySummarySchema,
+  timeline: external_exports.array(TimelineFrameSchema).readonly(),
+  failures: external_exports.array(external_exports.object({ t: external_exports.number(), error: external_exports.string() })).readonly()
+});
+var SessionReplayRefusalSchema = external_exports.enum([
+  "session-not-found",
+  "session-open",
+  "window-too-long",
+  "no-root-step",
+  "model-unpinned",
+  "model-not-servable",
+  "device-not-servable",
+  "no-recording",
+  "no-footage",
+  "session-length-unknown",
+  "pool-failing"
+]);
+var SessionReplayOutcomeSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("refused"),
+    reason: SessionReplayRefusalSchema,
+    detail: external_exports.string()
+  }),
+  external_exports.object({ kind: external_exports.literal("ran"), report: SessionReplayReportSchema })
+]);
+var SessionReplayProgressSchema = external_exports.object({
+  phase: external_exports.enum(["preparing", "replaying", "done"]),
+  framesPlanned: external_exports.number(),
+  framesDone: external_exports.number()
+});
+
+// src/benchmark-schemas.ts
+var BenchModeSchema = external_exports.enum(["inference", "full-tree", "live-frame"]);
+var BenchPoolTuningSchema = external_exports.object({
+  runtime: external_exports.string().nullable(),
+  numWorkers: external_exports.number().nullable(),
+  concurrency: external_exports.number().nullable(),
+  batchMode: external_exports.string().nullable(),
+  maxBatchSize: external_exports.number().nullable()
+});
+var HistoryMeasurementFields = {
   stepId: external_exports.string(),
   modelId: external_exports.string(),
-  runtime: external_exports.string(),
   iterations: external_exports.number(),
   warmup: external_exports.number(),
   fps: external_exports.number(),
@@ -14544,377 +14693,163 @@ var PipelineBenchmarkHistoryEntrySchema = external_exports.object({
   p95Ms: external_exports.number(),
   p99Ms: external_exports.number(),
   /**
-   * OPTIONAL, and absent on every entry the page writes.
-   * `pipeline-runner.runSyntheticBench` reports mean / p50 / p95 / p99 and
-   * measures no per-call min or max. They were required here while nothing
-   * in the page ever called `saveBenchmarkResult`, so nothing noticed; the
-   * moment it does, a required field can only be satisfied by inventing a
-   * number, and a fabricated latency in the history table is worse than a
-   * blank one.
+   * OPTIONAL, and absent on every entry the page writes: the runner reports
+   * mean / p50 / p95 / p99 and measures no per-call min or max. A fabricated
+   * latency in the history table is worse than a blank one.
    */
   minMs: external_exports.number().optional(),
   maxMs: external_exports.number().optional(),
   avgDetections: external_exports.number(),
   referenceImage: external_exports.string().optional(),
-  /** Number of concurrent runs aggregated into this entry; 1 = single run. */
+  /** Concurrent in-flight requests (simulated cameras) — NOT pool workers. */
   parallelRuns: external_exports.number().min(1).default(1)
-});
-var PipelineBenchmarkHistoryEntryInputSchema = PipelineBenchmarkHistoryEntrySchema.omit({
-  kind: true,
-  id: true,
-  date: true
-});
-var DecoderFixtureCodecSchema = external_exports.enum(["h264", "h265"]);
-var DecoderFixtureSchema = external_exports.object({
-  filename: external_exports.string(),
-  codec: DecoderFixtureCodecSchema,
-  resolutionLabel: external_exports.string(),
-  // '360p', '1080p', '1440p'
-  sizeBytes: external_exports.number(),
-  description: external_exports.string().optional()
-});
-var CamProfileSchema = external_exports.enum(["high", "mid", "low"]);
-var DecoderPerfSourceSchema = external_exports.discriminatedUnion("kind", [
-  external_exports.object({
-    kind: external_exports.literal("sample"),
-    fixtureFilename: external_exports.string()
-  }),
-  external_exports.object({
-    kind: external_exports.literal("stream"),
-    deviceId: external_exports.number().int().min(1),
-    profile: CamProfileSchema
-  })
-]);
-var DecoderPerfModeSchema = external_exports.discriminatedUnion("kind", [
-  external_exports.object({ kind: external_exports.literal("duration"), durationSec: external_exports.number().min(5).max(1800) }),
-  external_exports.object({ kind: external_exports.literal("iterations"), iterations: external_exports.number().min(10).max(1e6) })
-]);
-var DecoderPerfFormatSchema = external_exports.enum(["jpeg", "gray"]);
-var HWACCEL_VALUES = HWACCEL_OPTIONS.map((o) => o.value);
-var DecoderPerfHwaccelSchema = external_exports.enum(HWACCEL_VALUES);
-var DecoderPerfThresholdsSchema = external_exports.object({
-  warnMBMin: external_exports.number().min(0).default(5),
-  failMBMin: external_exports.number().min(0).default(20)
-});
-var DecoderPerfInputSchema = external_exports.object({
-  sessionId: external_exports.string(),
-  cameras: external_exports.number().int().min(1).max(16),
-  mode: DecoderPerfModeSchema,
-  source: DecoderPerfSourceSchema,
-  format: DecoderPerfFormatSchema,
-  fps: external_exports.number().min(1).max(120),
-  toggleMs: external_exports.number().min(0).default(0),
-  warmupSec: external_exports.number().min(0).default(15),
-  sampleIntervalMs: external_exports.number().min(500).default(2e3),
-  hwaccel: DecoderPerfHwaccelSchema.default("none"),
-  thresholds: DecoderPerfThresholdsSchema.default({ warnMBMin: 5, failMBMin: 20 }),
-  // Pin the decoder sessions to the selected node. createSession is the only
-  // decoder call without a node selector (the rest route via the nodeId that
-  // createSession returns), so without this the whole test runs on the
-  // singleton's elected node (the hub) regardless of the UI selection.
-  nodeId: external_exports.string().optional()
-});
-var DecoderPerfSampleSchema = external_exports.object({
-  tSec: external_exports.number(),
-  rssMB: external_exports.number(),
-  heapMB: external_exports.number(),
-  externalMB: external_exports.number(),
-  arrayBuffersMB: external_exports.number(),
-  cpuPct: external_exports.number(),
-  framesTotal: external_exports.number()
-});
-var DecoderPerfVerdictSchema = external_exports.enum(["pass", "warn", "fail", "aborted", "error"]);
-var DecoderPerfResultSchema = external_exports.object({
-  sessionId: external_exports.string(),
-  verdict: DecoderPerfVerdictSchema,
-  aborted: external_exports.boolean().default(false),
-  errorMessage: external_exports.string().optional(),
-  samples: external_exports.array(DecoderPerfSampleSchema).readonly(),
-  slopes: external_exports.object({
-    rssMBMin: external_exports.number(),
-    heapMBMin: external_exports.number(),
-    externalMBMin: external_exports.number()
-  }),
-  totals: external_exports.object({
-    wallSec: external_exports.number(),
-    framesEmitted: external_exports.number(),
-    fpsPerCamera: external_exports.number(),
-    cpuAvgPct: external_exports.number(),
-    droppedFrames: external_exports.number()
-  }),
-  config: DecoderPerfInputSchema
-});
-var DecoderPerfProgressSchema = external_exports.object({
-  kind: external_exports.literal("decoder-perf"),
-  sessionId: external_exports.string(),
-  phase: external_exports.enum(["init", "warmup", "running", "complete", "aborted", "error"]),
-  tSec: external_exports.number().optional(),
-  sample: DecoderPerfSampleSchema.optional(),
-  message: external_exports.string().optional()
-});
-var DecoderPerfHistoryEntrySchema = external_exports.object({
-  kind: external_exports.literal("decoder-perf"),
+};
+var PipelineBenchmarkHistoryEntrySchema = external_exports.object({
+  kind: external_exports.literal("pipeline").default("pipeline"),
   id: external_exports.string(),
   date: external_exports.string(),
-  sessionId: external_exports.string(),
-  verdict: DecoderPerfVerdictSchema,
-  cameras: external_exports.number(),
-  format: DecoderPerfFormatSchema,
-  sourceLabel: external_exports.string(),
-  // 'sample:camera-sim-360p' | 'stream:dev-2/low'
-  modeLabel: external_exports.string(),
-  // 'duration:60s' | 'iterations:5000'
-  rssSlopeMBMin: external_exports.number(),
-  heapSlopeMBMin: external_exports.number(),
-  externalSlopeMBMin: external_exports.number(),
-  framesEmitted: external_exports.number(),
-  fpsPerCamera: external_exports.number(),
-  cpuAvgPct: external_exports.number(),
-  droppedFrames: external_exports.number(),
-  wallSec: external_exports.number(),
-  hwaccel: DecoderPerfHwaccelSchema
+  ...HistoryMeasurementFields,
+  nodeId: external_exports.string().optional(),
+  deviceKey: external_exports.string().nullable().optional(),
+  plane: external_exports.enum(["full", "frame"]).nullable().optional(),
+  mode: BenchModeSchema.optional(),
+  pool: BenchPoolTuningSchema.optional(),
+  runtime: external_exports.string().optional()
 });
-var DecoderPerfHistoryEntryInputSchema = DecoderPerfHistoryEntrySchema.omit({
-  kind: true,
-  id: true,
-  date: true
+var PipelineBenchmarkHistoryEntryInputSchema = external_exports.object({
+  ...HistoryMeasurementFields,
+  nodeId: external_exports.string(),
+  deviceKey: external_exports.string().nullable(),
+  plane: external_exports.enum(["full", "frame"]).nullable(),
+  mode: BenchModeSchema,
+  pool: BenchPoolTuningSchema
 });
-var HistoryEntrySchema = external_exports.discriminatedUnion("kind", [
-  PipelineBenchmarkHistoryEntrySchema,
-  DecoderPerfHistoryEntrySchema
-]);
+var HistoryEntrySchema = PipelineBenchmarkHistoryEntrySchema;
 var PipelineRunInputSchema = external_exports.object({
-  steps: external_exports.array(PipelineStepInputSchema).readonly(),
+  steps: external_exports.array(PipelineStepInputSchema2).readonly(),
   imageBase64: external_exports.string().optional(),
   referenceImage: external_exports.string().optional(),
-  frameId: external_exports.string().optional(),
-  /**
-   * Target node for the pipeline test. Forwarded to
-   * `pipelineExecutor.runPipeline`. Omit to run on the hub.
-   */
+  /** Target node. Forwarded to `pipelineExecutor.runPipeline`. Omit to run on the hub. */
   nodeId: external_exports.string().optional(),
-  /**
-   * UI-provided correlation id. When set, every `pipeline.progress`
-   * event emitted by the run is tagged with this value so the caller
-   * can filter out concurrent camera-runtime dispatches that share the
-   * same bus category.
-   */
+  /** UI correlation id stamped on every `pipeline.progress` line of the run. */
   sessionId: external_exports.string().optional(),
-  engine: external_exports.object({
-    runtime: external_exports.enum(["python", "node"]),
-    backend: external_exports.string(),
-    format: external_exports.enum(["onnx", "coreml", "openvino", "tflite"]),
-    device: external_exports.string().optional()
-  }).optional(),
   deviceKey: external_exports.string().optional(),
   plane: external_exports.enum(["full", "frame"]).optional()
 });
-var PipelineRunBatchInputSchema = external_exports.object({
-  steps: external_exports.array(PipelineStepInputSchema).readonly(),
-  imageBase64: external_exports.string(),
-  batchSize: external_exports.number().int().min(1).max(255),
-  targetSize: external_exports.number().int().min(64).max(2048).optional(),
-  nodeId: external_exports.string().optional(),
-  sessionId: external_exports.string().optional(),
-  engine: external_exports.object({
-    runtime: external_exports.enum(["python", "node"]),
-    backend: external_exports.string(),
-    format: external_exports.enum(["onnx", "coreml", "openvino", "tflite"]),
-    device: external_exports.string().optional()
-  }).optional()
+var SyntheticBenchPoolSchema = external_exports.object({
+  nodeId: external_exports.string(),
+  deviceKey: external_exports.string().nullable(),
+  runtime: external_exports.string().nullable(),
+  numWorkers: external_exports.number().nullable(),
+  concurrency: external_exports.number().nullable(),
+  batchMode: external_exports.string().nullable(),
+  maxBatchSize: external_exports.number().nullable()
 });
-var PipelineRunBatchResultSchema = external_exports.object({
-  results: external_exports.array(PipelineRunResultBridgeRef()).readonly(),
-  callMs: external_exports.number(),
-  inferMs: external_exports.number()
+var SyntheticBenchStatsSchema = external_exports.object({
+  runs: external_exports.number(),
+  wallSec: external_exports.number(),
+  fps: external_exports.number(),
+  detectionsPerSec: external_exports.number(),
+  avgDetections: external_exports.number(),
+  callMs: external_exports.object({ mean: external_exports.number(), p50: external_exports.number(), p95: external_exports.number(), p99: external_exports.number() }),
+  inferMs: external_exports.number(),
+  preprocessMs: external_exports.number(),
+  predictMs: external_exports.number(),
+  batchSizeMean: external_exports.number(),
+  batchSizeMax: external_exports.number(),
+  pool: SyntheticBenchPoolSchema,
+  path: external_exports.string()
 });
-function PipelineRunResultBridgeRef() {
-  return external_exports.unknown();
-}
-var MultiCameraStressInputSchema = external_exports.object({
-  steps: external_exports.array(PipelineStepInputSchema).readonly(),
-  imageBase64: external_exports.string(),
-  targetSize: external_exports.number().int().min(64).max(2048).optional(),
-  simulatedCameras: external_exports.number().int().min(1).max(64).optional(),
-  batchesPerCamera: external_exports.number().int().min(1).max(2e3).optional(),
-  batchSize: external_exports.number().int().min(1).max(64).optional(),
-  extraSinglesPerRound: external_exports.number().int().min(0).max(16).optional(),
-  nodeId: external_exports.string().optional(),
-  sessionId: external_exports.string().optional()
+var SyntheticBenchStatusSchema = external_exports.object({
+  sessionId: external_exports.string(),
+  state: external_exports.enum(["running", "done", "failed", "aborted"]),
+  startedAtMs: external_exports.number(),
+  finishedAtMs: external_exports.number().nullable(),
+  progress: external_exports.object({ runs: external_exports.number(), totalRuns: external_exports.number() }).nullable(),
+  result: SyntheticBenchStatsSchema.nullable(),
+  error: external_exports.string().nullable()
+}).nullable();
+var MotionSessionSchema = external_exports.object({
+  motionEventId: external_exports.number(),
+  deviceId: external_exports.number(),
+  startMs: external_exports.number(),
+  /** `null` while the session is still open. */
+  durationMs: external_exports.number().nullable(),
+  open: external_exports.boolean(),
+  /** Why a replay of this session would be refused (`session-open`, `session-length-unknown`, …); `null` = replayable. */
+  refusal: external_exports.string().nullable(),
+  /** Stored tracks born inside the session window (slim read). */
+  storedTracks: external_exports.number()
 });
-var MultiCameraStressResultSchema = external_exports.object({
-  totalMs: external_exports.number(),
-  countedDetections: external_exports.number(),
-  detsPerSec: external_exports.number(),
-  totalCalls: external_exports.number(),
-  totalFrames: external_exports.number(),
-  callMsP50: external_exports.number(),
-  callMsP95: external_exports.number(),
-  callMsP99: external_exports.number(),
-  inferMsMean: external_exports.number(),
-  errors: external_exports.number()
+var ListMotionSessionsInputSchema = external_exports.object({
+  deviceId: external_exports.number(),
+  /** Default: the last 24 h. */
+  sinceMs: external_exports.number().optional(),
+  untilMs: external_exports.number().optional(),
+  limit: external_exports.number().int().min(1).max(200).default(50)
 });
-var SustainedEngineSchema = external_exports.object({
-  runtime: external_exports.enum(["python", "node"]),
-  backend: external_exports.string(),
-  format: external_exports.enum(["onnx", "coreml", "openvino", "tflite"]),
-  device: external_exports.string().optional()
-}).optional();
-var SustainedNodeTargetSchema = external_exports.object({
-  nodeId: external_exports.string().optional(),
-  engine: SustainedEngineSchema,
+var SESSION_REPLAY_MAX_FRAMES = 1200;
+var StartSessionReplayInputSchema = external_exports.object({
+  deviceId: external_exports.number(),
+  motionEventId: external_exports.number(),
+  /** The session's start (`getMotionEvents.timestamp`) — the lookup is windowed on it. */
+  motionStartMs: external_exports.number(),
+  nodeId: external_exports.string(),
+  /** Absent ⇒ the node-default pool. */
   deviceKey: external_exports.string().optional(),
-  steps: external_exports.array(PipelineStepInputSchema).readonly(),
-  label: external_exports.string().optional()
-});
-var SustainedThroughputInputSchema = external_exports.object({
-  frameId: external_exports.string().optional(),
-  imageBase64: external_exports.string().optional(),
-  durationSec: external_exports.number().min(1).max(3600),
-  batchSize: external_exports.number().int().min(1).max(255),
-  concurrency: external_exports.number().int().min(1).max(64),
-  targetSize: external_exports.number().int().min(64).max(2048).optional(),
-  sessionId: external_exports.string(),
-  nodes: external_exports.array(SustainedNodeTargetSchema).min(1).readonly()
+  /** Absent ⇒ the model the camera's resolved tree names. */
+  modelId: external_exports.string().optional(),
+  /** Absent ⇒ measured from the stored positions (the live cadence). */
+  fps: external_exports.number().min(1).max(30).optional(),
+  maxFrames: external_exports.number().int().min(1).max(SESSION_REPLAY_MAX_FRAMES).default(600)
 });
-var SustainedLatencyStatsSchema = external_exports.object({
-  p50: external_exports.number(),
-  p95: external_exports.number(),
-  p99: external_exports.number(),
-  mean: external_exports.number(),
-  min: external_exports.number(),
-  max: external_exports.number()
+var StartSessionReplayAcceptedSchema = external_exports.object({
+  accepted: external_exports.literal(true),
+  runId: external_exports.string()
 });
-var SustainedNodeResultSchema = external_exports.object({
-  nodeId: external_exports.string().nullable(),
-  label: external_exports.string().optional(),
-  /** Total frames processed by this node's loop. */
-  totalFrames: external_exports.number(),
-  /** Total completed batch calls. */
-  totalBatches: external_exports.number(),
-  /** Measured wall-clock window in ms. */
-  wallMs: external_exports.number(),
-  /** Sustained throughput. */
-  fps: external_exports.number(),
-  detsPerSec: external_exports.number(),
-  /** Mean detections per frame — stable since the frame is fixed. */
-  avgDetections: external_exports.number(),
-  latency: SustainedLatencyStatsSchema,
-  /** Batch calls that errored (transport / inference). */
-  errors: external_exports.number(),
-  /** True when this node ended via the stop button rather than the deadline. */
-  aborted: external_exports.boolean()
+var SessionReplayKeySchema = external_exports.object({ runId: external_exports.string() });
+var SessionReplayStatusSchema = external_exports.object({
+  runId: external_exports.string(),
+  state: external_exports.enum(["running", "done", "failed", "aborted"]),
+  startedAtMs: external_exports.number(),
+  finishedAtMs: external_exports.number().nullable(),
+  progress: SessionReplayProgressSchema.nullable(),
+  outcome: SessionReplayOutcomeSchema.nullable(),
+  error: external_exports.string().nullable()
+}).nullable();
+var StoredSessionReplaySummarySchema = external_exports.object({
+  id: external_exports.string(),
+  deviceId: external_exports.number(),
+  nodeId: external_exports.string(),
+  createdAtMs: external_exports.number(),
+  report: SessionReplayReportSchema.omit({ timeline: true })
 });
-var SustainedThroughputResultSchema = external_exports.object({
-  perNode: external_exports.array(SustainedNodeResultSchema).readonly(),
-  durationSec: external_exports.number(),
-  batchSize: external_exports.number(),
-  concurrency: external_exports.number()
+var ListSessionReplaysInputSchema = external_exports.object({ deviceId: external_exports.number() });
+var ListSessionReplaysResultSchema = external_exports.object({
+  runs: external_exports.array(StoredSessionReplaySummarySchema).readonly(),
+  /** Rows that did not read as a session replay (the removed clip replays). */
+  skipped: external_exports.number()
 });
-var ReplaySourceSchema = external_exports.custom();
-var ReplayOverlaySchema = external_exports.custom();
-var OrchestrateReplayRunResultSchema = external_exports.custom();
-var StoredReplayRunSchema = external_exports.custom();
-var ReplayDiffSchema = external_exports.custom();
-var RunReplayClipInputSchema = external_exports.object({
+var GetSessionReplayInputSchema = external_exports.object({ id: external_exports.string() });
+var StoredSessionReplaySchema = external_exports.object({
+  id: external_exports.string(),
   deviceId: external_exports.number(),
   nodeId: external_exports.string(),
-  source: ReplaySourceSchema,
-  overlay: ReplayOverlaySchema,
-  fps: external_exports.number().positive(),
-  maxFrames: external_exports.number().int().positive(),
-  maxWidth: external_exports.number().int().positive().default(1920),
-  deviceKey: external_exports.string().optional()
-});
-var UploadReplayClipInputSchema = external_exports.object({
-  dataBase64: external_exports.string(),
-  durationMs: external_exports.number().positive()
+  createdAtMs: external_exports.number(),
+  report: SessionReplayReportSchema
 });
-var UploadReplayClipResultSchema = external_exports.object({ clipId: external_exports.string() });
-var ListReplayRunsInputSchema = external_exports.object({ deviceId: external_exports.number() });
-var DiffReplayRunsInputSchema = external_exports.object({ runIdA: external_exports.string(), runIdB: external_exports.string() });
 
 // src/benchmark-actions.ts
 var benchmarkActions = defineCustomActions({
-  // Pipeline tester
+  // Detection Pipeline — one run.
   runPipelineTest: customAction(PipelineRunInputSchema, PipelineRunResultBridge, {
     kind: "mutation"
   }),
   /**
-   * Decode a JPEG once on the server and cache the resulting raw RGB
-   * buffer keyed by a returned `frameId`. Subsequent `runPipelineTest`
-   * calls pass `frameId` instead of `imageBase64` — the addon ships the
-   * cached raw frame to `pipelineExecutor.runPipeline` via the `frame`
-   * field, mirroring the production camera path (stream-broker delivers
-   * decoded RGB to pipeline-runner). Eliminates per-call JPEG decode +
-   * 265KB base64 transfer that was dominating bench transport time.
-   */
-  cacheBenchFrame: customAction(
-    external_exports.object({ imageBase64: external_exports.string(), ttlSeconds: external_exports.number().int().positive().optional() }),
-    external_exports.object({ frameId: external_exports.string(), width: external_exports.number(), height: external_exports.number(), expiresAt: external_exports.number() }),
-    { kind: "mutation" }
-  ),
-  releaseBenchFrame: customAction(
-    external_exports.object({ frameId: external_exports.string() }),
-    external_exports.object({ released: external_exports.boolean() }),
-    { kind: "mutation" }
-  ),
-  /**
-   * Batched pipeline tester. Decodes the JPEG once into RGB on the
-   * addon, then forwards N FrameInputs to the target node in a single
-   * `pipelineExecutor.runPipelineBatch` cap call. Returns N
-   * `FrameResult`s plus aggregate timing.
-   *
-   * NO UI CALLER — and it is NOT dead. `scripts/bench-pool-ceiling.mts` and
-   * `scripts/bench-pipeline-investigation.mts` drive it directly. Do not
-   * delete it on the strength of an in-package grep; those scripts break
-   * silently and nothing in CI runs them.
-   */
-  runPipelineBatchTest: customAction(PipelineRunBatchInputSchema, PipelineRunBatchResultSchema, {
-    kind: "mutation"
-  }),
-  /**
-   * Multi-camera stress tester — runs the full multi-camera workload
-   * loop in-process (decode JPEG once, then N parallel "cameras" each
-   * issuing a configurable mix of batched + single cap calls). Returns
-   * only aggregate detection-rate stats. Used to measure the pool's
-   * true throughput ceiling without per-call tRPC overhead.
-   *
-   * NO UI CALLER — and it is NOT dead. `scripts/bench-pool-inprocess.mts`
-   * drives it directly. Same warning as `runPipelineBatchTest` above.
-   */
-  runMultiCameraStressTest: customAction(
-    MultiCameraStressInputSchema,
-    MultiCameraStressResultSchema,
-    { kind: "mutation" }
-  ),
-  /**
-   * Sustained-throughput ROOT-detection e2e run. Pins ONE frame (decoded
-   * once), then feeds the identical frame to root object-detection for
-   * `durationSec` seconds — driven by BATCHES (`runPipelineBatch`,
-   * `batchSize` frames/call) with `concurrency` calls in flight, fanned out
-   * across `nodes`, each on its resolved runtime/model + root-only steps.
-   * Returns per-node sustained fps / det/s + latency percentiles on the
-   * identical pinned frame. Bounded by N + `abortSustainedThroughput`.
-   */
-  runSustainedThroughput: customAction(
-    SustainedThroughputInputSchema,
-    SustainedThroughputResultSchema,
-    { kind: "mutation" }
-  ),
-  abortSustainedThroughput: customAction(
-    external_exports.object({ sessionId: external_exports.string() }),
-    external_exports.object({ aborted: external_exports.boolean() }),
-    { kind: "mutation" }
-  ),
-  /**
-   * History (shared across pipeline + decoder-perf entries).
+   * History.
    *
    * `z.object({})`, never `z.void()`: the `addons.custom` envelope insists
-   * on an `input` object, and a `z.void()` schema REJECTS `{}` — so the
-   * action resolved and could never actually be called, not from a settings
-   * button and not from `hub.mjs`. The tabs only got away with it by
-   * sending `input: undefined`.
+   * on an `input` object, and a `z.void()` schema REJECTS `{}`.
    */
   listBenchmarkHistory: customAction(external_exports.object({}), external_exports.array(HistoryEntrySchema).readonly()),
   saveBenchmarkResult: customAction(
@@ -14922,11 +14857,6 @@ var benchmarkActions = defineCustomActions({
     PipelineBenchmarkHistoryEntrySchema,
     { kind: "mutation" }
   ),
-  saveDecoderPerformanceResult: customAction(
-    DecoderPerfHistoryEntryInputSchema,
-    DecoderPerfHistoryEntrySchema,
-    { kind: "mutation" }
-  ),
   deleteBenchmarkResult: customAction(
     external_exports.object({ id: external_exports.string() }),
     external_exports.object({ success: external_exports.literal(true) }),
@@ -14935,332 +14865,41 @@ var benchmarkActions = defineCustomActions({
   clearBenchmarkHistory: customAction(external_exports.object({}), external_exports.object({ success: external_exports.literal(true) }), {
     kind: "mutation"
   }),
-  // Replay — rigiocare una pipeline vera su una clip fissa. Regia qui,
-  // FrameProcessor pass in `addon-post-analysis` via
-  // `pipelineAnalytics.runReplayFrameProcessor` (see `replay/replay-wiring.ts`).
-  uploadReplayClip: customAction(UploadReplayClipInputSchema, UploadReplayClipResultSchema, {
-    kind: "mutation"
-  }),
-  runReplayClip: customAction(RunReplayClipInputSchema, OrchestrateReplayRunResultSchema, {
-    kind: "mutation"
-  }),
-  listReplayRuns: customAction(
-    ListReplayRunsInputSchema,
-    external_exports.array(StoredReplayRunSchema).readonly()
+  // Session replay (D646) — the stored sessions to pick from, then start / poll / abort.
+  listMotionSessions: customAction(
+    ListMotionSessionsInputSchema,
+    external_exports.array(MotionSessionSchema).readonly()
   ),
-  diffReplayRuns: customAction(DiffReplayRunsInputSchema, ReplayDiffSchema),
-  // Decoder perf — fixture discovery + run control.
-  // `z.object({})` for the same reason as `listBenchmarkHistory` above.
-  listDecoderFixtures: customAction(external_exports.object({}), external_exports.array(DecoderFixtureSchema).readonly()),
-  runDecoderPerformanceTest: customAction(DecoderPerfInputSchema, DecoderPerfResultSchema, {
-    kind: "mutation"
+  startSessionReplay: customAction(
+    StartSessionReplayInputSchema,
+    StartSessionReplayAcceptedSchema,
+    { kind: "mutation", auth: "admin" }
+  ),
+  getSessionReplayStatus: customAction(SessionReplayKeySchema, SessionReplayStatusSchema),
+  abortSessionReplay: customAction(SessionReplayKeySchema, external_exports.object({ aborted: external_exports.boolean() }), {
+    kind: "mutation",
+    auth: "admin"
   }),
-  abortDecoderPerformanceTest: customAction(
-    external_exports.object({ sessionId: external_exports.string() }),
-    external_exports.object({ aborted: external_exports.boolean() }),
-    { kind: "mutation" }
-  )
+  listSessionReplays: customAction(ListSessionReplaysInputSchema, ListSessionReplaysResultSchema),
+  getSessionReplay: customAction(GetSessionReplayInputSchema, StoredSessionReplaySchema.nullable())
 });
 
-// src/benchmark-addon.ts
-import { createHash } from "crypto";
-
-// src/decoder-perf-runner.ts
-import * as fs from "fs";
-import * as path from "path";
-import { performance } from "perf_hooks";
-import { cpuUsage, memoryUsage } from "process";
-import { createEvent, nodePin } from "@camstack/types";
-var CHUNK_SIZE = 4096;
-function emitProgress(eventBus, payload) {
-  if (!eventBus) return;
-  eventBus.emit(
-    createEvent(
-      "benchmark.progress",
-      { type: "benchmark", id: "decoder-perf" },
-      {
-        kind: payload.kind,
-        sessionId: payload.sessionId,
-        phase: payload.phase,
-        tSec: payload.tSec,
-        sample: payload.sample ? { ...payload.sample } : void 0,
-        message: payload.message
-      }
-    )
-  );
-}
-function slope(xs, ys) {
-  if (xs.length < 2) return 0;
-  const n = xs.length;
-  let sx = 0, sy = 0, sxx = 0, sxy = 0;
-  for (let i = 0; i < n; i++) {
-    sx += xs[i];
-    sy += ys[i];
-    sxx += xs[i] * xs[i];
-    sxy += xs[i] * ys[i];
-  }
-  const denom = n * sxx - sx * sx;
-  return denom === 0 ? 0 : (n * sxy - sx * sy) / denom;
-}
-function verdictFor(rssSlopeMBMin, warnMBMin, failMBMin) {
-  if (rssSlopeMBMin >= failMBMin) return "fail";
-  if (rssSlopeMBMin >= warnMBMin) return "warn";
-  return "pass";
-}
-function resolveFixtureCodec(filename) {
-  if (filename.endsWith(".hevc") || filename.endsWith(".h265")) return "h265";
-  return "h264";
-}
-function readFixtureBytes(fixturesDir, filename) {
-  const full = path.join(fixturesDir, filename);
-  if (!fs.existsSync(full)) {
-    throw new Error(`decoder fixture not found: ${filename}`);
-  }
-  return fs.readFileSync(full);
-}
-async function createSessions(api, input, codec2) {
-  const handles = [];
-  const pin = input.nodeId ? nodePin(input.nodeId) : void 0;
-  for (let i = 0; i < input.cameras; i++) {
-    const created = await api.decoder.createSession.query(
-      {
-        codec: codec2,
-        maxFps: input.fps,
-        outputFormat: input.format === "gray" ? "gray" : "jpeg",
-        scale: 1
-      },
-      pin
-    );
-    handles.push({
-      sessionId: created.sessionId,
-      nodeId: created.nodeId,
-      codec: codec2,
-      offsetBytes: 0,
-      framesPushed: 0
-    });
-  }
-  return handles;
-}
-async function destroySessions(api, handles, logger) {
-  for (const h of handles) {
-    try {
-      await api.decoder.destroySession.query({ sessionId: h.sessionId, nodeId: h.nodeId });
-    } catch (err) {
-      logger.warn("destroySession failed", {
-        meta: { sessionId: h.sessionId, error: err instanceof Error ? err.message : String(err) }
-      });
-    }
-  }
-}
-async function pushChunk(api, handle, fixture) {
-  if (handle.offsetBytes >= fixture.length) handle.offsetBytes = 0;
-  const end = Math.min(handle.offsetBytes + CHUNK_SIZE, fixture.length);
-  const chunk = fixture.subarray(handle.offsetBytes, end);
-  handle.offsetBytes = end;
-  const now = Date.now();
-  await api.decoder.pushPacket.query({
-    sessionId: handle.sessionId,
-    nodeId: handle.nodeId,
-    packet: {
-      type: "video",
-      data: new Uint8Array(chunk),
-      pts: now,
-      dts: now,
-      keyframe: handle.offsetBytes <= CHUNK_SIZE,
-      codec: handle.codec
-    }
-  });
-  handle.framesPushed += 1;
-}
-async function sumDroppedFrames(api, handles) {
-  let dropped = 0;
-  for (const h of handles) {
-    try {
-      const stats = await api.decoder.getStats.query({ sessionId: h.sessionId, nodeId: h.nodeId });
-      dropped += stats.droppedFrames;
-    } catch {
-    }
-  }
-  return dropped;
-}
-async function runDecoderPerfTest(input, deps) {
-  const { api, eventBus, logger, fixturesDir, abortFlag } = deps;
-  const sessionId = input.sessionId;
-  const samples = [];
-  const startWall = performance.now();
-  emitProgress(eventBus, {
-    kind: "decoder-perf",
-    sessionId,
-    phase: "init",
-    message: "initialising"
-  });
-  if (input.source.kind !== "sample") {
-    const msg = "decoder perf: stream source not yet implemented \u2014 use a sample fixture";
-    emitProgress(eventBus, { kind: "decoder-perf", sessionId, phase: "error", message: msg });
-    return {
-      sessionId,
-      verdict: "error",
-      aborted: false,
-      errorMessage: msg,
-      samples: [],
-      slopes: { rssMBMin: 0, heapMBMin: 0, externalMBMin: 0 },
-      totals: { wallSec: 0, framesEmitted: 0, fpsPerCamera: 0, cpuAvgPct: 0, droppedFrames: 0 },
-      config: input
-    };
-  }
-  const fixtureName = input.source.fixtureFilename;
-  const codec2 = resolveFixtureCodec(fixtureName);
-  const fixture = readFixtureBytes(fixturesDir, fixtureName);
-  try {
-    const active = await api.decoder.listActiveSessions.query();
-    if (active.length > 0) {
-      logger.warn("concurrent decoder sessions detected \u2014 measurement may be contaminated", {
-        meta: { concurrent: active.length }
-      });
-    }
-  } catch {
-  }
-  try {
-    const instances = await api.metricsProvider.listAddonInstances.query();
-    const workerInstances = instances.filter((i) => i.role === "worker");
-    if (workerInstances.length === 0) {
-      logger.info(
-        "decoder perf: no isolated worker detected \u2014 hub-local measurement (process.memoryUsage) mixes decoder + hub workload"
-      );
-    } else {
-      logger.info("decoder perf: worker instances visible", {
-        meta: { workers: workerInstances.map((w) => w.addonId) }
-      });
-    }
-  } catch {
-  }
-  let handles;
-  try {
-    handles = await createSessions(api, input, codec2);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    emitProgress(eventBus, {
-      kind: "decoder-perf",
-      sessionId,
-      phase: "error",
-      message: `createSession failed: ${msg}`
-    });
-    return {
-      sessionId,
-      verdict: "error",
-      aborted: false,
-      errorMessage: msg,
-      samples: [],
-      slopes: { rssMBMin: 0, heapMBMin: 0, externalMBMin: 0 },
-      totals: { wallSec: 0, framesEmitted: 0, fpsPerCamera: 0, cpuAvgPct: 0, droppedFrames: 0 },
-      config: input
-    };
+// src/replay/mjpeg-split.ts
+var SOI = Buffer.from([255, 216]);
+var EOI = Buffer.from([255, 217]);
+function splitMjpegStream(bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const out = [];
+  let pos = 0;
+  for (; ; ) {
+    const soi = buf.indexOf(SOI, pos);
+    if (soi === -1) break;
+    const eoi = buf.indexOf(EOI, soi + SOI.length);
+    if (eoi === -1) break;
+    out.push(buf.subarray(soi, eoi + EOI.length));
+    pos = eoi + EOI.length;
   }
-  const frameIntervalMs = 1e3 / input.fps;
-  const warmupMs = input.warmupSec * 1e3;
-  const durationMs = input.mode.kind === "duration" ? input.mode.durationSec * 1e3 : Number.MAX_SAFE_INTEGER;
-  const targetIterations = input.mode.kind === "iterations" ? input.mode.iterations : Number.MAX_SAFE_INTEGER;
-  let cpuSnapshot = cpuUsage();
-  let cpuWallMs = performance.now();
-  const feedTickerStart = performance.now();
-  let nextFeedAt = feedTickerStart;
-  let nextSampleAt = feedTickerStart + warmupMs;
-  let aborted2 = false;
-  emitProgress(eventBus, {
-    kind: "decoder-perf",
-    sessionId,
-    phase: "warmup",
-    tSec: 0,
-    message: `warming up ${input.warmupSec}s`
-  });
-  const loopUntil = feedTickerStart + warmupMs + durationMs;
-  while (performance.now() < loopUntil) {
-    if (abortFlag.aborted) {
-      aborted2 = true;
-      break;
-    }
-    const totalPushed = handles.reduce((s, h) => s + h.framesPushed, 0);
-    if (totalPushed >= targetIterations * handles.length) break;
-    const now = performance.now();
-    if (now >= nextFeedAt) {
-      for (const h of handles) {
-        try {
-          await pushChunk(api, h, fixture);
-        } catch (err) {
-          logger.warn("pushPacket failed", {
-            meta: {
-              sessionId: h.sessionId,
-              error: err instanceof Error ? err.message : String(err)
-            }
-          });
-        }
-      }
-      nextFeedAt += frameIntervalMs;
-    }
-    if (now >= nextSampleAt) {
-      const tSec = (now - feedTickerStart) / 1e3;
-      const mem = memoryUsage();
-      const cpu = cpuUsage(cpuSnapshot);
-      const windowMs = now - cpuWallMs;
-      const cpuPct = windowMs > 0 ? (cpu.user + cpu.system) / 1e3 / windowMs * 100 : 0;
-      cpuSnapshot = cpuUsage();
-      cpuWallMs = now;
-      const sample = {
-        tSec,
-        rssMB: mem.rss / 1048576,
-        heapMB: mem.heapUsed / 1048576,
-        externalMB: mem.external / 1048576,
-        arrayBuffersMB: mem.arrayBuffers / 1048576,
-        cpuPct,
-        framesTotal: handles.reduce((s, h) => s + h.framesPushed, 0)
-      };
-      samples.push(sample);
-      emitProgress(eventBus, {
-        kind: "decoder-perf",
-        sessionId,
-        phase: tSec < 0 ? "warmup" : "running",
-        tSec,
-        sample
-      });
-      nextSampleAt += input.sampleIntervalMs;
-    }
-    const sleepMs = Math.max(0, Math.min(nextFeedAt, nextSampleAt) - performance.now());
-    if (sleepMs > 0) await new Promise((r) => setTimeout(r, sleepMs));
-  }
-  const droppedFrames = await sumDroppedFrames(api, handles);
-  await destroySessions(api, handles, logger);
-  const postWarmup = samples.filter((s) => s.tSec * 1e3 >= warmupMs);
-  const xs = postWarmup.map((s) => s.tSec);
-  const rssYs = postWarmup.map((s) => s.rssMB);
-  const heapYs = postWarmup.map((s) => s.heapMB);
-  const extYs = postWarmup.map((s) => s.externalMB);
-  const rssSlopeMBMin = slope(xs, rssYs) * 60;
-  const heapSlopeMBMin = slope(xs, heapYs) * 60;
-  const externalSlopeMBMin = slope(xs, extYs) * 60;
-  const wallSec = (performance.now() - startWall) / 1e3;
-  const framesEmitted = handles.reduce((s, h) => s + h.framesPushed, 0);
-  const fpsPerCamera = wallSec > 0 ? framesEmitted / Math.max(1, handles.length) / wallSec : 0;
-  const cpuAvgPct = samples.length > 0 ? samples.reduce((s, x) => s + x.cpuPct, 0) / samples.length : 0;
-  const verdict = aborted2 ? "aborted" : verdictFor(rssSlopeMBMin, input.thresholds.warnMBMin, input.thresholds.failMBMin);
-  emitProgress(eventBus, {
-    kind: "decoder-perf",
-    sessionId,
-    phase: aborted2 ? "aborted" : "complete",
-    message: `done \u2014 rss slope ${rssSlopeMBMin.toFixed(2)} MB/min`
-  });
-  return {
-    sessionId,
-    verdict,
-    aborted: aborted2,
-    samples,
-    slopes: {
-      rssMBMin: rssSlopeMBMin,
-      heapMBMin: heapSlopeMBMin,
-      externalMBMin: externalSlopeMBMin
-    },
-    totals: { wallSec, framesEmitted, fpsPerCamera, cpuAvgPct, droppedFrames },
-    config: input
-  };
+  return out;
 }
 
 // src/replay/replay-decode.ts
@@ -15289,13 +14928,13 @@ var REPLAY_DECODE_MAX_CONCURRENT = 2;
 var REPLAY_DECODE_TIMEOUT_MS = 15e3;
 var KILL_GRACE_MS = 500;
 var ReplayDecoder = class {
-  ffmpegPath;
+  resolveFfmpegPath;
   spawnFn;
   maxConcurrent;
   timeoutMs;
   inFlight = 0;
   constructor(deps) {
-    this.ffmpegPath = deps.ffmpegPath;
+    this.resolveFfmpegPath = deps.resolveFfmpegPath;
     this.spawnFn = deps.spawnFn ?? ((bin, args) => spawn(bin, [...args]));
     this.maxConcurrent = deps.maxConcurrent ?? REPLAY_DECODE_MAX_CONCURRENT;
     this.timeoutMs = deps.timeoutMs ?? REPLAY_DECODE_TIMEOUT_MS;
@@ -15312,7 +14951,7 @@ var ReplayDecoder = class {
    * uploaded clip) are fetched through a capability call, not a local path.
    * Resolves with the whole MJPEG stdout stream.
    */
-  async decodeSequence(args, input) {
+  async decodeSequence(args, input, opts = {}) {
     if (this.inFlight >= this.maxConcurrent) {
       throw new Error(
         `replay decode busy: node already running ${this.inFlight}/${this.maxConcurrent} decodes`
@@ -15320,19 +14959,20 @@ var ReplayDecoder = class {
     }
     this.inFlight += 1;
     try {
-      return await this.runOnce(args, input);
+      const ffmpegPath = await this.resolveFfmpegPath();
+      return await this.runOnce(ffmpegPath, args, input, opts.timeoutMs ?? this.timeoutMs);
     } finally {
       this.inFlight -= 1;
     }
   }
-  runOnce(args, input) {
-    return new Promise((resolve2, reject) => {
+  runOnce(ffmpegPath, args, input, timeoutMs) {
+    return new Promise((resolve, reject) => {
       const chunks = [];
       const stderrTail = [];
       let settled = false;
       const child = (() => {
         try {
-          return this.spawnFn(this.ffmpegPath, args);
+          return this.spawnFn(ffmpegPath, args);
         } catch (err) {
           reject(new Error(`replay decode: ffmpeg spawn failed: ${String(err)}`));
           return null;
@@ -15363,7 +15003,7 @@ var ReplayDecoder = class {
       const timer = setTimeout(() => {
         settle(() => reject(new Error("replay decode: timed out")));
         kill();
-      }, this.timeoutMs);
+      }, timeoutMs);
       timer.unref?.();
       child.stdout?.on("data", (chunk) => chunks.push(chunk));
       child.stderr?.on("data", (data) => {
@@ -15379,7 +15019,7 @@ var ReplayDecoder = class {
       child.on("exit", (code, signal) => {
         const stdout = Buffer.concat(chunks);
         if (code === 0) {
-          settle(() => resolve2(stdout));
+          settle(() => resolve(stdout));
           return;
         }
         settle(
@@ -15401,6 +15041,7 @@ var ReplayDecoder = class {
 
 // src/replay/replay-store.ts
 var REPLAY_RUNS_COLLECTION = "benchmark:replay-runs";
+var REPLAY_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var REPLAY_RUNS_COLUMNS = [
   { name: "id", type: "TEXT", primaryKey: true, notNull: true },
   { name: "deviceId", type: "INTEGER", notNull: true },
@@ -15415,7 +15056,14 @@ var REPLAY_RUNS_INDEXES = [
   { name: "idx_replay_runs_device_created", columns: ["deviceId", "createdAtMs"] },
   { name: "idx_replay_runs_created", columns: ["createdAtMs"] }
 ];
-var ReplayStore = class {
+var StoredRowSchema = external_exports.object({
+  deviceId: external_exports.number(),
+  nodeId: external_exports.string(),
+  createdAtMs: external_exports.number(),
+  source: external_exports.object({ kind: external_exports.literal("motion-session") }).loose(),
+  verdict: SessionReplayReportSchema
+});
+var ReplayStore = class _ReplayStore {
   constructor(store) {
     this.store = store;
   }
@@ -15430,24 +15078,57 @@ var ReplayStore = class {
     });
   }
   async save(run) {
-    const { id, ...rest } = run;
+    const { report } = run;
     await this.store.insert.mutate({
       collection: REPLAY_RUNS_COLLECTION,
-      record: { id, data: rest }
-      // TECH-DEBT: settings-store boundary, see the comment above.
+      record: {
+        id: run.id,
+        data: {
+          deviceId: run.deviceId,
+          nodeId: run.nodeId,
+          clipId: `session:${report.deviceId}:${report.motionEventId}`,
+          createdAtMs: run.createdAtMs,
+          source: { kind: "motion-session", motionEventId: report.motionEventId, ...report.window },
+          plan: {
+            pin: report.pin,
+            rootStep: report.rootStep,
+            cadence: report.cadence,
+            frameSize: report.frameSize
+          },
+          verdict: report
+        }
+      }
     });
   }
-  /** Runs newest-first, optionally scoped to one device. */
+  /** Session replays newest-first, optionally scoped to one camera. */
   async list(query) {
-    const filter = { orderBy: { field: "createdAtMs", direction: "desc" } };
-    if (query.deviceId !== void 0) filter.where = { deviceId: query.deviceId };
-    if (query.limit !== void 0) filter.limit = query.limit;
-    const rows = await this.store.query.query({ collection: REPLAY_RUNS_COLLECTION, filter });
-    return rows.map((r) => ({ id: r.id, ...r.data }));
+    const rows = await this.store.query.query({
+      collection: REPLAY_RUNS_COLLECTION,
+      filter: {
+        orderBy: { field: "createdAtMs", direction: "desc" },
+        ...query.deviceId !== void 0 ? { where: { deviceId: query.deviceId } } : {},
+        ...query.limit !== void 0 ? { limit: query.limit } : {}
+      }
+    });
+    const runs = [];
+    let skipped = 0;
+    for (const row of rows) {
+      const parsed = _ReplayStore.readRow(row.id, row.data);
+      if (parsed === null) skipped += 1;
+      else runs.push(parsed);
+    }
+    return { runs, skipped };
+  }
+  async get(id) {
+    const rows = await this.store.query.query({
+      collection: REPLAY_RUNS_COLLECTION,
+      filter: { where: { id }, limit: 1 }
+    });
+    const row = rows[0];
+    return row === void 0 ? null : _ReplayStore.readRow(row.id, row.data);
   }
   /** Delete every run created before `cutoffMs`. This store's OWN retention
-   *  clock — see the file header for why that matters. Returns the count so
-   *  a caller can log it, the way `OpsLogStore`-adjacent sweeps do. */
+   *  clock — see the file header for why that matters. */
   async pruneBefore(cutoffMs) {
     const { deleted } = await this.store.deleteWhere.mutate({
       collection: REPLAY_RUNS_COLLECTION,
@@ -15455,449 +15136,845 @@ var ReplayStore = class {
     });
     return deleted;
   }
-};
-
-// src/replay/replay-plan.ts
-function readPreflight(result) {
-  if (!result.ok) {
-    const detail = result.issues.map((i) => `${i.addonId}: ${i.detail}`).join("; ");
-    return { kind: "refused", reason: "step-unrunnable", detail };
-  }
-  if (result.substitutions.length > 0) {
-    const detail = result.substitutions.map((s) => `${s.addonId}: chose \`${s.chosen}\`, running \`${s.running}\` (${s.format})`).join("; ");
-    return { kind: "refused", reason: "model-substituted", detail };
-  }
-  return { kind: "runnable", format: result.format };
-}
-var PACKAGE_DETECTION_STEP_ID = "package-detection";
-function applyPackageZoneOverlay(steps, overlay) {
-  if (overlay.packageDetection === void 0) return steps;
-  const existing = steps.find((s) => s.addonId === PACKAGE_DETECTION_STEP_ID);
-  if (!overlay.packageDetection) {
-    if (!existing) return steps;
-    return steps.filter((s) => s.addonId !== PACKAGE_DETECTION_STEP_ID);
-  }
-  if (existing) {
-    if (existing.enabled === true) return steps;
-    return steps.map((s) => s.addonId === PACKAGE_DETECTION_STEP_ID ? { ...s, enabled: true } : s);
-  }
-  const node = {
-    addonId: PACKAGE_DETECTION_STEP_ID,
-    enabled: true,
-    children: []
-  };
-  return [...steps, node];
-}
-function applySettingsAndModels(steps, overlay, ignored) {
-  const settingsKeys = new Set(Object.keys(overlay.stepSettings ?? {}));
-  const modelKeys = new Set(Object.keys(overlay.stepModels ?? {}));
-  const presentIds = new Set(steps.map((s) => s.addonId));
-  for (const id of settingsKeys) if (!presentIds.has(id)) ignored.add(id);
-  for (const id of modelKeys) if (!presentIds.has(id)) ignored.add(id);
-  return steps.map((s) => {
-    const settingsPatch = overlay.stepSettings?.[s.addonId];
-    const modelOverride = overlay.stepModels?.[s.addonId];
-    if (settingsPatch === void 0 && modelOverride === void 0) return s;
+  static readRow(id, data) {
+    const parsed = StoredRowSchema.safeParse(data);
+    if (!parsed.success) return null;
     return {
-      ...s,
-      ...modelOverride !== void 0 ? { modelId: modelOverride } : {},
-      ...settingsPatch !== void 0 ? { settings: { ...s.settings, ...settingsPatch } } : {}
+      id,
+      deviceId: parsed.data.deviceId,
+      nodeId: parsed.data.nodeId,
+      createdAtMs: parsed.data.createdAtMs,
+      report: parsed.data.verdict
     };
-  });
-}
-function buildReplayPlan(base, overlay) {
-  const ignored = /* @__PURE__ */ new Set();
-  const withPackageZone = applyPackageZoneOverlay(base.steps, overlay);
-  const steps = applySettingsAndModels(withPackageZone, overlay, ignored);
-  return { steps, ignoredOverlays: [...ignored] };
-}
-
-// src/replay/replay-source.ts
-function planReplayFrames(source, fps, maxFrames) {
-  const durationMs = source.kind === "recording" ? source.toMs - source.fromMs : source.durationMs;
-  if (durationMs <= 0) return { kind: "refused", reason: "empty-window" };
-  const stepMs = 1e3 / fps;
-  const startAt = source.kind === "recording" ? source.fromMs : 0;
-  const rawCount = Math.max(1, Math.floor(durationMs / stepMs));
-  const truncated = rawCount > maxFrames;
-  const count = Math.min(rawCount, maxFrames);
-  const instants = [];
-  for (let i = 0; i < count; i++) instants.push(startAt + Math.round(i * stepMs));
-  return { kind: "planned", deviceId: source.deviceId, instants, truncated };
-}
-
-// src/replay/mjpeg-split.ts
-var SOI = Buffer.from([255, 216]);
-var EOI = Buffer.from([255, 217]);
-function splitMjpegStream(bytes) {
-  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const out = [];
-  let pos = 0;
-  for (; ; ) {
-    const soi = buf.indexOf(SOI, pos);
-    if (soi === -1) break;
-    const eoi = buf.indexOf(EOI, soi + SOI.length);
-    if (eoi === -1) break;
-    out.push(buf.subarray(soi, eoi + EOI.length));
-    pos = eoi + EOI.length;
   }
-  return out;
-}
+};
 
-// src/replay/replay-run.ts
-var DEFAULT_REPLAY_BUDGET_MS = 12e4;
-var DEFAULT_REPLAY_PACING_MS = 50;
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function runReplay(deps, frames) {
-  const now = deps.now ?? Date.now;
-  const budgetMs = deps.budgetMs ?? DEFAULT_REPLAY_BUDGET_MS;
-  const pacingMs = deps.pacingMs ?? DEFAULT_REPLAY_PACING_MS;
-  const startedAt = now();
-  const tags = { deviceId: deps.deviceId };
-  deps.logger.info("replay: run starting", {
-    tags,
-    meta: { framesPlanned: frames.length, nodeId: deps.nodeId, pacingMs, budgetMs }
-  });
-  const succeeded = [];
-  const discarded = [];
-  let framesFailed = 0;
-  let stoppedOnBudget = false;
-  for (let i = 0; i < frames.length; i++) {
-    if (now() - startedAt >= budgetMs) {
-      stoppedOnBudget = true;
-      deps.logger.warn("replay: run stopped on budget \u2014 a partial census, reported as such", {
-        tags,
-        meta: {
-          framesPlanned: frames.length,
-          framesRan: succeeded.length,
-          framesFailed,
-          budgetMs
-        }
-      });
-      break;
+// src/session-replay/recording-reader.ts
+async function readRecordingForInstants(deps, instants, stepMs) {
+  const parts = [];
+  let withoutFootage = 0;
+  let truncated = false;
+  let i = 0;
+  while (i < instants.length) {
+    const t = instants[i];
+    if (t === void 0) break;
+    const located = await deps.locateSegment(t);
+    if (located.kind !== "segment") {
+      const edge = located.nearestEdgeMs;
+      let j2 = i + 1;
+      if (edge === null) j2 = instants.length;
+      else if (edge > t) while (j2 < instants.length && (instants[j2] ?? edge) < edge) j2++;
+      withoutFootage += j2 - i;
+      i = j2;
+      continue;
     }
-    const f = frames[i];
-    if (f === void 0) continue;
-    try {
-      const frame = await deps.runPipeline({
-        timestamp: f.timestamp,
-        image: f.image,
-        nodeId: deps.nodeId
-      });
-      succeeded.push({ timestamp: f.timestamp, frame });
-      if (frame.discarded !== void 0) discarded.push(...frame.discarded);
-    } catch (err) {
-      framesFailed += 1;
-      deps.logger.warn("replay: frame failed on the node \u2014 counted, run continues", {
-        tags,
-        meta: { timestamp: f.timestamp, error: err instanceof Error ? err.message : String(err) }
-      });
+    const segEnd = located.startMs + located.durMs;
+    let j = i;
+    while (j < instants.length && (instants[j] ?? segEnd) < segEnd) j++;
+    const covered = instants.slice(i, j);
+    const lastCovered = covered[covered.length - 1] ?? t;
+    const window = await deps.readWindowBytes({
+      startMs: located.startMs,
+      fromMs: t,
+      toMs: Math.min(segEnd, lastCovered + Math.round(stepMs))
+    });
+    if (window.kind === "ok") {
+      if (!window.reachesRequestedEnd) truncated = true;
+      parts.push({ bytes: window.data, gopStartMs: window.gopStartMs, instants: covered });
+    } else {
+      withoutFootage += covered.length;
     }
-    if (pacingMs > 0 && i < frames.length - 1) await sleep(pacingMs);
+    i = j === i ? i + 1 : j;
+  }
+  if (parts.length === 0) {
+    return {
+      kind: "refused",
+      reason: "no-footage",
+      detail: `no recording covers any of the ${instants.length} planned instants`
+    };
   }
-  const tracks = succeeded.length > 0 ? (await deps.runTracking(succeeded)).tracks : [];
-  const complete = !stoppedOnBudget && framesFailed === 0;
-  deps.logger.info("replay: run finished", {
-    tags,
-    meta: {
-      framesPlanned: frames.length,
-      framesRan: succeeded.length,
-      framesFailed,
-      complete,
-      tracks: tracks.length
-    }
-  });
   return {
-    kind: succeeded.length === 0 ? "no-frame-ran" : "ran",
-    deviceId: deps.deviceId,
-    nodeId: deps.nodeId,
-    complete,
-    tracks,
-    discarded,
-    counters: { framesPlanned: frames.length, framesRan: succeeded.length, framesFailed }
+    kind: "ok",
+    parts,
+    instantsWithoutFootage: withoutFootage,
+    truncatedBySafetyCap: truncated
   };
 }
 
-// src/replay/replay-wiring.ts
-function clipIdOf(source) {
-  return source.kind === "upload" ? source.clipId : `recording:${source.deviceId}:${source.fromMs}`;
-}
-async function orchestrateReplayRun(deps, input) {
-  const tags = { deviceId: input.deviceId };
-  const base = await deps.resolveBaseTree(input.deviceId);
-  const plan = buildReplayPlan(base, input.overlay);
-  if (plan.ignoredOverlays.length > 0) {
-    deps.logger.warn("replay: overlay named a step the resolved tree does not run", {
-      tags,
-      meta: { ignoredOverlays: plan.ignoredOverlays }
-    });
-  }
-  const preflight = await deps.api.pipelineExecutor.validatePipeline.query({
-    steps: [...plan.steps]
-  });
-  const preflightVerdict = readPreflight(preflight);
-  if (preflightVerdict.kind === "refused") {
-    deps.logger.warn("replay: run refused at preflight", {
-      tags,
-      meta: { reason: preflightVerdict.reason, detail: preflightVerdict.detail }
-    });
-    return { kind: "refused", reason: `${preflightVerdict.reason}: ${preflightVerdict.detail}` };
+// src/session-replay/cadence.ts
+var DEFAULT_DETECTION_FPS = 10;
+var MIN_DETECTION_FPS = 1;
+var MAX_DETECTION_FPS = 30;
+var MIN_GAPS_TO_MEASURE = 3;
+function clampFps(fps) {
+  return Math.min(MAX_DETECTION_FPS, Math.max(MIN_DETECTION_FPS, fps));
+}
+function resolveReplayCadence(requestedFps, positionTimesByTrack) {
+  if (requestedFps !== void 0) return { fps: clampFps(requestedFps), source: "operator" };
+  const gaps = [];
+  for (const times of positionTimesByTrack) {
+    for (let i = 1; i < times.length; i++) {
+      const prev = times[i - 1];
+      const cur = times[i];
+      if (prev !== void 0 && cur !== void 0 && cur > prev) gaps.push(cur - prev);
+    }
+  }
+  if (gaps.length < MIN_GAPS_TO_MEASURE) return { fps: DEFAULT_DETECTION_FPS, source: "default" };
+  const sorted = gaps.toSorted((a, b) => a - b);
+  const quartile = sorted[Math.floor((sorted.length - 1) / 4)] ?? 0;
+  if (!(quartile > 0)) return { fps: DEFAULT_DETECTION_FPS, source: "default" };
+  return { fps: clampFps(Math.round(1e3 / quartile)), source: "stored-positions" };
+}
+
+// src/session-replay/compare.ts
+var MATCH_IOU_MIN = 0.5;
+var RELAXED_IOU_MIN = 0.3;
+var MAX_INTERPOLATION_GAP_MS = 5e3;
+function iou(a, b) {
+  const x1 = Math.max(a.x, b.x);
+  const y1 = Math.max(a.y, b.y);
+  const x2 = Math.min(a.x + a.w, b.x + b.w);
+  const y2 = Math.min(a.y + a.h, b.y + b.h);
+  const inter = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+  if (inter === 0) return 0;
+  const union2 = a.w * a.h + b.w * b.h - inter;
+  return union2 > 0 ? inter / union2 : 0;
+}
+function lerp(a, b, f) {
+  return a + (b - a) * f;
+}
+function entry(p, t, basis) {
+  return { ...p, t, basis };
+}
+function trackAt(track, t, halfStepMs) {
+  let prev;
+  let next;
+  let nearest;
+  for (const p of track.positions) {
+    if (p.t <= t) prev = p;
+    if (p.t >= t && next === void 0) next = p;
+    if (nearest === void 0 || Math.abs(p.t - t) < Math.abs(nearest.t - t)) nearest = p;
   }
-  const framePlan = planReplayFrames(input.source, input.fps, input.maxFrames);
-  if (framePlan.kind === "refused") {
-    deps.logger.warn("replay: run refused \u2014 empty window", { tags });
-    return { kind: "refused", reason: framePlan.reason };
+  if (nearest !== void 0 && Math.abs(nearest.t - t) <= halfStepMs) {
+    return entry(nearest, nearest.t, "exact");
   }
-  if (framePlan.truncated) {
-    deps.logger.warn("replay: frame plan truncated by maxFrames", {
-      tags,
-      meta: { maxFrames: input.maxFrames, planned: framePlan.instants.length }
-    });
+  if (t < track.firstSeen || t > track.lastSeen || nearest === void 0) return null;
+  if (prev !== void 0 && next !== void 0 && next.t - prev.t <= MAX_INTERPOLATION_GAP_MS) {
+    const f = next.t === prev.t ? 0 : (t - prev.t) / (next.t - prev.t);
+    return {
+      trackId: track.trackId,
+      className: track.className,
+      t,
+      box: {
+        x: lerp(prev.box.x, next.box.x, f),
+        y: lerp(prev.box.y, next.box.y, f),
+        w: lerp(prev.box.w, next.box.w, f),
+        h: lerp(prev.box.h, next.box.h, f)
+      },
+      score: prev.score !== null && next.score !== null ? lerp(prev.score, next.score, f) : null,
+      basis: "interpolated"
+    };
   }
-  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 entry(nearest, t, "uncertain");
+}
+function referenceAt(tracks, t, halfStepMs) {
+  const entries = [];
+  let live = false;
+  for (const track of tracks) {
+    if (t >= track.firstSeen && t <= track.lastSeen) live = true;
+    const e = trackAt(track, t, halfStepMs);
+    if (e !== null) {
+      entries.push(e);
+      live = true;
+    }
+  }
+  return { live, entries };
+}
+function sameClass(a, b) {
+  return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+function barFor(basis, iouMin) {
+  if (basis === "exact") return iouMin;
+  if (basis === "interpolated") return Math.min(iouMin, RELAXED_IOU_MIN);
+  return 0;
+}
+function pairUp(replay, stored, accept, bar) {
+  const candidates = [];
+  replay.forEach((r, ri) => {
+    stored.forEach((s, si) => {
+      if (!accept(r, s)) return;
+      const v = iou(r.box, s.box);
+      if (v >= bar(s)) candidates.push({ r: ri, s: si, iou: v });
     });
-    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 = (first - sourceFetch.startMs) / 1e3;
-  const durationSec = Math.max(1 / input.fps, (last - first) / 1e3 + 1 / input.fps);
-  const args = buildReplaySequenceArgs({
-    startSec,
-    durationSec,
-    fps: input.fps,
-    maxWidth: input.maxWidth
   });
-  const mjpeg = await deps.decoder.decodeSequence(args, sourceBytes);
-  const jpegFrames = splitMjpegStream(mjpeg);
-  const frames = [];
-  for (let i = 0; i < framePlan.instants.length; i++) {
-    const timestamp = framePlan.instants[i];
-    const image = jpegFrames[i];
-    if (timestamp === void 0 || image === void 0) continue;
-    frames.push({ timestamp, image });
-  }
-  if (frames.length < framePlan.instants.length) {
-    deps.logger.warn("replay: decode produced fewer frames than planned", {
-      tags,
-      meta: { planned: framePlan.instants.length, decoded: frames.length }
+  const ranked = candidates.toSorted((a, b) => b.iou - a.iou);
+  const usedR = /* @__PURE__ */ new Set();
+  const usedS = /* @__PURE__ */ new Set();
+  const pairs = [];
+  for (const c of ranked) {
+    if (usedR.has(c.r) || usedS.has(c.s)) continue;
+    const r = replay[c.r];
+    const s = stored[c.s];
+    if (r === void 0 || s === void 0) continue;
+    usedR.add(c.r);
+    usedS.add(c.s);
+    pairs.push({
+      replay: r,
+      stored: s,
+      iou: c.iou,
+      scoreDelta: s.score === null ? null : r.score - s.score
     });
   }
-  const verdict = await runReplay(
-    {
-      deviceId: input.deviceId,
-      nodeId: input.nodeId,
-      runPipeline: async (call) => deps.api.pipelineExecutor.runPipeline.mutate({
-        nodeId: call.nodeId,
-        steps: [...plan.steps],
-        // Copy into a fresh `Uint8Array<ArrayBuffer>` — `mjpeg-split.ts`
-        // hands back a `Buffer` view (`Uint8Array<ArrayBufferLike>`), and
-        // the generated cap input is typed against the narrower
-        // `ArrayBuffer` backing.
-        image: new Uint8Array(call.image),
-        deviceId: input.deviceId,
-        ...input.deviceKey !== void 0 ? { deviceKey: input.deviceKey } : {}
-      }),
-      // THE cross-addon call this whole track exists for: the FrameProcessor
-      // pass lives in `addon-post-analysis`, reached only through this cap
-      // method — see the file header.
-      runTracking: async (tracked) => deps.api.pipelineAnalytics.runReplayFrameProcessor.mutate({
-        deviceId: input.deviceId,
-        source: "pipeline",
-        frames: [...tracked]
-      }),
-      logger: deps.logger
-    },
-    frames
+  return {
+    pairs,
+    restReplay: replay.filter((_r, i) => !usedR.has(i)),
+    restStored: stored.filter((_s, i) => !usedS.has(i))
+  };
+}
+function compareFrame(t, replay, reference, iouMin = MATCH_IOU_MIN) {
+  const same = pairUp(
+    replay,
+    reference.entries,
+    (r, s) => sameClass(r.className, s.className),
+    (s) => barFor(s.basis, iouMin)
+  );
+  const changed = pairUp(
+    same.restReplay,
+    same.restStored,
+    (_r, s) => s.basis !== "uncertain",
+    (s) => barFor(s.basis, iouMin)
   );
-  const now = deps.now ?? Date.now;
-  const newId = deps.newId ?? (() => `replay-${now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
-  const replayRunId = newId();
-  const record2 = {
-    id: replayRunId,
-    deviceId: input.deviceId,
-    nodeId: input.nodeId,
-    clipId: clipIdOf(input.source),
-    createdAtMs: now(),
-    source: input.source,
-    plan,
-    verdict
-  };
-  await deps.store.save(record2);
-  return { kind: "ran", replayRunId, verdict };
+  return {
+    t,
+    referenced: reference.live,
+    matched: same.pairs,
+    classChanged: changed.pairs,
+    added: reference.live ? changed.restReplay : [],
+    unreferenced: reference.live ? [] : changed.restReplay,
+    missed: changed.restStored
+  };
+}
+function percentile(sorted, q) {
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(q * sorted.length) - 1));
+  return sorted[idx] ?? 0;
+}
+function summarizeReplay(frames, inferenceMs) {
+  const perClass = /* @__PURE__ */ new Map();
+  const bump = (cls, field) => {
+    const key = cls.trim().toLowerCase();
+    const e = perClass.get(key) ?? {
+      replay: 0,
+      stored: 0,
+      matched: 0,
+      added: 0,
+      missed: 0,
+      unreferenced: 0,
+      interpolated: 0
+    };
+    e[field] += 1;
+    perClass.set(key, e);
+  };
+  const deltas = [];
+  let matched = 0;
+  let classChanged = 0;
+  let added = 0;
+  let missed = 0;
+  let unreferenced = 0;
+  let interpolated = 0;
+  const noteBasis = (s) => {
+    if (s.basis === "exact") return;
+    interpolated += 1;
+    bump(s.className, "interpolated");
+  };
+  for (const f of frames) {
+    for (const p of f.matched) {
+      matched += 1;
+      bump(p.replay.className, "replay");
+      bump(p.stored.className, "stored");
+      bump(p.replay.className, "matched");
+      noteBasis(p.stored);
+      if (p.scoreDelta !== null) deltas.push(p.scoreDelta);
+    }
+    for (const p of f.classChanged) {
+      classChanged += 1;
+      bump(p.replay.className, "replay");
+      bump(p.stored.className, "stored");
+      noteBasis(p.stored);
+    }
+    for (const r of f.added) {
+      added += 1;
+      bump(r.className, "replay");
+      bump(r.className, "added");
+    }
+    for (const r of f.unreferenced) {
+      unreferenced += 1;
+      bump(r.className, "replay");
+      bump(r.className, "unreferenced");
+    }
+    for (const s of f.missed) {
+      missed += 1;
+      bump(s.className, "stored");
+      bump(s.className, "missed");
+      noteBasis(s);
+    }
+  }
+  const sortedDeltas = deltas.toSorted((a, b) => a - b);
+  const sortedInfer = [...inferenceMs].toSorted((a, b) => a - b);
+  return {
+    totals: { matched, classChanged, added, missed, unreferenced, interpolated },
+    perClass: Object.fromEntries(
+      [...perClass.entries()].toSorted(([a], [b]) => a.localeCompare(b))
+    ),
+    scoreDelta: sortedDeltas.length === 0 ? null : {
+      mean: sortedDeltas.reduce((s, v) => s + v, 0) / sortedDeltas.length,
+      p10: percentile(sortedDeltas, 0.1),
+      p50: percentile(sortedDeltas, 0.5),
+      p90: percentile(sortedDeltas, 0.9)
+    },
+    inferenceMs: sortedInfer.length === 0 ? null : {
+      p50: percentile(sortedInfer, 0.5),
+      p95: percentile(sortedInfer, 0.95),
+      count: sortedInfer.length
+    }
+  };
 }
 
-// src/replay/replay-diff.ts
-function iou(a, b) {
-  const x1 = Math.max(a.x, b.x);
-  const y1 = Math.max(a.y, b.y);
-  const x2 = Math.min(a.x + a.w, b.x + b.w);
-  const y2 = Math.min(a.y + a.h, b.y + b.h);
-  const interW = Math.max(0, x2 - x1);
-  const interH = Math.max(0, y2 - y1);
-  const inter = interW * interH;
-  if (inter <= 0) return 0;
-  const union2 = a.w * a.h + b.w * b.h - inter;
-  return union2 <= 0 ? 0 : inter / union2;
-}
-function windowsOverlap(a, b) {
-  return a.firstSeenMs <= b.lastSeenMs && b.firstSeenMs <= a.lastSeenMs;
-}
-var TRACK_PAIR_MIN_IOU = 0.3;
-function diffTracks(a, b) {
-  const bMatched = /* @__PURE__ */ new Set();
-  const lost = [];
-  for (const ta of a) {
-    let bestIdx = -1;
-    let bestIou = 0;
-    for (let i = 0; i < b.length; i++) {
-      if (bMatched.has(i)) continue;
-      const tb = b[i];
-      if (tb === void 0 || tb.className !== ta.className) continue;
-      if (!windowsOverlap(ta, tb)) continue;
-      const score = iou(ta.bbox, tb.bbox);
-      if (score >= TRACK_PAIR_MIN_IOU && score > bestIou) {
-        bestIou = score;
-        bestIdx = i;
-      }
-    }
-    if (bestIdx === -1) lost.push(ta);
-    else bMatched.add(bestIdx);
-  }
-  const gained = b.filter((_, i) => !bMatched.has(i));
-  return { gained, lost };
-}
-function diffKnobs(a, b) {
-  const stepIds = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
-  const changed = [];
-  for (const stepId of stepIds) {
-    const aStep = a[stepId] ?? {};
-    const bStep = b[stepId] ?? {};
-    const keys = /* @__PURE__ */ new Set([...Object.keys(aStep), ...Object.keys(bStep)]);
-    for (const key of keys) {
-      const from = aStep[key];
-      const to = bStep[key];
-      if (from !== to) changed.push({ stepId, key, from, to });
-    }
-  }
-  return changed;
-}
-function diffPromoted(discardedA, tracksB) {
-  const promoted = [];
-  for (const d of discardedA) {
-    const nowTracked = tracksB.some((t) => t.className === d.macroClass);
-    if (nowTracked)
-      promoted.push({ macroClass: d.macroClass, score: d.score, wasDiscardedBy: d.reason });
-  }
-  return promoted;
-}
-function diffReplayRuns(a, b) {
-  if (a.clipId !== b.clipId) return { kind: "incomparable", reason: "different-input" };
-  if (a.nodeId !== b.nodeId) return { kind: "incomparable", reason: "different-node" };
-  return {
-    kind: "compared",
-    changedKnobs: diffKnobs(a.settings, b.settings),
-    tracks: diffTracks(a.tracks, b.tracks),
-    promoted: diffPromoted(a.discarded, b.tracks)
+// src/session-replay/frame-plan.ts
+var REPLAY_CHUNK_MS = 1e4;
+function planReplayFrames(window, fps, maxFrames, chunkMs = REPLAY_CHUNK_MS) {
+  const stepMs = 1e3 / fps;
+  const instants = [];
+  let truncated = false;
+  for (let k = 0; ; k++) {
+    const t = window.startMs + Math.round(k * stepMs);
+    if (t >= window.endMs) break;
+    if (instants.length >= maxFrames) {
+      truncated = true;
+      break;
+    }
+    instants.push(t);
+  }
+  const chunks = [];
+  let current = [];
+  let chunkStart = window.startMs;
+  const flush = (toMs) => {
+    if (current.length > 0) chunks.push({ fromMs: chunkStart, toMs, instants: current });
+    current = [];
   };
+  for (const t of instants) {
+    while (t >= chunkStart + chunkMs) {
+      flush(chunkStart + chunkMs);
+      chunkStart += chunkMs;
+    }
+    current.push(t);
+  }
+  const last = instants[instants.length - 1];
+  flush(
+    truncated && last !== void 0 ? last + Math.round(stepMs) : Math.min(window.endMs, chunkStart + chunkMs)
+  );
+  return { chunks, planned: instants.length, truncated };
 }
 
-// src/throughput/sustained-runner.ts
-async function runSustainedLoop(opts) {
-  const concurrency = Math.max(1, Math.floor(opts.concurrency));
-  const start = opts.now();
-  const deadline = start + Math.max(0, opts.durationMs);
-  const callMsList = [];
-  let totalFrames = 0;
-  let totalBatches = 0;
-  let totalDetections = 0;
-  let detectionSamples = 0;
-  let errors = 0;
-  const worker = async () => {
-    while (!opts.shouldStop() && opts.now() < deadline) {
-      const t0 = opts.now();
-      try {
-        const out = await opts.dispatchBatch();
-        const t1 = opts.now();
-        callMsList.push(t1 - t0);
-        totalBatches += 1;
-        totalFrames += out.frameCount;
-        for (const c of out.detectionCounts) {
-          totalDetections += c;
-          detectionSamples += 1;
-        }
-      } catch {
-        errors += 1;
-      }
+// src/session-replay/replay-steps.ts
+var REPLAY_ROOT_STEP = "object-detection";
+function selectRootReplayStep(tree, requestedModelId) {
+  const root = tree.steps.find((s) => s.addonId === REPLAY_ROOT_STEP);
+  if (root === void 0 || !root.enabled) {
+    return {
+      kind: "refused",
+      reason: "no-root-step",
+      detail: `the camera does not run ${REPLAY_ROOT_STEP} as an enabled root step`
+    };
+  }
+  const cameraModelId = root.modelId ?? null;
+  const modelId = requestedModelId ?? cameraModelId;
+  if (modelId === null || modelId.length === 0) {
+    return {
+      kind: "refused",
+      reason: "model-unpinned",
+      detail: `the camera's ${REPLAY_ROOT_STEP} names no model (it runs the node's format default); pick the model to replay explicitly`
+    };
+  }
+  return {
+    kind: "ok",
+    cameraModelId,
+    step: {
+      addonId: root.addonId,
+      modelId,
+      enabled: true,
+      ...root.settings !== void 0 ? { settings: root.settings } : {},
+      children: []
     }
   };
-  await Promise.all(Array.from({ length: concurrency }, () => worker()));
-  const wallMs = opts.now() - start;
+}
+
+// src/session-replay/session-window.ts
+var SESSION_PREROLL_MS = 5e3;
+var SESSION_TAIL_MS = 3e4;
+var SESSION_MAX_WINDOW_MS = 10 * 6e4;
+function motionSessionWindow(session, camera = {}, opts = {}) {
+  if (session.durationMs === null) {
+    return {
+      kind: "refused",
+      reason: "session-open",
+      detail: `motion session ${session.id} is still open \u2014 its end is not known yet`
+    };
+  }
+  if (session.durationMs === void 0) {
+    return {
+      kind: "refused",
+      reason: "session-length-unknown",
+      detail: `motion session ${session.id} predates the episode duration column \u2014 its length is unknown`
+    };
+  }
+  const motionEndMs = session.timestamp + session.durationMs;
+  const prerollSource = camera.preRollInferenceEnabled === false ? "camera" : "default";
+  const prerollMs = camera.preRollInferenceEnabled === false ? 0 : SESSION_PREROLL_MS;
+  const tailSource = camera.motionCooldownMs !== void 0 ? "camera" : "default";
+  const tailMs = camera.motionCooldownMs ?? SESSION_TAIL_MS;
+  const startMs = session.timestamp - prerollMs;
+  const endMs = motionEndMs + tailMs;
+  const maxWindowMs = opts.maxWindowMs ?? SESSION_MAX_WINDOW_MS;
+  if (endMs - startMs > maxWindowMs) {
+    return {
+      kind: "refused",
+      reason: "window-too-long",
+      detail: `motion session ${session.id} spans ${Math.round((endMs - startMs) / 1e3)} s \u2014 longer than the ${Math.round(maxWindowMs / 1e3)} s a replay reads`
+    };
+  }
   return {
-    callMsList,
-    totalFrames,
-    totalBatches,
-    totalDetections,
-    detectionSamples,
-    errors,
-    wallMs,
-    aborted: opts.shouldStop()
+    kind: "window",
+    motionEventId: session.id,
+    motionStartMs: session.timestamp,
+    motionEndMs,
+    startMs,
+    endMs,
+    prerollSource,
+    tailSource
   };
 }
 
-// src/throughput/throughput-stats.ts
-var EMPTY_LATENCY = { p50: 0, p95: 0, p99: 0, mean: 0, min: 0, max: 0 };
-function percentile(sortedAsc, p) {
-  const n = sortedAsc.length;
-  if (n === 0) return 0;
-  const clamped = p < 0 ? 0 : p > 1 ? 1 : p;
-  if (clamped <= 0) return sortedAsc[0] ?? 0;
-  if (clamped >= 1) return sortedAsc[n - 1] ?? 0;
-  const rank = Math.ceil(clamped * n);
-  const idx = Math.min(n - 1, Math.max(0, rank - 1));
-  return sortedAsc[idx] ?? 0;
-}
-function computeLatencyStats(samplesMs) {
-  if (samplesMs.length === 0) return EMPTY_LATENCY;
-  const sorted = [...samplesMs].sort((a, b) => a - b);
-  const sum = sorted.reduce((acc, x) => acc + x, 0);
+// src/session-replay/stored-reference.ts
+var UNKNOWN_MODEL = "unknown";
+function buildStoredReference(tracks, window) {
+  const refs = [];
+  const models = /* @__PURE__ */ new Map();
+  const sizes = /* @__PURE__ */ new Map();
+  const timesByTrack = [];
+  let recoveryExcluded = 0;
+  let withoutGeometry = 0;
+  let trackCount = 0;
+  for (const track of tracks) {
+    const inWindow = track.positions.filter(
+      (p) => p.timestamp >= window.startMs && p.timestamp < window.endMs
+    );
+    const aliveInWindow = track.firstSeen < window.endMs && track.lastSeen >= window.startMs;
+    if (inWindow.length === 0 && !aliveInWindow) continue;
+    trackCount += 1;
+    const model = track.modelId ?? UNKNOWN_MODEL;
+    models.set(model, (models.get(model) ?? 0) + 1);
+    const fw = track.frameWidth;
+    const fh = track.frameHeight;
+    const hasGeometry = fw !== void 0 && fh !== void 0 && fw > 0 && fh > 0;
+    if (hasGeometry) {
+      const key = `${fw}x${fh}`;
+      const entry2 = sizes.get(key) ?? { width: fw, height: fh, count: 0 };
+      entry2.count += 1;
+      sizes.set(key, entry2);
+    }
+    const times = [];
+    const positions = [];
+    for (const p of inWindow) {
+      if (p.source === "recovery") {
+        recoveryExcluded += 1;
+        continue;
+      }
+      times.push(p.timestamp);
+      if (!hasGeometry) {
+        withoutGeometry += 1;
+        continue;
+      }
+      positions.push({
+        trackId: track.trackId,
+        className: track.className,
+        t: p.timestamp,
+        box: { x: p.bbox.x / fw, y: p.bbox.y / fh, w: p.bbox.w / fw, h: p.bbox.h / fh },
+        score: p.score ?? null
+      });
+    }
+    timesByTrack.push(times.toSorted((a, b) => a - b));
+    if (hasGeometry) {
+      const sorted = positions.toSorted((a, b) => a.t - b.t);
+      refs.push({
+        trackId: track.trackId,
+        className: track.className,
+        firstSeen: Math.min(track.firstSeen, sorted[0]?.t ?? track.firstSeen),
+        lastSeen: Math.max(track.lastSeen, sorted[sorted.length - 1]?.t ?? track.lastSeen),
+        positions: sorted
+      });
+    }
+  }
+  const commonest = [...sizes.values()].toSorted((a, b) => b.count - a.count)[0];
   return {
-    p50: percentile(sorted, 0.5),
-    p95: percentile(sorted, 0.95),
-    p99: percentile(sorted, 0.99),
-    mean: sum / sorted.length,
-    min: sorted[0] ?? 0,
-    max: sorted[sorted.length - 1] ?? 0
+    tracks: refs,
+    trackCount,
+    recoveryExcluded,
+    withoutGeometry,
+    models: Object.fromEntries(models),
+    frameSize: commonest ? { width: commonest.width, height: commonest.height } : null,
+    positionTimesByTrack: timesByTrack
   };
 }
-function computeFps(totalFrames, wallMs) {
-  if (wallMs <= 0) return 0;
-  return totalFrames * 1e3 / wallMs;
+
+// src/session-replay/run-session-replay.ts
+var TRACK_LOOKBACK_MS = 12e4;
+var DEFAULT_REPLAY_WIDTH = 1280;
+var SUPPRESSED_BIRTH_PROXIMITY_MS = 2e3;
+var MAX_REPORTED_FAILURES = 20;
+var MAX_CONSECUTIVE_FAILURES = 10;
+var STORED_TRACKS_READ_LIMIT = 1e3;
+var REAL_PACE = {
+  now: () => Date.now(),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+var PIN_REFUSALS = ["model-not-servable", "device-not-servable"];
+function pinRefusalOf(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  for (const reason of PIN_REFUSALS) {
+    if (message.includes(`${reason}:`)) return { reason, detail: message };
+  }
+  return null;
+}
+function toReplayBoxes(frame) {
+  const w = frame.width;
+  const h = frame.height;
+  if (!(w > 0 && h > 0)) return [];
+  return frame.detections.filter((d) => d.kind === "first-level").map((d) => ({
+    className: d.macroClass,
+    score: d.score,
+    box: { x: d.bbox.x / w, y: d.bbox.y / h, w: d.bbox.width / w, h: d.bbox.height / h }
+  }));
 }
-function computeDetsPerSec(totalDetections, wallMs) {
-  if (wallMs <= 0) return 0;
-  return totalDetections * 1e3 / wallMs;
+function sameClass2(a, b) {
+  return a.trim().toLowerCase() === b.trim().toLowerCase();
 }
-function computeAvgDetections(totalDetections, sampledFrames) {
-  if (sampledFrames <= 0) return 0;
-  return totalDetections / sampledFrames;
+async function runSessionReplay(deps, request, run) {
+  const tags = { deviceId: request.deviceId };
+  const refuse = (reason, detail) => {
+    deps.logger.warn("session replay refused", {
+      tags,
+      meta: { reason, detail, motionEventId: request.motionEventId, nodeId: request.nodeId }
+    });
+    return { kind: "refused", reason, detail };
+  };
+  run.report({ phase: "preparing", framesPlanned: 0, framesDone: 0 });
+  const session = await deps.findMotionSession(
+    request.deviceId,
+    request.motionEventId,
+    request.motionStartMs
+  );
+  if (session === null) {
+    return refuse(
+      "session-not-found",
+      `no stored motion session ${request.motionEventId} for camera ${request.deviceId}`
+    );
+  }
+  const window = motionSessionWindow(session, await deps.cameraSessionSettings(request.deviceId));
+  if (window.kind === "refused") return refuse(window.reason, window.detail);
+  const tree = await deps.resolveCameraTree(request.deviceId, request.nodeId);
+  const selection = selectRootReplayStep(tree, request.modelId);
+  if (selection.kind === "refused") return refuse(selection.reason, selection.detail);
+  const step = selection.step;
+  const modelId = step.modelId ?? "";
+  const validation = await deps.validate([step], request.nodeId, request.deviceKey);
+  const pool = `${request.nodeId}/${request.deviceKey ?? "node default"}`;
+  if (!validation.ok) {
+    return refuse(
+      "device-not-servable",
+      `${pool} cannot run ${step.addonId}: ${validation.issues.map((i) => i.detail).join("; ")}`
+    );
+  }
+  const substitution = validation.substitutions[0];
+  if (substitution !== void 0) {
+    return refuse(
+      "model-not-servable",
+      `${pool} would run ${substitution.running} instead of ${substitution.chosen} (${substitution.format})`
+    );
+  }
+  if (!await deps.isRecording(request.deviceId)) {
+    return refuse("no-recording", `camera ${request.deviceId} does not have recording enabled`);
+  }
+  const [tracks, births] = await Promise.all([
+    deps.listStoredTracks(request.deviceId, window.startMs - TRACK_LOOKBACK_MS, window.endMs),
+    deps.listBirthDecisions(request.deviceId, window.startMs)
+  ]);
+  const reference = buildStoredReference(tracks, window);
+  const readTruncated = tracks.length >= STORED_TRACKS_READ_LIMIT;
+  if (readTruncated) {
+    deps.logger.warn(
+      "session replay: stored-track read hit its limit \u2014 the reference may be incomplete",
+      {
+        tags,
+        meta: { limit: STORED_TRACKS_READ_LIMIT, motionEventId: request.motionEventId }
+      }
+    );
+  }
+  const cadence = resolveReplayCadence(request.fps, reference.positionTimesByTrack);
+  const frameSize = reference.frameSize !== null ? { width: reference.frameSize.width, source: "stored-tracks" } : { width: DEFAULT_REPLAY_WIDTH, source: "default" };
+  const windowBirths = births.filter((b) => b.at >= window.startMs && b.at < window.endMs);
+  const suppressedBirths = windowBirths.filter((b) => b.verdict === "suppressed");
+  const liveVerdicts = {};
+  for (const b of windowBirths) liveVerdicts[b.verdict] = (liveVerdicts[b.verdict] ?? 0) + 1;
+  const plan = planReplayFrames(window, cadence.fps, request.maxFrames);
+  if (plan.truncated) {
+    deps.logger.warn("session replay: frame plan truncated by maxFrames", {
+      tags,
+      meta: { maxFrames: request.maxFrames, motionEventId: request.motionEventId }
+    });
+  }
+  const stepMs = 1e3 / cadence.fps;
+  const halfStepMs = stepMs / 2;
+  const timeline = [];
+  const comparisons = [];
+  const inferenceMs = [];
+  const failures = [];
+  let decoded = 0;
+  let ran = 0;
+  let failed = 0;
+  let consecutiveFailures = 0;
+  let lastCallAt = null;
+  const pace = deps.pace ?? REAL_PACE;
+  let withoutFootage = 0;
+  let notDecoded = 0;
+  let truncatedBySafetyCap = false;
+  let nearSuppressedBirth = 0;
+  let positionsCompared = 0;
+  let partsRead = 0;
+  const progress = () => run.report({ phase: "replaying", framesPlanned: plan.planned, framesDone: ran + failed });
+  progress();
+  for (const chunk of plan.chunks) {
+    if (run.signal.aborted) break;
+    const recording = await deps.readRecording(request.deviceId, chunk.instants, stepMs);
+    if (recording.kind === "refused") {
+      withoutFootage += chunk.instants.length;
+      deps.logger.warn("session replay: no footage for a stretch of the session", {
+        tags,
+        meta: { fromMs: chunk.fromMs, toMs: chunk.toMs, detail: recording.detail }
+      });
+      continue;
+    }
+    withoutFootage += recording.instantsWithoutFootage;
+    partsRead += recording.parts.length;
+    if (recording.truncatedBySafetyCap) truncatedBySafetyCap = true;
+    for (const part of recording.parts) {
+      if (run.signal.aborted) break;
+      const first = part.instants[0];
+      if (first === void 0) continue;
+      const frames = await deps.decode(part.bytes, {
+        startSec: (first - part.gopStartMs) / 1e3,
+        durationSec: part.instants.length / cadence.fps,
+        fps: cadence.fps,
+        maxWidth: frameSize.width
+      });
+      decoded += Math.min(frames.length, part.instants.length);
+      if (frames.length < part.instants.length) {
+        notDecoded += part.instants.length - frames.length;
+        deps.logger.warn("session replay: decode produced fewer frames than planned", {
+          tags,
+          meta: { planned: part.instants.length, decoded: frames.length, fromMs: first }
+        });
+      }
+      for (let k = 0; k < part.instants.length; k++) {
+        if (run.signal.aborted) break;
+        const t = part.instants[k];
+        const image = frames[k];
+        if (t === void 0 || image === void 0) break;
+        if (lastCallAt !== null) {
+          const wait = lastCallAt + stepMs - pace.now();
+          if (wait > 0) await pace.sleep(wait);
+        }
+        lastCallAt = pace.now();
+        let result;
+        try {
+          result = await deps.runRootDetector({
+            nodeId: request.nodeId,
+            ...request.deviceKey !== void 0 ? { deviceKey: request.deviceKey } : {},
+            steps: [step],
+            image,
+            deviceId: request.deviceId,
+            t
+          });
+        } catch (err) {
+          const pinRefusal = pinRefusalOf(err);
+          if (pinRefusal !== null) return refuse(pinRefusal.reason, pinRefusal.detail);
+          failed += 1;
+          consecutiveFailures += 1;
+          const error51 = err instanceof Error ? err.message : String(err);
+          if (failures.length < MAX_REPORTED_FAILURES) failures.push({ t, error: error51 });
+          deps.logger.warn("session replay: frame failed \u2014 counted, the run continues", {
+            tags,
+            meta: { t, error: error51, consecutiveFailures }
+          });
+          if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+            return refuse(
+              "pool-failing",
+              `${pool} failed ${consecutiveFailures} frames in a row (last: ${error51}) \u2014 stopped rather than keep loading a live pool`
+            );
+          }
+          progress();
+          continue;
+        }
+        consecutiveFailures = 0;
+        if (result.rootModelId !== modelId) {
+          return refuse(
+            "model-not-servable",
+            result.rootModelId === void 0 ? `${pool} does not report the model it ran (an executor older than D646) \u2014 the pin cannot be verified` : `${pool} reported ${result.rootModelId} for a frame pinned to ${modelId}`
+          );
+        }
+        ran += 1;
+        const frameInferMs = result.debug?.totalInferenceMs;
+        if (frameInferMs !== void 0) inferenceMs.push(frameInferMs);
+        const replayBoxes = toReplayBoxes(result);
+        const instantRef = referenceAt(reference.tracks, t, halfStepMs);
+        positionsCompared += instantRef.entries.length;
+        const cmp = compareFrame(t, replayBoxes, instantRef);
+        comparisons.push(cmp);
+        for (const unmatched of [...cmp.added, ...cmp.unreferenced]) {
+          if (suppressedBirths.some(
+            (b) => sameClass2(b.className, unmatched.className) && Math.abs(b.at - t) <= SUPPRESSED_BIRTH_PROXIMITY_MS
+          )) {
+            nearSuppressedBirth += 1;
+          }
+        }
+        timeline.push({
+          t,
+          referenced: cmp.referenced,
+          inferenceMs: frameInferMs ?? null,
+          replay: [
+            ...cmp.matched.map((p) => ({ ...p.replay, outcome: "matched" })),
+            ...cmp.classChanged.map((p) => ({ ...p.replay, outcome: "class-changed" })),
+            ...cmp.added.map((r) => ({ ...r, outcome: "added" })),
+            ...cmp.unreferenced.map((r) => ({ ...r, outcome: "unreferenced" }))
+          ],
+          stored: [
+            ...cmp.matched.map((p) => ({ ...p.stored, outcome: "matched" })),
+            ...cmp.classChanged.map((p) => ({ ...p.stored, outcome: "class-changed" })),
+            ...cmp.missed.map((s) => ({ ...s, outcome: "missed" }))
+          ]
+        });
+        progress();
+      }
+    }
+  }
+  const aborted2 = run.signal.aborted;
+  if (partsRead === 0 && !aborted2) {
+    return refuse(
+      "no-footage",
+      `no recording covers any of the ${plan.planned} planned instants of motion session ${request.motionEventId}`
+    );
+  }
+  if (aborted2) {
+    deps.logger.info("session replay aborted \u2014 the report covers the frames that ran", {
+      tags,
+      meta: { ran, planned: plan.planned }
+    });
+  }
+  run.report({ phase: "done", framesPlanned: plan.planned, framesDone: ran + failed });
+  return {
+    kind: "ran",
+    report: {
+      deviceId: request.deviceId,
+      motionEventId: request.motionEventId,
+      window: {
+        startMs: window.startMs,
+        endMs: window.endMs,
+        motionStartMs: window.motionStartMs,
+        motionEndMs: window.motionEndMs,
+        prerollSource: window.prerollSource,
+        tailSource: window.tailSource
+      },
+      pin: {
+        nodeId: request.nodeId,
+        deviceKey: request.deviceKey ?? null,
+        modelId,
+        cameraModelId: selection.cameraModelId
+      },
+      rootStep: step,
+      cadence,
+      frameSize,
+      frames: {
+        planned: plan.planned,
+        decoded,
+        ran,
+        failed,
+        withoutFootage,
+        notDecoded,
+        truncated: plan.truncated,
+        truncatedBySafetyCap,
+        aborted: aborted2
+      },
+      reference: {
+        tracks: reference.trackCount,
+        positionsCompared,
+        recoveryExcluded: reference.recoveryExcluded,
+        withoutGeometry: reference.withoutGeometry,
+        models: reference.models,
+        read: { tracks: tracks.length, truncated: readTruncated }
+      },
+      confirmation: { liveVerdicts, nearSuppressedBirth },
+      summary: summarizeReplay(comparisons, inferenceMs),
+      timeline,
+      failures
+    }
+  };
+}
+
+// src/session-replay/camera-settings.ts
+var FieldSchema = external_exports.object({
+  key: external_exports.string().optional(),
+  value: external_exports.unknown().optional(),
+  fields: external_exports.array(external_exports.unknown()).optional(),
+  tabs: external_exports.array(external_exports.object({ fields: external_exports.array(external_exports.unknown()).optional() }).loose()).optional()
+}).loose();
+var FormSchema = external_exports.object({
+  sections: external_exports.array(external_exports.object({ fields: external_exports.array(external_exports.unknown()) }).loose())
+});
+function collect(fields, out) {
+  for (const raw of fields) {
+    const field = FieldSchema.safeParse(raw);
+    if (!field.success) continue;
+    if (field.data.key !== void 0 && "value" in field.data)
+      out.set(field.data.key, field.data.value);
+    if (field.data.fields !== void 0) collect(field.data.fields, out);
+    for (const tab of field.data.tabs ?? []) collect(tab.fields ?? [], out);
+  }
+}
+function readCameraSessionSettings(raw) {
+  const form = FormSchema.safeParse(raw);
+  if (!form.success) return {};
+  const values = /* @__PURE__ */ new Map();
+  for (const section of form.data.sections) collect(section.fields, values);
+  const cooldown = values.get("motionCooldownMs");
+  const preRoll = values.get("preRollInferenceEnabled");
+  return {
+    ...typeof cooldown === "number" && Number.isFinite(cooldown) && cooldown >= 0 ? { motionCooldownMs: cooldown } : {},
+    ...typeof preRoll === "boolean" ? { preRollInferenceEnabled: preRoll } : {}
+  };
 }
 
 // src/benchmark-addon.ts
 var KEY_BENCHMARK_HISTORY = "benchmarkHistory";
 var MAX_HISTORY_ENTRIES = 100;
 var EMPTY_HISTORY_JSON = "[]";
-var BENCH_RUN_TIMEOUT_MS = Math.max(
-  1e4,
-  Number(process.env["CAMSTACK_BENCH_RUN_TIMEOUT_MS"]) || 12e4
+var BENCH_RUN_TIMEOUT_MS = Math.min(
+  55e3,
+  Math.max(1e4, Number(process.env["CAMSTACK_BENCH_RUN_TIMEOUT_MS"]) || 55e3)
 );
+var REPLAY_RECORDING_PROFILE = "high";
+var REPLAY_BIRTHS_LIMIT = 1e3;
+var REPLAY_DECODE_TIMEOUT_FLOOR_MS = 15e3;
+var REPLAY_DECODE_TIMEOUT_PER_SEC_MS = 3e3;
+var MOTION_SESSIONS_DEFAULT_SPAN_MS = 24 * 60 * 60 * 1e3;
 async function withHardTimeout(promise2, ms, label) {
   let timer;
   const timeout = new Promise((_resolve, reject) => {
@@ -15914,60 +15991,35 @@ async function withHardTimeout(promise2, ms, label) {
   }
 }
 var HistoryArraySchema = external_exports.array(HistoryEntrySchema);
-var FIXTURE_META = {
-  "camera-sim-360p.h264": {
-    codec: "h264",
-    resolutionLabel: "360p",
-    description: "Synthetic 360p H.264 \u2014 light workload"
-  },
-  "camera-sim-1080p.h264": {
-    codec: "h264",
-    resolutionLabel: "1080p",
-    description: "Synthetic 1080p H.264 \u2014 production-like"
-  },
-  "camera-sim-1440p-h265.hevc": {
-    codec: "h265",
-    resolutionLabel: "1440p",
-    description: "Synthetic 1440p H.265 \u2014 hardware decode stress"
-  }
-};
-function resolveFixturesDir() {
-  const here = fileURLToPath(import.meta.url);
-  const pkgRoot = path2.resolve(path2.dirname(here), "..");
-  return path2.join(pkgRoot, "assets", "fixtures");
-}
-var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
+var BenchmarkAddon = class extends BaseAddon {
   id = "benchmark";
-  /** Per-sessionId abort flags for in-flight decoder perf runs. */
-  decoderPerfAbortFlags = /* @__PURE__ */ new Map();
-  /** Per-sessionId abort flags for in-flight sustained-throughput runs. */
-  sustainedAbortFlags = /* @__PURE__ */ new Map();
-  /**
-   * In-memory cache of original JPEG bytes keyed by `frameId`. Populated by
-   * `cacheBenchFrame` (UI uploads JPEG once at bench start). Subsequent
-   * `runPipelineTest` calls ship only `frameId` — bench addon forwards the
-   * cached JPEG buffer as `image: Uint8Array` to pipelineExecutor.runPipeline
-   * (Moleculer MsgPack ships binary efficiently). Why JPEG and not raw RGB:
-   * cross-process MsgPack of a 2.7MB raw RGB frame (1280×720×3) is 13×
-   * heavier than the 200KB JPEG, and the pipeline addon's per-call sharp
-   * decode (~5ms) is cheaper than serialising the raw buffer twice.
-   * Production's broker→detection path is in-process (same group) so neither
-   * cost matters there.
-   */
-  frameCache = /* @__PURE__ */ new Map();
-  /** Periodic GC handle — clears expired frames every 60s. */
-  frameCacheSweeper = null;
-  /** The replay run collection — declared in `onInitialize`, before any
-   *  `runReplayClip` call can save into it. See `replay/replay-store.ts`. */
   replayStore = null;
-  /** The replay's one ffmpeg spawn, bounded — see `replay/replay-decode.ts`. */
+  /** The replay's ffmpeg spawns — the PINNED binary (`ctx.deps.ensureFfmpeg`, D540). */
   replayDecoder = new ReplayDecoder({
-    ffmpegPath: process.env["FFMPEG_PATH"] ?? "ffmpeg"
+    resolveFfmpegPath: () => this.ctx.deps.ensureFfmpeg()
   });
-  /** `replay:<StoredReplayRun>` — an in-memory index would drift from the
-   *  store; this is a thin cache over `replayStore.list`, keyed for the
-   *  diff action's two-id lookup. */
-  replayRunCache = /* @__PURE__ */ new Map();
+  /**
+   * Session replays, start-then-poll (D646). One at a time — a replay drives
+   * one inference call after another on a node that also serves live
+   * cameras — and the last few finished runs kept for a late poll.
+   */
+  replays = new BackgroundRunRegistry(
+    {
+      maxConcurrent: 1,
+      keepFinished: 10,
+      onSettled: (status) => {
+        if (status.state === "failed") {
+          this.ctx.logger.warn("session replay failed", {
+            meta: { runId: status.runId, error: status.error }
+          });
+          return;
+        }
+        const outcome = status.result;
+        if (outcome === null || outcome.kind !== "ran") return;
+        void this.persistReplay(status.runId, outcome.report.pin.nodeId, outcome);
+      }
+    }
+  );
   pages = [
     {
       id: "benchmark",
@@ -15990,99 +16042,50 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
     };
     await ReplayStore.declare(this.api.settingsStore);
     this.replayStore = new ReplayStore(this.api.settingsStore);
+    await this.pruneReplays();
     return {
       providers: [{ capability: addonPagesSourceCapability, provider }],
       customActions: benchmarkActions,
       actionHandlers: {
         runPipelineTest: async (input) => this.runPipelineTest(input),
-        runPipelineBatchTest: async (input) => this.runPipelineBatchTest(input),
-        runMultiCameraStressTest: async (input) => this.runMultiCameraStressTest(input),
-        runSustainedThroughput: async (input) => this.runSustainedThroughput(input),
-        abortSustainedThroughput: async (input) => this.abortSustainedThroughput(input),
-        cacheBenchFrame: async (input) => this.cacheBenchFrame(input),
-        releaseBenchFrame: async (input) => this.releaseBenchFrame(input),
-        listBenchmarkHistory: async () => this.listBenchmarkHistory(),
+        listBenchmarkHistory: async () => this.loadHistory(),
         saveBenchmarkResult: async (input) => this.saveBenchmarkResult(input),
-        saveDecoderPerformanceResult: async (input) => this.saveDecoderPerformanceResult(input),
         deleteBenchmarkResult: async (input) => this.deleteBenchmarkResult(input),
         clearBenchmarkHistory: async () => this.clearBenchmarkHistory(),
-        listDecoderFixtures: async () => this.listDecoderFixtures(),
-        runDecoderPerformanceTest: async (input) => this.runDecoderPerformanceTest(input),
-        abortDecoderPerformanceTest: async (input) => this.abortDecoderPerformanceTest(input),
-        uploadReplayClip: async (input) => this.uploadReplayClip(input),
-        runReplayClip: async (input) => this.runReplayClip(input),
-        listReplayRuns: async (input) => this.listReplayRuns(input),
-        diffReplayRuns: async (input) => this.diffReplayRunsAction(input)
+        listMotionSessions: async (input) => this.listMotionSessions(input),
+        startSessionReplay: async (input) => this.startSessionReplay(input),
+        getSessionReplayStatus: async (input) => this.getSessionReplayStatus(input),
+        abortSessionReplay: async (input) => ({ aborted: this.replays.abort(input.runId) }),
+        listSessionReplays: async (input) => this.listSessionReplays(input),
+        getSessionReplay: async (input) => this.replayStore === null ? null : this.replayStore.get(input.id)
       }
     };
   }
   async onShutdown() {
-    if (this.frameCacheSweeper) {
-      clearInterval(this.frameCacheSweeper);
-      this.frameCacheSweeper = null;
-    }
-    this.frameCache.clear();
-    for (const flag of this.sustainedAbortFlags.values()) flag.aborted = true;
-    this.sustainedAbortFlags.clear();
-  }
-  // ── Frame cache (raw RGB) ────────────────────────────────────────────────
-  async cacheBenchFrame(input) {
-    const jpeg = Buffer.from(input.imageBase64, "base64");
-    const sharp = (await import("sharp")).default;
-    const meta3 = await sharp(jpeg).metadata();
-    const width = meta3.width ?? 0;
-    const height = meta3.height ?? 0;
-    if (width <= 0 || height <= 0) {
-      throw new Error("cacheBenchFrame: failed to probe JPEG dimensions");
-    }
-    const ttlMs = Math.max(6e4, (input.ttlSeconds ?? 600) * 1e3);
-    const frameId = `bench-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-    const expiresAt = Date.now() + ttlMs;
-    this.frameCache.set(frameId, { jpeg, width, height, expiresAt });
-    if (!this.frameCacheSweeper) {
-      this.frameCacheSweeper = setInterval(() => this.sweepFrameCache(), 6e4);
-      this.frameCacheSweeper.unref?.();
-    }
-    this.ctx.logger.info("cached bench frame", {
-      meta: { frameId, width, height, jpegBytes: jpeg.length, ttlMs }
-    });
-    return { frameId, width, height, expiresAt };
+    this.replays.abortAll();
   }
-  async releaseBenchFrame(input) {
-    return { released: this.frameCache.delete(input.frameId) };
-  }
-  sweepFrameCache() {
-    const now = Date.now();
-    for (const [id, entry] of this.frameCache) {
-      if (entry.expiresAt < now) this.frameCache.delete(id);
-    }
-  }
-  // ── Handler implementations ──────────────────────────────────────────────
   get api() {
     const api = this.ctx.api;
     if (!api) throw new Error("BenchmarkAddon: ctx.api not available");
     return api;
   }
+  // ── Detection Pipeline — one run ─────────────────────────────────────────
   async runPipelineTest(input) {
-    const { nodeId, steps, imageBase64, referenceImage, frameId, sessionId, engine } = input;
-    const { deviceKey, plane } = input;
+    const { nodeId, steps, imageBase64, referenceImage, sessionId, deviceKey, plane } = input;
     this.ctx.logger.debug("runPipelineTest payload", {
       meta: {
         nodeId: nodeId ?? null,
         deviceKey: deviceKey ?? null,
         plane: plane ?? null,
         sessionId: sessionId ?? null,
-        engine: engine ?? null,
         stepsCount: steps.length,
-        steps: steps.map((s) => `${s.addonId}/${s.modelId}${s.enabled ? "" : "[off]"}`),
-        imageSource: frameId ? `frame:${frameId}` : referenceImage ? `ref:${referenceImage}` : imageBase64 ? `base64:${Math.round(imageBase64.length / 1024)}KB` : "none"
+        steps: steps.map(
+          (s) => `${s.addonId}/${s.modelId ?? "(format default)"}${s.enabled ? "" : "[off]"}`
+        ),
+        imageSource: referenceImage ? `ref:${referenceImage}` : imageBase64 ? `base64:${Math.round(imageBase64.length / 1024)}KB` : "none"
       }
     });
-    const cached2 = frameId ? this.frameCache.get(frameId) : void 0;
-    if (frameId && !cached2)
-      throw new Error(`runPipelineTest: frameId ${frameId} not in cache (expired or never cached)`);
-    const cachedImage = cached2 ? new Uint8Array(cached2.jpeg) : void 0;
-    const image = cachedImage ?? (imageBase64 ? new Uint8Array(Buffer.from(imageBase64, "base64")) : void 0);
+    const image = imageBase64 ? new Uint8Array(Buffer.from(imageBase64, "base64")) : void 0;
     const stepsToRun = steps.length > 0 ? [...steps] : await (async () => {
       const globalSteps = await this.api.pipelineExecutor.getGlobalSteps.query({ nodeId });
       if (!globalSteps || globalSteps.length === 0) {
@@ -16101,10 +16104,8 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
         nodeId,
         steps: stepsToRun,
         ...image ? { image } : {},
-        ...!image && imageBase64 ? { imageBase64 } : {},
         referenceImage,
         sessionId,
-        ...engine ? { engine } : {},
         // Absent, never present-and-undefined: the generated router takes
         // `.loose()` input and an explicit `undefined` is not the same thing
         // as "the node's default pool" / "the cap's default plane".
@@ -16115,579 +16116,235 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
       "runPipelineTest"
     );
   }
-  // ── Replay ────────────────────────────────────────────────────────────
-  /**
-   * Storage location a replay upload lands on. `replayClips` is a NEW
-   * `StorageLocationType` (an open string, no schema change needed — see
-   * `storage-location.ts:19`) but it still needs an actual location
-   * REGISTERED for that type before `storage.write`/`.read` can resolve it
-   * (`storage.upsertLocation`, `cardinality: 'single'`, its own retention).
-   * That registration is an operator/boot-time provisioning step this
-   * change does not perform — see the report's open items.
-   */
-  static REPLAY_CLIPS_LOCATION = "replayClips";
-  async uploadReplayClip(input) {
-    const bytes = Buffer.from(input.dataBase64, "base64");
-    const clipId = `clip:${createHash("sha256").update(bytes).digest("hex").slice(0, 32)}`;
-    await this.api.storage.write.mutate({
-      location: _BenchmarkAddon.REPLAY_CLIPS_LOCATION,
-      relativePath: `${clipId}.bin`,
-      data: new Uint8Array(bytes)
+  // ── Session replay (D646) ─────────────────────────────────────────────────
+  async listMotionSessions(input) {
+    const untilMs = input.untilMs ?? Date.now();
+    const sinceMs = input.sinceMs ?? untilMs - MOTION_SESSIONS_DEFAULT_SPAN_MS;
+    const events = await this.api.pipelineAnalytics.getMotionEvents.query({
+      deviceId: input.deviceId,
+      since: sinceMs,
+      until: untilMs,
+      limit: input.limit,
+      projection: "full"
     });
-    this.ctx.logger.info("replay: clip uploaded", { meta: { clipId, bytes: bytes.length } });
-    return { clipId };
-  }
-  async runReplayClip(input) {
-    if (this.replayStore === null) throw new Error("replay: store not initialized");
-    const store = this.replayStore;
-    const source = input.source;
-    const result = await orchestrateReplayRun(
-      {
-        api: this.api,
-        logger: this.ctx.logger,
-        decoder: this.replayDecoder,
-        store,
-        ffmpegPath: process.env["FFMPEG_PATH"] ?? "ffmpeg",
-        resolveBaseTree: (deviceId) => this.api.pipelineOrchestrator.resolvePipeline.query({ deviceId }),
-        fetchSourceBytes: (src) => this.fetchReplaySourceBytes(src)
-      },
-      {
-        deviceId: input.deviceId,
-        nodeId: input.nodeId,
-        source,
-        overlay: input.overlay,
-        fps: input.fps,
-        maxFrames: input.maxFrames,
-        maxWidth: input.maxWidth,
-        ...input.deviceKey !== void 0 ? { deviceKey: input.deviceKey } : {}
-      }
+    const camera = await this.cameraSessionSettings(input.deviceId);
+    const windows = events.map((ev) => ({ ev, window: motionSessionWindow(ev, camera) }));
+    const starts = windows.map(
+      ({ ev, window }) => window.kind === "window" ? window.startMs : ev.timestamp
     );
-    if (result.kind === "ran")
-      this.replayRunCache.set(result.replayRunId, {
-        id: result.replayRunId,
-        deviceId: input.deviceId,
-        nodeId: input.nodeId,
-        clipId: source.kind === "upload" ? source.clipId : `recording:${source.deviceId}:${source.fromMs}`,
-        createdAtMs: Date.now(),
-        source,
-        plan: null,
-        verdict: result.verdict
-      });
-    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 `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") {
-      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.recordingArchive.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`
-      };
-    }
-    const located = await this.api.recordingArchive.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.recordingArchive.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 [];
-    const rows = await this.replayStore.list({ deviceId: input.deviceId });
-    for (const row of rows) this.replayRunCache.set(row.id, row);
-    return rows;
-  }
-  /** `verdict` round-trips through the store as opaque JSON
-   *  (`StoredReplayRun.verdict: unknown`) — this is the ONE narrowing back
-   *  to the shape `diffReplayRuns` needs, at the ONE place that reads it
-   *  for that purpose. Same documented boundary `ReplayStore.list` itself
-   *  crosses (`replay-store.ts`): this addon is the only reader that knows
-   *  what it wrote. */
-  static verdictTracksAndDiscarded(verdict) {
-    return verdict;
-  }
-  async diffReplayRunsAction(input) {
-    const a = this.replayRunCache.get(input.runIdA);
-    const b = this.replayRunCache.get(input.runIdB);
-    if (a === void 0 || b === void 0) {
-      throw new Error(
-        "replay: diff \u2014 one or both run ids are not loaded (call listReplayRuns first)"
-      );
-    }
-    return diffReplayRuns(
-      {
-        clipId: a.clipId,
-        nodeId: a.nodeId,
-        settings: {},
-        ..._BenchmarkAddon.verdictTracksAndDiscarded(a.verdict)
-      },
-      {
-        clipId: b.clipId,
-        nodeId: b.nodeId,
-        settings: {},
-        ..._BenchmarkAddon.verdictTracksAndDiscarded(b.verdict)
-      }
+    const ends = windows.map(
+      ({ ev, window }) => window.kind === "window" ? window.endMs : ev.timestamp
     );
-  }
-  /**
-   * Batched pipeline tester.
-   *
-   * Decodes the JPEG once via sharp into RGB24 at native dimensions,
-   * then ships N copies as `FrameInput[]` in a single
-   * `pipelineExecutor.runPipelineBatch` cap call. The Python pool
-   * collapses the N predicts into one `MSG_INFER_BATCH = 0x03` IPC
-   * frame — per-call header + JSON envelope cost is amortised N:1.
-   *
-   * Returns N `FrameResult`s plus aggregate timing so the UI can
-   * compute fps directly from the wall clock.
-   */
-  async runPipelineBatchTest(input) {
-    this.ctx.logger.debug("runPipelineBatchTest payload", {
-      meta: {
-        nodeId: input.nodeId ?? null,
-        sessionId: input.sessionId ?? null,
-        engine: input.engine ?? null,
-        batchSize: input.batchSize,
-        targetSize: input.targetSize ?? null,
-        stepsCount: input.steps.length,
-        steps: input.steps.map((s) => `${s.addonId}/${s.modelId}${s.enabled ? "" : "[off]"}`),
-        imageBytesKB: Math.round(input.imageBase64.length / 1024)
-      }
-    });
-    const { nodeId, steps, imageBase64, batchSize, sessionId, engine } = input;
-    const targetSize = input.targetSize ?? 640;
-    if (steps.length === 0) {
-      throw new Error("runPipelineBatchTest: empty steps");
-    }
-    const sharp = (await import("sharp")).default;
-    const jpeg = Buffer.from(imageBase64, "base64");
-    const rgb = await sharp(jpeg).resize({ width: targetSize, height: targetSize, fit: "fill" }).raw().toColorspace("srgb").toBuffer();
-    const rgbBytes = new Uint8Array(rgb.buffer, rgb.byteOffset, rgb.byteLength);
-    this.ctx.logger.debug("runPipelineBatchTest dispatch", {
-      meta: {
-        phase: "batch",
-        batchSize,
-        targetSize,
-        rgbBytes: rgb.byteLength,
-        totalBytes: rgb.byteLength * batchSize
-      }
+    const tracks = events.length === 0 ? [] : await this.api.pipelineAnalytics.listTracks.query({
+      deviceId: input.deviceId,
+      since: Math.min(...starts),
+      until: Math.max(...ends),
+      projection: "slim",
+      excludeSources: ["sensor", "audio"],
+      limit: STORED_TRACKS_READ_LIMIT
     });
-    const frames = Array.from({ length: batchSize }, () => ({
-      data: rgbBytes,
-      format: "rgb",
-      width: targetSize,
-      height: targetSize,
-      timestamp: Date.now()
+    return windows.map(({ ev, window }) => ({
+      motionEventId: ev.id,
+      deviceId: ev.deviceId,
+      startMs: ev.timestamp,
+      durationMs: ev.durationMs ?? null,
+      open: ev.durationMs === null,
+      refusal: window.kind === "refused" ? window.reason : null,
+      storedTracks: window.kind === "window" ? tracks.filter((t) => t.firstSeen >= window.startMs && t.firstSeen < window.endMs).length : 0
     }));
-    const callStart = Date.now();
-    const out = await withHardTimeout(
-      this.api.pipelineExecutor.runPipelineBatch.mutate({
-        nodeId,
-        steps: [...steps],
-        frames,
-        sessionId,
-        ...engine ? { engine } : {}
-      }),
-      BENCH_RUN_TIMEOUT_MS,
-      "runPipelineBatchTest"
-    );
-    const callMs = Date.now() - callStart;
-    const inferMs = out.results.reduce((acc, r) => Math.max(acc, r.debug?.totalInferenceMs ?? 0), 0);
-    return {
-      results: out.results,
-      callMs,
-      inferMs
-    };
   }
-  /**
-   * Multi-camera stress tester.
-   *
-   * Runs the entire stress workload IN-PROCESS:
-   *   1. Decode + sharp-resize the JPEG once.
-   *   2. Build pre-fabricated `FrameInput[]` templates for the batched
-   *      and single-frame call shapes.
-   *   3. Spawn `simulatedCameras` parallel async loops; each loop runs
-   *      `batchesPerCamera` rounds. Per round: fan out 1 batched call
-   *      + `extraSinglesPerRound` single calls via `Promise.all`.
-   *   4. Aggregate detsPerSec from `(simulatedCameras × batchesPerCamera
-   *      × batchSize) / totalMs` so the metric is comparable to the
-   *      external detector-engine benchmark we're calibrating against.
-   *
-   * Because the dispatch goes through `this.api.pipelineExecutor.
-   * runPipelineBatch.mutate(...)` and not over the wire, `localProvider
-   * Link` short-circuits when detection-pipeline is co-located on the
-   * same node. Removes per-call JSON marshalling, JPEG decode, and TLS.
-   */
-  async runMultiCameraStressTest(input) {
-    const targetSize = input.targetSize ?? 640;
-    const simulatedCameras = input.simulatedCameras ?? 4;
-    const batchesPerCamera = input.batchesPerCamera ?? 125;
-    const batchSize = input.batchSize ?? 4;
-    const extraSinglesPerRound = input.extraSinglesPerRound ?? 3;
-    const { nodeId, steps, sessionId } = input;
-    if (steps.length === 0) {
-      throw new Error("runMultiCameraStressTest: empty steps");
-    }
-    this.ctx.logger.info("runMultiCameraStressTest start", {
+  startSessionReplay(input) {
+    const runId = `replay-${input.deviceId}-${input.motionEventId}-${Date.now().toString(36)}`;
+    this.ctx.logger.info("session replay started", {
+      tags: { deviceId: input.deviceId },
       meta: {
-        nodeId: nodeId ?? null,
-        simulatedCameras,
-        batchesPerCamera,
-        batchSize,
-        extraSinglesPerRound,
-        targetSize,
-        steps: steps.map((s) => `${s.addonId}/${s.modelId}${s.enabled ? "" : "[off]"}`)
+        runId,
+        motionEventId: input.motionEventId,
+        nodeId: input.nodeId,
+        deviceKey: input.deviceKey ?? null,
+        modelId: input.modelId ?? null,
+        fps: input.fps ?? null,
+        maxFrames: input.maxFrames
       }
     });
-    const sharp = (await import("sharp")).default;
-    const jpeg = Buffer.from(input.imageBase64, "base64");
-    const rgb = await sharp(jpeg).resize({ width: targetSize, height: targetSize, fit: "fill" }).raw().toColorspace("srgb").toBuffer();
-    const rgbBytes = new Uint8Array(rgb.buffer, rgb.byteOffset, rgb.byteLength);
-    const buildFrames = (count) => Array.from({ length: count }, () => ({
-      data: rgbBytes,
-      format: "rgb",
-      width: targetSize,
-      height: targetSize,
-      timestamp: Date.now()
-    }));
-    const batchedFrames = buildFrames(batchSize);
-    const singleFrames = buildFrames(1);
-    const callMsList = [];
-    const inferMsList = [];
-    let errors = 0;
-    let countedDetections = 0;
-    let totalCalls = 0;
-    let totalFrames = 0;
-    const dispatchOne = async (frames, isCounted, tag) => {
-      const callStart = Date.now();
-      try {
-        const out = await this.api.pipelineExecutor.runPipelineBatch.mutate({
-          nodeId,
-          steps: [...steps],
-          frames: [...frames],
-          sessionId: sessionId ? `${sessionId}-${tag}` : tag
-        });
-        const callMs = Date.now() - callStart;
-        if (isCounted) {
-          callMsList.push(callMs);
-          let maxInfer = 0;
-          for (const r of out.results) {
-            const ms = r.debug?.totalInferenceMs ?? 0;
-            if (ms > maxInfer) maxInfer = ms;
-          }
-          inferMsList.push(maxInfer);
-        }
-      } catch (err) {
-        errors++;
-        this.ctx.logger.warn("runMultiCameraStressTest dispatch error", {
-          meta: { tag, error: err instanceof Error ? err.message : String(err) }
-        });
-      }
-    };
-    const start = Date.now();
-    const cameraTasks = Array.from(
-      { length: simulatedCameras },
-      (_, camIdx) => (async () => {
-        for (let i = 0; i < batchesPerCamera; i++) {
-          const dispatches = [
-            dispatchOne(batchedFrames, true, `c${camIdx}-r${i}-b`)
-          ];
-          for (let j = 0; j < extraSinglesPerRound; j++) {
-            dispatches.push(dispatchOne(singleFrames, false, `c${camIdx}-r${i}-s${j}`));
-          }
-          await Promise.all(dispatches);
-          countedDetections += batchSize;
-          totalCalls += 1 + extraSinglesPerRound;
-          totalFrames += batchSize + extraSinglesPerRound;
-        }
-      })()
+    this.replays.start(
+      runId,
+      (run) => runSessionReplay(
+        this.sessionReplayDeps(),
+        {
+          deviceId: input.deviceId,
+          motionEventId: input.motionEventId,
+          motionStartMs: input.motionStartMs,
+          nodeId: input.nodeId,
+          maxFrames: input.maxFrames,
+          ...input.deviceKey !== void 0 ? { deviceKey: input.deviceKey } : {},
+          ...input.modelId !== void 0 ? { modelId: input.modelId } : {},
+          ...input.fps !== void 0 ? { fps: input.fps } : {}
+        },
+        run
+      )
     );
-    await Promise.all(cameraTasks);
-    const totalMs = Date.now() - start;
-    const sortedCall = [...callMsList].toSorted((a, b) => a - b);
-    const pct = (xs, p) => {
-      if (xs.length === 0) return 0;
-      const idx = Math.min(xs.length - 1, Math.floor(xs.length * p));
-      return xs[idx] ?? 0;
+    return { accepted: true, runId };
+  }
+  getSessionReplayStatus(input) {
+    const status = this.replays.status(input.runId);
+    if (status === null) return null;
+    return {
+      runId: status.runId,
+      state: status.state,
+      startedAtMs: status.startedAtMs,
+      finishedAtMs: status.finishedAtMs,
+      progress: status.progress,
+      outcome: status.result,
+      error: status.error
     };
-    const inferMean = inferMsList.length === 0 ? 0 : inferMsList.reduce((s, x) => s + x, 0) / inferMsList.length;
-    const detsPerSec = totalMs > 0 ? countedDetections * 1e3 / totalMs : 0;
-    this.ctx.logger.info("runMultiCameraStressTest done", {
-      meta: {
-        totalMs,
-        countedDetections,
-        detsPerSec: Number(detsPerSec.toFixed(2)),
-        totalCalls,
-        totalFrames,
-        errors
-      }
-    });
+  }
+  async listSessionReplays(input) {
+    if (this.replayStore === null) return { runs: [], skipped: 0 };
+    const { runs, skipped } = await this.replayStore.list({ deviceId: input.deviceId, limit: 50 });
+    if (skipped > 0) {
+      this.ctx.logger.info("session replays: rows skipped that are not session replays", {
+        tags: { deviceId: input.deviceId },
+        meta: { skipped }
+      });
+    }
     return {
-      totalMs,
-      countedDetections,
-      detsPerSec,
-      totalCalls,
-      totalFrames,
-      callMsP50: pct(sortedCall, 0.5),
-      callMsP95: pct(sortedCall, 0.95),
-      callMsP99: pct(sortedCall, 0.99),
-      inferMsMean: inferMean,
-      errors
+      runs: runs.map((r) => {
+        const { timeline: _timeline, ...report } = r.report;
+        return {
+          id: r.id,
+          deviceId: r.deviceId,
+          nodeId: r.nodeId,
+          createdAtMs: r.createdAtMs,
+          report
+        };
+      }),
+      skipped
     };
   }
-  // ── Sustained throughput (root-detection e2e) ────────────────────────────
-  /**
-   * SUSTAINED THROUGHPUT test of ROOT detection.
-   *
-   * 1. Pin ONE frame in memory: resolve `frameId` (from `cacheBenchFrame`)
-   *    or the one-shot `imageBase64`, decode + square-resize ONCE to raw
-   *    RGB. Every node + every iteration consumes the IDENTICAL buffer — no
-   *    per-iteration decode or upload.
-   * 2. For each target node, run a `concurrency`-bounded loop of
-   *    `runPipelineBatch` (batchSize frames/call) on the node's ROOT-ONLY
-   *    steps until `durationSec` elapses (or the stop flag fires). Root-only
-   *    steps stay on the batch single-root fast path == live `plane:'frame'`
-   *    root detection.
-   * 3. Aggregate sustained fps / det/s + latency percentiles per node on the
-   *    identical pinned frame for apples-to-apples comparison.
-   *
-   * Non-destructive: targets the benchmark's own cached frame (never a live
-   * camera session), is explicitly started, and is bounded by N + the stop
-   * button (`abortSustainedThroughput`).
-   */
-  async runSustainedThroughput(input) {
-    const { frameId, imageBase64, durationSec, batchSize, concurrency, sessionId, nodes } = input;
-    const targetSize = input.targetSize ?? 640;
-    const cached2 = frameId ? this.frameCache.get(frameId) : void 0;
-    if (frameId && !cached2)
-      throw new Error(
-        `runSustainedThroughput: frameId ${frameId} not in cache (expired or never cached)`
-      );
-    const jpegSource = cached2 ? cached2.jpeg : imageBase64 ? Buffer.from(imageBase64, "base64") : null;
-    if (!jpegSource)
-      throw new Error("runSustainedThroughput: no frame source (need frameId or imageBase64)");
-    const sharp = (await import("sharp")).default;
-    const rgb = await sharp(jpegSource).resize({ width: targetSize, height: targetSize, fit: "fill" }).raw().toColorspace("srgb").toBuffer();
-    const rgbBytes = new Uint8Array(rgb.buffer, rgb.byteOffset, rgb.byteLength);
-    const batchFrames = Array.from({ length: batchSize }, () => ({
-      data: rgbBytes,
-      format: "rgb",
-      width: targetSize,
-      height: targetSize,
-      timestamp: Date.now()
-    }));
-    const benchFrameId = Math.floor(Math.random() * 4294967294) + 1 >>> 0;
-    const abortFlag = { aborted: false };
-    this.sustainedAbortFlags.set(sessionId, abortFlag);
-    this.ctx.logger.info("runSustainedThroughput start", {
-      meta: {
-        sessionId,
-        durationSec,
-        batchSize,
-        concurrency,
-        targetSize,
-        nodeCount: nodes.length,
-        nodes: nodes.map((n) => n.nodeId ?? "hub"),
-        deviceKeys: nodes.map((n) => n.deviceKey ?? "(default)")
-      }
-    });
+  async persistReplay(runId, nodeId, outcome) {
+    const store = this.replayStore;
+    if (store === null) return;
+    const tags = { deviceId: outcome.report.deviceId };
     try {
-      const perNode = await Promise.all(
-        nodes.map(async (node) => {
-          if (node.steps.length === 0)
-            throw new Error(
-              `runSustainedThroughput: node ${node.nodeId ?? "hub"} has no root steps`
-            );
-          const dispatchBatch = async () => {
-            const out = await this.api.pipelineExecutor.runPipelineBatch.mutate({
-              nodeId: node.nodeId,
-              steps: [...node.steps],
-              frames: [...batchFrames],
-              sessionId,
-              frameId: benchFrameId,
-              ...node.engine ? { engine: node.engine } : {},
-              ...node.deviceKey ? { deviceKey: node.deviceKey } : {}
-            });
-            return {
-              frameCount: out.results.length,
-              detectionCounts: out.results.map((r) => r.detections.length)
-            };
-          };
-          let raw;
-          try {
-            raw = await runSustainedLoop({
-              dispatchBatch,
-              concurrency,
-              durationMs: durationSec * 1e3,
-              now: () => Date.now(),
-              shouldStop: () => abortFlag.aborted
-            });
-          } finally {
-            await this.api.pipelineExecutor.uncacheFrame.mutate({ nodeId: node.nodeId, frameId: benchFrameId }).catch(() => {
-            });
-          }
-          const summary = {
-            nodeId: node.nodeId ?? null,
-            ...node.label ? { label: node.label } : {},
-            totalFrames: raw.totalFrames,
-            totalBatches: raw.totalBatches,
-            wallMs: raw.wallMs,
-            fps: computeFps(raw.totalFrames, raw.wallMs),
-            detsPerSec: computeDetsPerSec(raw.totalDetections, raw.wallMs),
-            avgDetections: computeAvgDetections(raw.totalDetections, raw.detectionSamples),
-            latency: computeLatencyStats(raw.callMsList),
-            errors: raw.errors,
-            aborted: raw.aborted
-          };
-          this.ctx.logger.info("runSustainedThroughput node done", {
-            meta: {
-              nodeId: summary.nodeId,
-              fps: Number(summary.fps.toFixed(2)),
-              detsPerSec: Number(summary.detsPerSec.toFixed(2)),
-              p95Ms: Number(summary.latency.p95.toFixed(2)),
-              totalFrames: summary.totalFrames,
-              errors: summary.errors,
-              aborted: summary.aborted
-            }
-          });
-          return summary;
-        })
-      );
-      return { perNode, durationSec, batchSize, concurrency };
-    } finally {
-      this.sustainedAbortFlags.delete(sessionId);
+      await store.save({
+        id: runId,
+        deviceId: outcome.report.deviceId,
+        nodeId,
+        createdAtMs: Date.now(),
+        report: outcome.report
+      });
+      await this.pruneReplays();
+    } catch (err) {
+      this.ctx.logger.warn("session replay: report NOT saved", {
+        tags,
+        meta: { runId, error: errMsg(err) }
+      });
     }
   }
-  async abortSustainedThroughput(input) {
-    const flag = this.sustainedAbortFlags.get(input.sessionId);
-    if (!flag) return { aborted: false };
-    flag.aborted = true;
-    return { aborted: true };
-  }
-  // ── Decoder perf — fixture discovery + run orchestration ────────────────
-  async listDecoderFixtures() {
-    const dir = resolveFixturesDir();
-    if (!fs2.existsSync(dir)) {
-      this.ctx.logger.warn("decoder fixtures directory missing", { meta: { dir } });
-      return [];
-    }
-    const out = [];
-    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isFile()) continue;
-      const meta3 = FIXTURE_META[entry.name];
-      if (!meta3) continue;
-      const full = path2.join(dir, entry.name);
-      const stat = fs2.statSync(full);
-      out.push({
-        filename: entry.name,
-        codec: meta3.codec,
-        resolutionLabel: meta3.resolutionLabel,
-        sizeBytes: stat.size,
-        description: meta3.description
-      });
+  async pruneReplays() {
+    const store = this.replayStore;
+    if (store === null) return;
+    try {
+      const deleted = await store.pruneBefore(Date.now() - REPLAY_RETENTION_MS);
+      if (deleted > 0) this.ctx.logger.info("session replays pruned", { meta: { deleted } });
+    } catch (err) {
+      this.ctx.logger.warn("session replays: prune failed", { meta: { error: errMsg(err) } });
     }
-    out.sort((a, b) => a.sizeBytes - b.sizeBytes);
-    return out;
   }
-  async runDecoderPerformanceTest(input) {
-    const abortFlag = { aborted: false };
-    this.decoderPerfAbortFlags.set(input.sessionId, abortFlag);
+  /**
+   * The camera's own cooldown + pre-roll switch, read from the orchestrator's
+   * hydrated device settings (the authority, not a copy). A failed read is
+   * `{}` — the fleet defaults apply and the report says `default`.
+   */
+  async cameraSessionSettings(deviceId) {
     try {
-      return await runDecoderPerfTest(input, {
-        api: this.api,
-        eventBus: this.ctx.eventBus,
-        logger: this.ctx.logger,
-        fixturesDir: resolveFixturesDir(),
-        abortFlag
+      const raw = await this.api.addonSettings.getDeviceSettings.query({
+        addonId: "pipeline-orchestrator",
+        deviceId
       });
-    } finally {
-      this.decoderPerfAbortFlags.delete(input.sessionId);
+      return readCameraSessionSettings(raw);
+    } catch (err) {
+      this.ctx.logger.warn("session replay: camera session settings unreadable \u2014 fleet defaults", {
+        tags: { deviceId },
+        meta: { error: errMsg(err) }
+      });
+      return {};
     }
   }
-  async abortDecoderPerformanceTest(input) {
-    const flag = this.decoderPerfAbortFlags.get(input.sessionId);
-    if (!flag) return { aborted: false };
-    flag.aborted = true;
-    return { aborted: true };
+  /** The replay's outside world — every call through `ctx.api`, node-pinned where it matters. */
+  sessionReplayDeps() {
+    const api = this.api;
+    const profile = REPLAY_RECORDING_PROFILE;
+    return {
+      logger: this.ctx.logger,
+      cameraSessionSettings: (deviceId) => this.cameraSessionSettings(deviceId),
+      findMotionSession: async (deviceId, motionEventId, motionStartMs) => {
+        const events = await api.pipelineAnalytics.getMotionEvents.query({
+          deviceId,
+          since: motionStartMs - 1,
+          until: motionStartMs + 1,
+          limit: 50,
+          projection: "full"
+        });
+        return events.find((e) => e.id === motionEventId) ?? null;
+      },
+      resolveCameraTree: (deviceId, nodeId) => api.pipelineOrchestrator.resolvePipeline.query({ deviceId, agentNodeId: nodeId }),
+      validate: (steps, nodeId, deviceKey) => api.pipelineExecutor.validatePipeline.query(
+        { steps: [...steps], ...deviceKey !== void 0 ? { deviceKey } : {} },
+        nodePin(nodeId)
+      ),
+      isRecording: async (deviceId) => {
+        const config2 = await api.recordingArchive.getDeviceConfig.query({ deviceId });
+        return config2.enabled !== false;
+      },
+      listStoredTracks: async (deviceId, sinceMs, untilMs) => api.pipelineAnalytics.listTracks.query({
+        deviceId,
+        since: sinceMs,
+        until: untilMs,
+        projection: "full",
+        excludeSources: ["sensor", "audio"],
+        limit: STORED_TRACKS_READ_LIMIT
+      }),
+      listBirthDecisions: (deviceId, sinceMs) => api.pipelineAnalytics.listBirthDecisions.query({
+        deviceId,
+        since: sinceMs,
+        limit: REPLAY_BIRTHS_LIMIT
+      }),
+      readRecording: (deviceId, instants, stepMs) => readRecordingForInstants(
+        {
+          locateSegment: (epochMs) => api.recordingArchive.locateSegment.query({ deviceId, profile, epochMs }),
+          readWindowBytes: (q) => api.recordingArchive.readWindowBytes.query({ deviceId, profile, ...q })
+        },
+        instants,
+        stepMs
+      ),
+      decode: async (bytes, args) => {
+        const mjpeg = await this.replayDecoder.decodeSequence(
+          buildReplaySequenceArgs(args),
+          bytes,
+          {
+            timeoutMs: Math.max(
+              REPLAY_DECODE_TIMEOUT_FLOOR_MS,
+              Math.round(args.durationSec * REPLAY_DECODE_TIMEOUT_PER_SEC_MS)
+            )
+          }
+        );
+        return splitMjpegStream(mjpeg);
+      },
+      runRootDetector: (call) => api.pipelineExecutor.runPipeline.mutate({
+        nodeId: call.nodeId,
+        steps: [...call.steps],
+        // A fresh `Uint8Array<ArrayBuffer>`: `mjpeg-split` hands back a
+        // `Buffer` view, and the generated cap input is typed against the
+        // narrower `ArrayBuffer` backing.
+        image: new Uint8Array(call.image),
+        deviceId: call.deviceId,
+        plane: "frame",
+        replay: true,
+        ...call.deviceKey !== void 0 ? { deviceKey: call.deviceKey } : {}
+      })
+    };
   }
   // ── History persistence (per-addon store on the hub) ──────────────────
   /**
@@ -16695,9 +16352,7 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
    * VERBATIM: the value under `benchmarkHistory` is a JSON **string** (not
    * the array itself), so the handle is typed over the string — the
    * encode/decode + entry-level recovery below stays the codec, the handle
-   * owns store access (retry budget + validated fallback). Absent key or a
-   * non-string value falls back to the empty-history encoding, exactly the
-   * `[]` the raw read produced.
+   * owns store access (retry budget + validated fallback).
    */
   historyState() {
     return this.state(KEY_BENCHMARK_HISTORY, external_exports.string(), EMPTY_HISTORY_JSON);
@@ -16711,14 +16366,10 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
       const arr = Array.isArray(parsed) ? parsed : [];
       const accepted = [];
       let rejected = 0;
-      for (const entry of arr) {
-        const normalized = entry !== null && typeof entry === "object" && !("kind" in entry) ? { ...entry, kind: "pipeline" } : entry;
-        const parsedEntry = HistoryEntrySchema.safeParse(normalized);
-        if (parsedEntry.success) {
-          accepted.push(parsedEntry.data);
-        } else {
-          rejected += 1;
-        }
+      for (const entry2 of arr) {
+        const parsedEntry = HistoryEntrySchema.safeParse(entry2);
+        if (parsedEntry.success) accepted.push(parsedEntry.data);
+        else rejected += 1;
       }
       if (rejected > 0) {
         this.ctx.logger.warn("benchmark history: dropped unparseable entries", {
@@ -16734,13 +16385,10 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
   async writeHistory(history) {
     await this.historyState().set(JSON.stringify(history));
   }
-  async listBenchmarkHistory() {
-    return this.loadHistory();
-  }
-  async saveBenchmarkResult(entry) {
+  async saveBenchmarkResult(entry2) {
     const history = await this.loadHistory();
     const saved = {
-      ...entry,
+      ...entry2,
       kind: "pipeline",
       id: `bench-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
       date: (/* @__PURE__ */ new Date()).toISOString()
@@ -16750,19 +16398,6 @@ var BenchmarkAddon = class _BenchmarkAddon extends BaseAddon {
     await this.writeHistory(next);
     return saved;
   }
-  async saveDecoderPerformanceResult(entry) {
-    const history = await this.loadHistory();
-    const saved = {
-      kind: "decoder-perf",
-      id: `decoder-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      date: (/* @__PURE__ */ new Date()).toISOString(),
-      ...entry
-    };
-    const next = [saved, ...history];
-    if (next.length > MAX_HISTORY_ENTRIES) next.length = MAX_HISTORY_ENTRIES;
-    await this.writeHistory(next);
-    return saved;
-  }
   async deleteBenchmarkResult(input) {
     const history = (await this.loadHistory()).filter((e) => e.id !== input.id);
     await this.writeHistory(history);