@camstack/addon-benchmark 1.2.194 → 1.2.196

package/dist/index.js

@@ -26,7 +26,10 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/benchmark-addon.ts
-var import_types4 = require("@camstack/types");
+var import_types3 = require("@camstack/types");
+
+// src/benchmark-actions.ts
+var import_types2 = require("@camstack/types");
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -11518,42 +11521,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 entry2 of ctx.seen.entries()) {
-    const id = ctx.metadataRegistry.get(entry2[0])?.id;
+  for (const entry of ctx.seen.entries()) {
+    const id = ctx.metadataRegistry.get(entry[0])?.id;
     if (id) {
       const existing = idToSchema.get(id);
-      if (existing && existing !== entry2[0]) {
+      if (existing && existing !== entry[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, entry2[0]);
+      idToSchema.set(id, entry[0]);
     }
   }
-  const makeURI = (entry2) => {
+  const makeURI = (entry) => {
     const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
     if (ctx.external) {
-      const externalId = ctx.external.registry.get(entry2[0])?.id;
+      const externalId = ctx.external.registry.get(entry[0])?.id;
       const uriGenerator = ctx.external.uri ?? ((id2) => id2);
       if (externalId) {
         return { ref: uriGenerator(externalId) };
       }
-      const id = entry2[1].defId ?? entry2[1].schema.id ?? `schema${ctx.counter++}`;
-      entry2[1].defId = id;
+      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
+      entry[1].defId = id;
       return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
     }
-    if (entry2[1] === root) {
+    if (entry[1] === root) {
       return { ref: "#" };
     }
     const uriPrefix = `#`;
     const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
-    const defId = entry2[1].schema.id ?? `__schema${ctx.counter++}`;
+    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
     return { defId, ref: defUriPrefix + defId };
   };
-  const extractToDef = (entry2) => {
-    if (entry2[1].schema.$ref) {
+  const extractToDef = (entry) => {
+    if (entry[1].schema.$ref) {
       return;
     }
-    const seen = entry2[1];
-    const { ref, defId } = makeURI(entry2);
+    const seen = entry[1];
+    const { ref, defId } = makeURI(entry);
     seen.def = { ...seen.schema };
     if (defId)
       seen.defId = defId;
@@ -11564,8 +11567,8 @@ function extractDefs(ctx, schema) {
     schema2.$ref = ref;
   };
   if (ctx.cycles === "throw") {
-    for (const entry2 of ctx.seen.entries()) {
-      const seen = entry2[1];
+    for (const entry of ctx.seen.entries()) {
+      const seen = entry[1];
       if (seen.cycle) {
         throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
 
@@ -11573,31 +11576,31 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
   }
-  for (const entry2 of ctx.seen.entries()) {
-    const seen = entry2[1];
-    if (schema === entry2[0]) {
-      extractToDef(entry2);
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
+    if (schema === entry[0]) {
+      extractToDef(entry);
       continue;
     }
     if (ctx.external) {
-      const ext = ctx.external.registry.get(entry2[0])?.id;
-      if (schema !== entry2[0] && ext) {
-        extractToDef(entry2);
+      const ext = ctx.external.registry.get(entry[0])?.id;
+      if (schema !== entry[0] && ext) {
+        extractToDef(entry);
         continue;
       }
     }
-    const id = ctx.metadataRegistry.get(entry2[0])?.id;
+    const id = ctx.metadataRegistry.get(entry[0])?.id;
     if (id) {
-      extractToDef(entry2);
+      extractToDef(entry);
       continue;
     }
     if (seen.cycle) {
-      extractToDef(entry2);
+      extractToDef(entry);
       continue;
     }
     if (seen.count > 1) {
       if (ctx.reused === "ref") {
-        extractToDef(entry2);
+        extractToDef(entry);
         continue;
       }
     }
@@ -11669,8 +11672,8 @@ function finalize(ctx, schema) {
       path: seen.path ?? []
     });
   };
-  for (const entry2 of [...ctx.seen.entries()].reverse()) {
-    flattenRef(entry2[0]);
+  for (const entry of [...ctx.seen.entries()].reverse()) {
+    flattenRef(entry[0]);
   }
   const result = {};
   if (ctx.target === "draft-2020-12") {
@@ -11693,8 +11696,8 @@ function finalize(ctx, schema) {
   if (rootMetaId !== void 0 && result.id === rootMetaId)
     delete result.id;
   const defs = ctx.external?.defs ?? {};
-  for (const entry2 of ctx.seen.entries()) {
-    const seen = entry2[1];
+  for (const entry of ctx.seen.entries()) {
+    const seen = entry[1];
     if (seen.def && seen.defId) {
       if (seen.def.id === seen.defId)
         delete seen.def.id;
@@ -12310,8 +12313,8 @@ function toJSONSchema(input, params) {
     const registry2 = input;
     const ctx2 = initializeContext({ ...params, processors: allProcessors });
     const defs = {};
-    for (const entry2 of registry2._idmap.entries()) {
-      const [_, schema] = entry2;
+    for (const entry of registry2._idmap.entries()) {
+      const [_, schema] = entry;
       process(schema, ctx2);
     }
     const schemas = {};
@@ -12321,8 +12324,8 @@ function toJSONSchema(input, params) {
       defs
     };
     ctx2.external = external;
-    for (const entry2 of registry2._idmap.entries()) {
-      const [key, schema] = entry2;
+    for (const entry of registry2._idmap.entries()) {
+      const [key, schema] = entry;
       extractDefs(ctx2, schema);
       schemas[key] = finalize(ctx2, schema);
     }
@@ -14542,205 +14545,10 @@ function date4(params) {
 // ../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
-// src/benchmark-actions.ts
-var import_types3 = require("@camstack/types");
-
 // src/benchmark-schemas.ts
-var import_types2 = require("@camstack/types");
-
-// src/session-replay/schemas.ts
 var import_types = require("@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: import_types.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(),
-  iterations: external_exports.number(),
-  warmup: external_exports.number(),
-  fps: external_exports.number(),
-  avgMs: external_exports.number(),
-  medianMs: external_exports.number(),
-  p95Ms: external_exports.number(),
-  p99Ms: external_exports.number(),
-  /**
-   * 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(),
-  /** Concurrent in-flight requests (simulated cameras) — NOT pool workers. */
-  parallelRuns: external_exports.number().min(1).default(1)
-};
-var PipelineBenchmarkHistoryEntrySchema = external_exports.object({
-  kind: external_exports.literal("pipeline").default("pipeline"),
-  id: external_exports.string(),
-  date: external_exports.string(),
-  ...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 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 = PipelineBenchmarkHistoryEntrySchema;
 var PipelineRunInputSchema = external_exports.object({
-  steps: external_exports.array(import_types2.PipelineStepInputSchema).readonly(),
+  steps: external_exports.array(import_types.PipelineStepInputSchema).readonly(),
   imageBase64: external_exports.string().optional(),
   referenceImage: external_exports.string().optional(),
   /** Target node. Forwarded to `pipelineExecutor.runPipeline`. Omit to run on the hub. */
@@ -14750,1242 +14558,17 @@ var PipelineRunInputSchema = external_exports.object({
   deviceKey: external_exports.string().optional(),
   plane: external_exports.enum(["full", "frame"]).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 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()
-});
-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 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 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(),
-  /** 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 StartSessionReplayAcceptedSchema = external_exports.object({
-  accepted: external_exports.literal(true),
-  runId: external_exports.string()
-});
-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 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 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(),
-  createdAtMs: external_exports.number(),
-  report: SessionReplayReportSchema
-});
 
 // src/benchmark-actions.ts
-var benchmarkActions = (0, import_types3.defineCustomActions)({
-  // Detection Pipeline — one run.
-  runPipelineTest: (0, import_types3.customAction)(PipelineRunInputSchema, import_types3.PipelineRunResultBridge, {
-    kind: "mutation"
-  }),
-  /**
-   * History.
-   *
-   * `z.object({})`, never `z.void()`: the `addons.custom` envelope insists
-   * on an `input` object, and a `z.void()` schema REJECTS `{}`.
-   */
-  listBenchmarkHistory: (0, import_types3.customAction)(external_exports.object({}), external_exports.array(HistoryEntrySchema).readonly()),
-  saveBenchmarkResult: (0, import_types3.customAction)(
-    PipelineBenchmarkHistoryEntryInputSchema,
-    PipelineBenchmarkHistoryEntrySchema,
-    { kind: "mutation" }
-  ),
-  deleteBenchmarkResult: (0, import_types3.customAction)(
-    external_exports.object({ id: external_exports.string() }),
-    external_exports.object({ success: external_exports.literal(true) }),
-    { kind: "mutation" }
-  ),
-  clearBenchmarkHistory: (0, import_types3.customAction)(external_exports.object({}), external_exports.object({ success: external_exports.literal(true) }), {
+var benchmarkActions = (0, import_types2.defineCustomActions)({
+  // Image — one run of a step tree on a (node, deviceKey).
+  runPipelineTest: (0, import_types2.customAction)(PipelineRunInputSchema, import_types2.PipelineRunResultBridge, {
     kind: "mutation"
-  }),
-  // Session replay (D646) — the stored sessions to pick from, then start / poll / abort.
-  listMotionSessions: (0, import_types3.customAction)(
-    ListMotionSessionsInputSchema,
-    external_exports.array(MotionSessionSchema).readonly()
-  ),
-  startSessionReplay: (0, import_types3.customAction)(
-    StartSessionReplayInputSchema,
-    StartSessionReplayAcceptedSchema,
-    { kind: "mutation", auth: "admin" }
-  ),
-  getSessionReplayStatus: (0, import_types3.customAction)(SessionReplayKeySchema, SessionReplayStatusSchema),
-  abortSessionReplay: (0, import_types3.customAction)(SessionReplayKeySchema, external_exports.object({ aborted: external_exports.boolean() }), {
-    kind: "mutation",
-    auth: "admin"
-  }),
-  listSessionReplays: (0, import_types3.customAction)(ListSessionReplaysInputSchema, ListSessionReplaysResultSchema),
-  getSessionReplay: (0, import_types3.customAction)(GetSessionReplayInputSchema, StoredSessionReplaySchema.nullable())
-});
-
-// 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-decode.ts
-var import_node_child_process = require("child_process");
-function buildReplaySequenceArgs(opts) {
-  const { startSec, durationSec, fps, maxWidth } = opts;
-  return [
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    "-nostdin",
-    "-ss",
-    String(Math.max(0, startSec)),
-    "-i",
-    "pipe:0",
-    "-t",
-    String(Math.max(0, durationSec)),
-    "-vf",
-    `fps=${fps},scale='min(${maxWidth},iw)':-2`,
-    "-f",
-    "mjpeg",
-    "pipe:1"
-  ];
-}
-var REPLAY_DECODE_MAX_CONCURRENT = 2;
-var REPLAY_DECODE_TIMEOUT_MS = 15e3;
-var KILL_GRACE_MS = 500;
-var ReplayDecoder = class {
-  resolveFfmpegPath;
-  spawnFn;
-  maxConcurrent;
-  timeoutMs;
-  inFlight = 0;
-  constructor(deps) {
-    this.resolveFfmpegPath = deps.resolveFfmpegPath;
-    this.spawnFn = deps.spawnFn ?? ((bin, args) => (0, import_node_child_process.spawn)(bin, [...args]));
-    this.maxConcurrent = deps.maxConcurrent ?? REPLAY_DECODE_MAX_CONCURRENT;
-    this.timeoutMs = deps.timeoutMs ?? REPLAY_DECODE_TIMEOUT_MS;
-  }
-  /** Decodes currently running (tests / metrics). */
-  get running() {
-    return this.inFlight;
-  }
-  /**
-   * Run the sequence once, feeding `input` on stdin (`-i pipe:0` in
-   * {@link buildReplaySequenceArgs}) — the same shape as
-   * `RecordedStillService`, which pipes a GOP rather than pointing ffmpeg at
-   * a file path, because the source bytes (a recorder GOP window, or an
-   * uploaded clip) are fetched through a capability call, not a local path.
-   * Resolves with the whole MJPEG stdout stream.
-   */
-  async decodeSequence(args, input, opts = {}) {
-    if (this.inFlight >= this.maxConcurrent) {
-      throw new Error(
-        `replay decode busy: node already running ${this.inFlight}/${this.maxConcurrent} decodes`
-      );
-    }
-    this.inFlight += 1;
-    try {
-      const ffmpegPath = await this.resolveFfmpegPath();
-      return await this.runOnce(ffmpegPath, args, input, opts.timeoutMs ?? this.timeoutMs);
-    } finally {
-      this.inFlight -= 1;
-    }
-  }
-  runOnce(ffmpegPath, args, input, timeoutMs) {
-    return new Promise((resolve, reject) => {
-      const chunks = [];
-      const stderrTail = [];
-      let settled = false;
-      const child = (() => {
-        try {
-          return this.spawnFn(ffmpegPath, args);
-        } catch (err) {
-          reject(new Error(`replay decode: ffmpeg spawn failed: ${String(err)}`));
-          return null;
-        }
-      })();
-      if (child === null) return;
-      const settle = (fn) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        fn();
-      };
-      const kill = () => {
-        try {
-          child.kill("SIGTERM");
-        } catch {
-        }
-        const t = setTimeout(() => {
-          if (child.exitCode === null && child.signalCode === null) {
-            try {
-              child.kill("SIGKILL");
-            } catch {
-            }
-          }
-        }, KILL_GRACE_MS);
-        t.unref?.();
-      };
-      const timer = setTimeout(() => {
-        settle(() => reject(new Error("replay decode: timed out")));
-        kill();
-      }, timeoutMs);
-      timer.unref?.();
-      child.stdout?.on("data", (chunk) => chunks.push(chunk));
-      child.stderr?.on("data", (data) => {
-        const line = data.toString().trim();
-        if (line) {
-          stderrTail.push(line);
-          if (stderrTail.length > 8) stderrTail.shift();
-        }
-      });
-      child.on("error", (err) => {
-        settle(() => reject(new Error(`replay decode: ffmpeg process error: ${err.message}`)));
-      });
-      child.on("exit", (code, signal) => {
-        const stdout = Buffer.concat(chunks);
-        if (code === 0) {
-          settle(() => resolve(stdout));
-          return;
-        }
-        settle(
-          () => reject(
-            new Error(
-              `replay decode: ffmpeg exited code=${String(code)} signal=${String(signal)}: ${stderrTail.join(" | ") || "(no stderr)"}`
-            )
-          )
-        );
-      });
-      try {
-        child.stdin?.write(Buffer.from(input.buffer, input.byteOffset, input.byteLength));
-        child.stdin?.end();
-      } catch {
-      }
-    });
-  }
-};
-
-// 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 },
-  { name: "nodeId", type: "TEXT", notNull: true },
-  { name: "clipId", type: "TEXT", notNull: true },
-  { name: "createdAtMs", type: "INTEGER", notNull: true },
-  { name: "source", type: "JSON", notNull: true },
-  { name: "plan", type: "JSON", notNull: true },
-  { name: "verdict", type: "JSON", notNull: true }
-];
-var REPLAY_RUNS_INDEXES = [
-  { name: "idx_replay_runs_device_created", columns: ["deviceId", "createdAtMs"] },
-  { name: "idx_replay_runs_created", columns: ["createdAtMs"] }
-];
-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;
-  }
-  store;
-  /** Declare the collection. Call in `onInitialize`, before the first
-   *  `save` — an undeclared collection crash-loops the runner. */
-  static async declare(store) {
-    await store.declareCollection.mutate({
-      collection: REPLAY_RUNS_COLLECTION,
-      columns: [...REPLAY_RUNS_COLUMNS],
-      indexes: [...REPLAY_RUNS_INDEXES]
-    });
-  }
-  async save(run) {
-    const { report } = run;
-    await this.store.insert.mutate({
-      collection: REPLAY_RUNS_COLLECTION,
-      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
-        }
-      }
-    });
-  }
-  /** Session replays newest-first, optionally scoped to one camera. */
-  async list(query) {
-    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. */
-  async pruneBefore(cutoffMs) {
-    const { deleted } = await this.store.deleteWhere.mutate({
-      collection: REPLAY_RUNS_COLLECTION,
-      filter: { whereBetween: { createdAtMs: [0, cutoffMs] } }
-    });
-    return deleted;
-  }
-  static readRow(id, data) {
-    const parsed = StoredRowSchema.safeParse(data);
-    if (!parsed.success) return null;
-    return {
-      id,
-      deviceId: parsed.data.deviceId,
-      nodeId: parsed.data.nodeId,
-      createdAtMs: parsed.data.createdAtMs,
-      report: parsed.data.verdict
-    };
-  }
-};
-
-// 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 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;
-    }
-    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`
-    };
-  }
-  return {
-    kind: "ok",
-    parts,
-    instantsWithoutFootage: withoutFootage,
-    truncatedBySafetyCap: truncated
-  };
-}
-
-// 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;
-  }
-  if (nearest !== void 0 && Math.abs(nearest.t - t) <= halfStepMs) {
-    return entry(nearest, nearest.t, "exact");
-  }
-  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"
-    };
-  }
-  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 });
-    });
-  });
-  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
-    });
-  }
-  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)
-  );
-  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/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/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: []
-    }
-  };
-}
-
-// 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 {
-    kind: "window",
-    motionEventId: session.id,
-    motionStartMs: session.timestamp,
-    motionEndMs,
-    startMs,
-    endMs,
-    prerollSource,
-    tailSource
-  };
-}
-
-// 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 {
-    tracks: refs,
-    trackCount,
-    recoveryExcluded,
-    withoutGeometry,
-    models: Object.fromEntries(models),
-    frameSize: commonest ? { width: commonest.width, height: commonest.height } : null,
-    positionTimesByTrack: timesByTrack
-  };
-}
-
-// 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 sameClass2(a, b) {
-  return a.trim().toLowerCase() === b.trim().toLowerCase();
-}
-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 (the executor does not report it) \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 = 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) => {
@@ -16001,36 +14584,8 @@ async function withHardTimeout(promise2, ms, label) {
     if (timer) clearTimeout(timer);
   }
 }
-var HistoryArraySchema = external_exports.array(HistoryEntrySchema);
-var BenchmarkAddon = class extends import_types4.BaseAddon {
+var BenchmarkAddon = class extends import_types3.BaseAddon {
   id = "benchmark";
-  replayStore = null;
-  /** The replay's ffmpeg spawns — the PINNED binary (`ctx.deps.ensureFfmpeg`, D540). */
-  replayDecoder = new ReplayDecoder({
-    resolveFfmpegPath: () => this.ctx.deps.ensureFfmpeg()
-  });
-  /**
-   * 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 import_types4.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",
@@ -16051,29 +14606,15 @@ var BenchmarkAddon = class extends import_types4.BaseAddon {
       id: this.id,
       listPages: () => this.pages
     };
-    await ReplayStore.declare(this.api.settingsStore);
-    this.replayStore = new ReplayStore(this.api.settingsStore);
-    await this.pruneReplays();
     return {
-      providers: [{ capability: import_types4.addonPagesSourceCapability, provider }],
+      providers: [{ capability: import_types3.addonPagesSourceCapability, provider }],
       customActions: benchmarkActions,
       actionHandlers: {
-        runPipelineTest: async (input) => this.runPipelineTest(input),
-        listBenchmarkHistory: async () => this.loadHistory(),
-        saveBenchmarkResult: async (input) => this.saveBenchmarkResult(input),
-        deleteBenchmarkResult: async (input) => this.deleteBenchmarkResult(input),
-        clearBenchmarkHistory: async () => this.clearBenchmarkHistory(),
-        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)
+        runPipelineTest: async (input) => this.runPipelineTest(input)
       }
     };
   }
   async onShutdown() {
-    this.replays.abortAll();
   }
   get api() {
     const api = this.ctx.api;
@@ -16127,297 +14668,6 @@ var BenchmarkAddon = class extends import_types4.BaseAddon {
       "runPipelineTest"
     );
   }
-  // ── 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"
-    });
-    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
-    );
-    const ends = windows.map(
-      ({ ev, window }) => window.kind === "window" ? window.endMs : ev.timestamp
-    );
-    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
-    });
-    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
-    }));
-  }
-  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: {
-        runId,
-        motionEventId: input.motionEventId,
-        nodeId: input.nodeId,
-        deviceKey: input.deviceKey ?? null,
-        modelId: input.modelId ?? null,
-        fps: input.fps ?? null,
-        maxFrames: input.maxFrames
-      }
-    });
-    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
-      )
-    );
-    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
-    };
-  }
-  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 {
-      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
-    };
-  }
-  async persistReplay(runId, nodeId, outcome) {
-    const store = this.replayStore;
-    if (store === null) return;
-    const tags = { deviceId: outcome.report.deviceId };
-    try {
-      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: (0, import_types4.errMsg)(err) }
-      });
-    }
-  }
-  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: (0, import_types4.errMsg)(err) } });
-    }
-  }
-  /**
-   * 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 {
-      const raw = await this.api.addonSettings.getDeviceSettings.query({
-        addonId: "pipeline-orchestrator",
-        deviceId
-      });
-      return readCameraSessionSettings(raw);
-    } catch (err) {
-      this.ctx.logger.warn("session replay: camera session settings unreadable \u2014 fleet defaults", {
-        tags: { deviceId },
-        meta: { error: (0, import_types4.errMsg)(err) }
-      });
-      return {};
-    }
-  }
-  /** 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 } : {} },
-        (0, import_types4.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) ──────────────────
-  /**
-   * Durable handle over the persisted history blob. LEGACY SHAPE, PRESERVED
-   * 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).
-   */
-  historyState() {
-    return this.state(KEY_BENCHMARK_HISTORY, external_exports.string(), EMPTY_HISTORY_JSON);
-  }
-  async loadHistory() {
-    const raw = await this.historyState().get();
-    try {
-      const parsed = (0, import_types4.parseJsonUnknown)(raw);
-      const result = HistoryArraySchema.safeParse(parsed);
-      if (result.success) return [...result.data];
-      const arr = Array.isArray(parsed) ? parsed : [];
-      const accepted = [];
-      let rejected = 0;
-      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", {
-          meta: { rejected, accepted: accepted.length, error: result.error.message }
-        });
-      }
-      return accepted;
-    } catch (err) {
-      this.ctx.logger.warn("benchmark history parse failed", { meta: { error: (0, import_types4.errMsg)(err) } });
-      return [];
-    }
-  }
-  async writeHistory(history) {
-    await this.historyState().set(JSON.stringify(history));
-  }
-  async saveBenchmarkResult(entry2) {
-    const history = await this.loadHistory();
-    const saved = {
-      ...entry2,
-      kind: "pipeline",
-      id: `bench-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    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);
-    return { success: true };
-  }
-  async clearBenchmarkHistory() {
-    await this.writeHistory([]);
-    return { success: true };
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {