camstack 1.2.44 → 1.2.46

package/dist/{launcher-YBD4BK4V.js → launcher-Y5I6QU24.js}

@@ -23633,9 +23633,9 @@ var require_zod = __commonJS({
   }
 });
 
-// ../system/dist/dist-D5Jhh8Vk.js
-var require_dist_D5Jhh8Vk = __commonJS({
-  "../system/dist/dist-D5Jhh8Vk.js"(exports) {
+// ../system/dist/dist-jRSrzoXr.js
+var require_dist_jRSrzoXr = __commonJS({
+  "../system/dist/dist-jRSrzoXr.js"(exports) {
     "use strict";
     var zod = require_zod();
     var EventCategory = /* @__PURE__ */ (function(EventCategory2) {
@@ -34136,7 +34136,23 @@ var require_dist_D5Jhh8Vk = __commonJS({
       updatedAt: zod.z.number(),
       /** Failure detail — present on a `dead` row. */
       error: zod.z.string().optional(),
-      subject: NcHistorySubjectSchema
+      subject: NcHistorySubjectSchema,
+      /**
+      * Ids of the artefacts (still, then gif, then clip) this row's successful
+      * delivery indexed in the artefact library — a REFERENCE, never the bytes
+      * (an artefact is often megabytes; this row is durable JSON rewritten on
+      * every delivery attempt). Absent on a row still pending/dead, a row
+      * delivered before this field shipped, or a wiring with no artefact index.
+      *
+      * Resolve one to a fetchable URL with `resolveArtifactUrl` — an id
+      * outlives any one URL's TTL, so a caller mints a fresh link on demand
+      * rather than trusting one frozen at delivery time. `resolveArtifactUrl`
+      * also answers `null` for an id whose artefact has since expired past the
+      * retained shelf's own age bound — the degrade a caller (the Home
+      * Assistant export) must render as "no image right now", never as a
+      * broken link.
+      */
+      artifactIds: zod.z.array(zod.z.string().min(1)).optional()
     });
     var NcHistoryFilterSchema = zod.z.object({
       ruleId: zod.z.string().optional(),
@@ -34382,6 +34398,20 @@ var require_dist_D5Jhh8Vk = __commonJS({
         */
         getHistory: method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" }),
         /**
+        * Mint a fresh, externally-reachable URL for one artefact a history row
+        * named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
+        * signed-link mechanism the dispatcher uses to attach media to an
+        * outgoing notification (one derivation; this never re-implements it).
+        *
+        * `url: null` on THREE causes a caller must treat identically ("no image
+        * right now", never a broken link): the id is unknown, its artefact has
+        * expired past the retained shelf's own age bound, or this install has no
+        * externally-reachable base URL. A caller that received a URL on a
+        * previous call and now gets `null` must stop showing it — a link that
+        * worked five minutes ago is not proof it works now.
+        */
+        resolveArtifactUrl: method(zod.z.object({ artifactId: zod.z.string().min(1) }), zod.z.object({ url: zod.z.string().nullable() }), { auth: "admin" }),
+        /**
         * Snooze windows currently in effect, plus any whose digest has not yet
         * gone out. `caller: 'required'`: a user sees their OWN windows and the
         * global ones that silence them, never another person's private silence.
@@ -34621,6 +34651,726 @@ var require_dist_D5Jhh8Vk = __commonJS({
         getDescriptor: method(zod.z.void(), OauthIntegrationDescriptorSchema, { auth: "admin" })
       }
     };
+    var NativeCropRefSchema = zod.z.object({
+      /** Handle keying the retained native surface (node-pinned to its owner). */
+      handle: FrameHandleSchema,
+      /** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
+      cropFrameSpace: zod.z.object({
+        x: zod.z.number(),
+        y: zod.z.number(),
+        w: zod.z.number(),
+        h: zod.z.number()
+      })
+    });
+    zod.z.object({
+      crop: zod.z.object({
+        left: zod.z.number(),
+        top: zod.z.number(),
+        width: zod.z.number().positive(),
+        height: zod.z.number().positive()
+      }).optional(),
+      content: zod.z.object({
+        width: zod.z.number().int().positive(),
+        height: zod.z.number().int().positive()
+      }),
+      fit: zod.z.enum(["stretch", "contain"]),
+      format: zod.z.enum([
+        "rgb",
+        "gray",
+        "jpeg"
+      ])
+    });
+    var FrameRefSchema = zod.z.object({
+      registryId: zod.z.string().min(1),
+      id: zod.z.string().min(1),
+      width: zod.z.number().int().positive(),
+      height: zod.z.number().int().positive(),
+      format: zod.z.enum(["rgb", "gray"]),
+      timestamp: zod.z.number(),
+      capturedAt: zod.z.number().optional()
+    });
+    var ModelFormatSchema$1 = zod.z.enum([
+      "onnx",
+      "coreml",
+      "openvino",
+      "tflite",
+      "pt",
+      "gguf"
+    ]);
+    var PipelineSlotSchema = zod.z.enum([
+      "detector",
+      "cropper",
+      "classifier",
+      "refiner",
+      "audio-classifier"
+    ]);
+    var PipelineEngineChoiceSchema = zod.z.object({
+      runtime: zod.z.enum(["node", "python"]),
+      backend: zod.z.string(),
+      format: ModelFormatSchema$1,
+      device: zod.z.string().optional()
+    });
+    var EngineDeviceInfoSchema = zod.z.object({
+      id: zod.z.string(),
+      label: zod.z.string(),
+      description: zod.z.string().optional()
+    });
+    var AvailableEngineSchema = zod.z.object({
+      engine: PipelineEngineChoiceSchema,
+      devices: zod.z.array(EngineDeviceInfoSchema).readonly(),
+      defaultDevice: zod.z.string()
+    });
+    var PipelineDefaultStepSchema = zod.z.lazy(() => zod.z.object({
+      addonId: zod.z.string(),
+      addonName: zod.z.string(),
+      slot: PipelineSlotSchema,
+      inputClasses: zod.z.array(zod.z.string()).readonly(),
+      outputClasses: zod.z.array(zod.z.string()).readonly(),
+      enabled: zod.z.boolean(),
+      modelId: zod.z.string(),
+      children: zod.z.array(PipelineDefaultStepSchema).readonly(),
+      group: zod.z.string().optional(),
+      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }));
+    var PipelineTemplateStepSchema = zod.z.lazy(() => zod.z.object({
+      addonId: zod.z.string(),
+      enabled: zod.z.boolean(),
+      modelId: zod.z.string(),
+      children: zod.z.array(PipelineTemplateStepSchema).readonly(),
+      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }));
+    var PipelineTemplateSchema$1 = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      createdAt: zod.z.string(),
+      updatedAt: zod.z.string(),
+      engine: PipelineEngineChoiceSchema,
+      steps: zod.z.array(PipelineTemplateStepSchema).readonly()
+    });
+    var PipelineModelOptionSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      formats: zod.z.record(zod.z.string(), zod.z.object({
+        downloaded: zod.z.boolean(),
+        sizeMB: zod.z.number()
+      })),
+      group: ModelVariantGroupSchema.optional(),
+      legacy: zod.z.boolean().optional(),
+      provider: ModelProviderIdSchema.optional()
+    });
+    var ConfigFieldBridge = zod.z.custom();
+    var PipelineAddonSchemaSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      slot: PipelineSlotSchema,
+      inputClasses: zod.z.array(zod.z.string()).readonly(),
+      outputClasses: zod.z.array(zod.z.string()).readonly(),
+      childSlots: zod.z.array(PipelineSlotSchema).readonly(),
+      models: zod.z.array(PipelineModelOptionSchema).readonly(),
+      defaultModelId: zod.z.string(),
+      defaultModelIdByFormat: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+      enabledByDefault: zod.z.boolean().optional(),
+      backfillIntoExistingOverrides: zod.z.boolean().optional(),
+      defaultConfidence: zod.z.number(),
+      group: zod.z.string().optional(),
+      configSchema: zod.z.array(ConfigFieldBridge).readonly().optional()
+    });
+    var PipelineSlotSchemaSchema = zod.z.object({
+      id: PipelineSlotSchema,
+      label: zod.z.string(),
+      priority: zod.z.number(),
+      parentSlot: PipelineSlotSchema.nullable(),
+      addons: zod.z.array(PipelineAddonSchemaSchema).readonly()
+    });
+    var PipelineSchemaSchema = zod.z.object({
+      availableEngines: zod.z.array(AvailableEngineSchema).readonly(),
+      selectedEngine: PipelineEngineChoiceSchema,
+      slots: zod.z.array(PipelineSlotSchemaSchema).readonly()
+    });
+    var EngineProvisioningSchema = zod.z.object({
+      runtimeId: zod.z.enum([
+        "onnx",
+        "openvino",
+        "coreml",
+        "edgetpu"
+      ]).nullable(),
+      device: zod.z.string().nullable(),
+      state: zod.z.enum([
+        "idle",
+        "installing",
+        "verifying",
+        "ready",
+        "failed"
+      ]),
+      progress: zod.z.number().optional(),
+      error: zod.z.string().optional(),
+      nextRetryAt: zod.z.number().optional(),
+      /**
+      * Gate A (config-correctness gate at engine change): human-readable
+      * config issues surfaced EAGERLY when the node's engine changes — model
+      * substitutions ("chose X, running Y") and zero-build steps ("no model
+      * has a <format> build"). Additive/optional: informational only, never
+      * enforced here — `assertEngineReady` (readiness) still gates inference.
+      * Absent/empty when the node-default tree resolves cleanly.
+      */
+      configIssues: zod.z.array(zod.z.string()).optional()
+    });
+    var PipelineStepInputSchema = zod.z.lazy(() => zod.z.object({
+      addonId: zod.z.string(),
+      modelId: zod.z.string().optional(),
+      enabled: zod.z.boolean().default(true),
+      children: zod.z.array(PipelineStepInputSchema).optional(),
+      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+      jumpDeviceKey: zod.z.string().optional()
+    }));
+    var ModelSubstitutionSchema = zod.z.object({
+      addonId: zod.z.string(),
+      chosen: zod.z.string(),
+      running: zod.z.string(),
+      format: zod.z.string()
+    });
+    var PipelineValidationIssueSchema = zod.z.object({
+      addonId: zod.z.string(),
+      kind: zod.z.enum(["unknown-addon", "no-format-build"]),
+      detail: zod.z.string()
+    });
+    var PipelineValidationResultSchema = zod.z.object({
+      ok: zod.z.boolean(),
+      issues: zod.z.array(PipelineValidationIssueSchema).readonly(),
+      substitutions: zod.z.array(ModelSubstitutionSchema).readonly(),
+      /** The node's `currentEngine.format` this validation ran against. */
+      format: zod.z.string()
+    });
+    var ReferenceImageEntrySchema = zod.z.object({
+      filename: zod.z.string(),
+      stepIds: zod.z.array(zod.z.string()).readonly().optional()
+    });
+    var ReferenceImageBodySchema = zod.z.object({
+      base64: zod.z.string(),
+      filename: zod.z.string()
+    });
+    var ReferenceAudioEntrySchema = zod.z.object({
+      filename: zod.z.string(),
+      sizeKb: zod.z.number()
+    });
+    var ReferenceAudioBodySchema = zod.z.object({ base64: zod.z.string() });
+    var AudioBackendSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      description: zod.z.string(),
+      available: zod.z.boolean(),
+      /**
+      * Raw classifier labels this backend can emit (e.g. YAMNet's
+      * 521-class set or Apple SoundAnalysis's 303-class set). Used by
+      * the benchmark UI to populate the `enabledMicroClasses` filter
+      * specific to the selected backend without a separate fetch.
+      */
+      rawLabels: zod.z.array(zod.z.string()).readonly().optional()
+    });
+    var AudioCapabilitiesSchema = zod.z.object({
+      activeBackend: zod.z.string(),
+      availableBackends: zod.z.array(AudioBackendSchema).readonly(),
+      sampleRate: zod.z.number(),
+      chunkDurationMs: zod.z.number()
+    });
+    var DownloadModelResultSchema = zod.z.object({
+      filePath: zod.z.string(),
+      sizeMB: zod.z.number(),
+      durationMs: zod.z.number()
+    });
+    var AudioTestResultSchema = zod.z.object({
+      success: zod.z.boolean(),
+      error: zod.z.string().optional(),
+      frame: zod.z.custom().optional()
+    });
+    var PipelineConfigBridge = zod.z.custom();
+    var ConfigUISchemaBridge = zod.z.custom();
+    var ConfigUISchemaNullableBridge = zod.z.custom();
+    var InferenceCapabilitiesBridge = zod.z.custom();
+    var ModelAvailabilityListBridge = zod.z.custom();
+    var PipelineRunResultBridge = zod.z.custom();
+    var pipelineExecutorCapability = {
+      name: "pipeline-executor",
+      scope: "system",
+      mode: "singleton",
+      methods: {
+        getAvailableEngines: method(zod.z.void(), zod.z.array(PipelineEngineChoiceSchema)),
+        getSelectedEngine: method(zod.z.void(), PipelineEngineChoiceSchema),
+        getDefaultSteps: method(PipelineEngineChoiceSchema, zod.z.array(PipelineDefaultStepSchema)),
+        /**
+        * Per-node detection-engine provisioning snapshot. Returns the live
+        * state of the lazy runtime-provisioning machine on `nodeId`
+        * (idle / installing / verifying / ready / failed). The UI pairs this
+        * one-shot query with the `pipeline.engine-provisioning` live event
+        * (emitted on every transition) to drive a per-node "engine ready?"
+        * indicator without polling. Phase 2.
+        */
+        getEngineProvisioning: method(zod.z.object({ nodeId: zod.z.string() }), EngineProvisioningSchema),
+        getVideoPipelineSteps: method(zod.z.void(), zod.z.record(zod.z.string(), zod.z.object({
+          modelId: zod.z.string(),
+          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
+        }))),
+        setVideoPipelineSteps: method(zod.z.object({ steps: zod.z.record(zod.z.string(), zod.z.object({
+          modelId: zod.z.string(),
+          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
+        })) }), zod.z.object({ success: zod.z.literal(true) }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        /**
+        * Clear THIS node's executor-side PER-DEVICE settings stores (the
+        * per-camera step overrides the object-detection root reads via
+        * `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
+        * generated cap-router strips it (default `nodeIdMode: 'routing'`) and
+        * dispatches to that node, so the provider method runs ON the target
+        * node and receives no `nodeId`.
+        *
+        * This is the slimmed executor leg of the orchestrator's
+        * `resetNodePipelineDefaults` flow (which owns the real reset: node
+        * addonDefaults pins + per-camera orchestrator overrides). The legacy
+        * `resetToDefault` — which reset a persisted global step-tree seed
+        * nothing in the live per-camera path read — was removed together with
+        * that seed.
+        */
+        clearDeviceOverrides: method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({
+          success: zod.z.literal(true),
+          clearedDevices: zod.z.number()
+        }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        /**
+        * Which of THIS node's inference devices the executor currently refuses,
+        * and why. `nodeId` is the ROUTING key (stripped by the generated router).
+        *
+        * The channel that did not exist. Pool health was known only inside the
+        * detection addon and was an input to no routing decision anywhere: the
+        * per-dispatch capability gate is keyed on model FORMAT and so can never
+        * separate `openvino:gpu` from `openvino:npu`, and the orchestrator's live
+        * eligibility probe (`platformProbe.getCapabilities`) answers about
+        * HARDWARE — which was present throughout. So when the hub's `openvino:gpu`
+        * Python worker was SIGABRT'd by the Intel GPU plugin on 2026-08-25, the
+        * balancer went on handing that dead pool cameras by rotation for 31 hours:
+        * ~370 000 `PoolWorker[w0]: not initialized` lines, every frame lost.
+        *
+        * Read semantics the caller depends on, and which the provider guarantees:
+        * this is a synchronous read of in-memory state. It never probes hardware,
+        * never spawns a pool and never throws — an EMPTY `unhealthy` means "asked,
+        * nothing is refused", which is what re-admits a device. A read that FAILS
+        * (node offline, version skew) must therefore be distinguishable from an
+        * empty answer, and it is: it rejects.
+        */
+        getInferenceDeviceHealth: method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({ unhealthy: zod.z.array(zod.z.object({
+          /** `<backend>:<device>`, e.g. `openvino:gpu`. */
+          deviceKey: zod.z.string(),
+          /**
+          * `failed` — the per-device restart budget is exhausted; no pool
+          * will be spawned until an operator re-arms it or the runner
+          * respawns. `backoff` — under budget, waiting out the backoff (or
+          * a cached pool observed dead and not yet condemned).
+          */
+          state: zod.z.enum(["failed", "backoff"]),
+          /** Epoch ms of the death that produced this state. */
+          since: zod.z.number(),
+          /** Pool deaths inside the current window. */
+          deaths: zod.z.number(),
+          /** The last death's message. */
+          lastError: zod.z.string()
+        })).readonly() })),
+        /**
+        * Re-arm a terminally `failed` inference device on `nodeId`: forget its
+        * restart budget so the next dispatch builds a fresh pool.
+        *
+        * The terminal state is deliberate (the abort it bounds is deterministic —
+        * an automatic probation would just respawn Python forever, more slowly),
+        * and a terminal state an operator cannot leave is a silent fault. This is
+        * the way out. `rearmed:false` means there was nothing to forget.
+        */
+        rearmInferenceDevice: method(zod.z.object({
+          nodeId: zod.z.string(),
+          deviceKey: zod.z.string()
+        }), zod.z.object({ rearmed: zod.z.boolean() }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        getSchema: method(zod.z.void(), PipelineSchemaSchema),
+        getGlobalSteps: method(zod.z.void(), zod.z.array(PipelineDefaultStepSchema).readonly().nullable()),
+        getGlobalPipelineConfig: method(zod.z.void(), PipelineConfigBridge),
+        getOrchestratorConfigSchema: method(zod.z.void(), ConfigUISchemaBridge),
+        /**
+        * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
+        * node's `currentEngine.format` — resolves `steps` the same way the
+        * runtime dispatch path would, and reports what WOULD happen without
+        * touching any node-global state. Called by the orchestrator at attach
+        * time (`attachOn`), node-pinned to the TARGET node, so config problems
+        * surface BEFORE `pipelineRunner.attachCamera` rather than at the first
+        * per-frame resolve. `ok` is false iff `issues` is non-empty (both
+        * `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
+        * is informational (a degraded-but-loadable model swap) and never
+        * affects `ok`. Never throws.
+        */
+        validatePipeline: method(zod.z.object({ steps: zod.z.array(PipelineStepInputSchema) }), PipelineValidationResultSchema),
+        listTemplates: method(zod.z.void(), zod.z.array(PipelineTemplateSchema$1).readonly()),
+        saveTemplate: method(zod.z.object({
+          name: zod.z.string(),
+          steps: zod.z.array(PipelineTemplateStepSchema).readonly(),
+          engine: PipelineEngineChoiceSchema
+        }), PipelineTemplateSchema$1, { kind: "mutation" }),
+        updateTemplate: method(zod.z.object({
+          id: zod.z.string(),
+          name: zod.z.string().optional(),
+          steps: zod.z.array(PipelineTemplateStepSchema).readonly().optional()
+        }), PipelineTemplateSchema$1, { kind: "mutation" }),
+        deleteTemplate: method(zod.z.object({ id: zod.z.string() }), zod.z.void(), { kind: "mutation" }),
+        getCapabilities: method(zod.z.void(), InferenceCapabilitiesBridge),
+        getAddonModels: method(zod.z.object({ addonId: zod.z.string() }), ModelAvailabilityListBridge),
+        downloadModel: method(zod.z.object({
+          addonId: zod.z.string(),
+          modelId: zod.z.string(),
+          format: ModelFormatSchema$1
+        }), DownloadModelResultSchema, { kind: "mutation" }),
+        deleteModel: method(zod.z.object({
+          addonId: zod.z.string(),
+          modelId: zod.z.string(),
+          format: ModelFormatSchema$1
+        }), zod.z.object({ success: zod.z.literal(true) }), { kind: "mutation" }),
+        /**
+        * Stateless single-frame execution. Callers (runner, benchmark) pass
+        * the complete `engine` + `steps` tree; the executor holds no state
+        * about cameras or saved pipelines.
+        *
+        * `engine` is optional during the migration window to preserve the
+        * legacy call shape used by existing benchmark code; once all
+        * callers pass it explicitly we make it required.
+        *
+        * Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
+        * `referenceImage` must be provided:
+        *  - `frame`: runtime dispatch path (runner → decoded broker frame).
+        *    Carries the raw buffer, dimensions, and format; the executor
+        *    uses it directly without base64 round-tripping.
+        *  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
+        *    decoded frame. Both runner and executor are hub-local processes
+        *    sharing `/dev/shm`, so the executor maps the named segment and
+        *    reads the pixels back zero-copy — eliminating the ~1.2MB
+        *    re-serialisation over UDS/MsgPack the `frame` path pays per call.
+        *    High-risk: the FrameRing is a latest-wins seqlock with no
+        *    refcount, so a recycled slot yields a null read; the executor
+        *    then degrades to an empty result and the runner ships pixels via
+        *    `frame` as the fallback (queue-depth gated on the runner side).
+        *  - `imageBase64`: one-shot test path (benchmark ImageTab).
+        *  - `referenceImage`: named file from the reference-image store.
+        */
+        runPipeline: method(zod.z.object({
+          engine: PipelineEngineChoiceSchema.optional(),
+          steps: zod.z.array(PipelineStepInputSchema).min(1),
+          frame: FrameInputSchema.optional(),
+          /**
+          * Process-local lazy frame. Valid only when caller and provider resolve
+          * in the same execution-group process; split/cross-node callers use
+          * `frame`/`image` inline compatibility instead.
+          */
+          frameRef: FrameRefSchema.optional(),
+          /**
+          * CB5 shm passthrough — a `FrameHandle` naming the same ring slot
+          * the decoded pixels live in. One more member of the one-of
+          * frame/frameHandle/image/imageBase64/referenceImage group.
+          */
+          frameHandle: FrameHandleSchema.optional(),
+          imageBase64: zod.z.string().optional(),
+          /**
+          * Binary JPEG bytes — preferred over `imageBase64` on internal
+          * hops (hub → forked worker via Moleculer MsgPack) because it
+          * skips the 33% base64 overhead + the per-call base64 decode on
+          * the detection-pipeline worker. Callers can pass either; exactly
+          * one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
+          */
+          image: zod.z.instanceof(Uint8Array).optional(),
+          referenceImage: zod.z.string().optional(),
+          deviceId: zod.z.number().optional(),
+          sessionId: zod.z.string().optional(),
+          /**
+          * Execution plane. 'full' (default) runs the whole tree — benchmark,
+          * reference-image, and detail-subtree calls. 'frame' is the live
+          * per-frame dispatch: ONLY root-plane steps run; crop children
+          * (inputClasses ≠ null) are skipped and served per-track via
+          * pipelineRunner.runDetailSubtree (two-plane design).
+          */
+          plane: zod.z.enum(["full", "frame"]).optional(),
+          /**
+          * Inference-device selector (Phase 2 multi-device). Format
+          * `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
+          * Omitted ⇒ the runner's default device (current single-engine
+          * behaviour). Selects WHICH device pool of the node runs the call.
+          */
+          deviceKey: zod.z.string().optional(),
+          /**
+          * Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
+          * when the parent crop was resolved from the frame's retained NATIVE
+          * surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
+          * child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
+          * resolution from that surface — the SAME quality path faces already
+          * had — instead of the downscaled parent tile. `handle` keys the native
+          * surface (node-pinned to its owner); `cropFrameSpace` is the parent
+          * crop's padded/clamped rectangle in FRAME-space pixels, used to compose
+          * the executor's crop-normalized child ROI back into frame-normalized
+          * coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
+          * of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
+          * (today's behaviour on the fallback path).
+          */
+          nativeCropRef: NativeCropRefSchema.optional()
+        }), PipelineRunResultBridge, { kind: "mutation" }),
+        /**
+        * Batched run — N raw frames packed into one cap call. The provider
+        * routes the batch through `SharedInferencePool.inferBatch`
+        * (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
+        * envelope cost is amortised N:1 vs N concurrent `runPipeline`
+        * calls. Single root step + uniform model assumed; trees with crop
+        * children fall back to sequential execution.
+        *
+        * Used by `scripts/bench-batch-style.mts` for batch benchmarking —
+        * N frames in one call to amortise per-call IPC overhead.
+        */
+        runPipelineBatch: method(zod.z.object({
+          engine: PipelineEngineChoiceSchema.optional(),
+          steps: zod.z.array(PipelineStepInputSchema).min(1),
+          frames: zod.z.array(FrameInputSchema).min(1).max(255),
+          deviceId: zod.z.number().optional(),
+          sessionId: zod.z.string().optional(),
+          /**
+          * Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
+          * the batch to the Python pool's bench preprocess cache
+          * (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
+          * preprocessed ONCE and every later inference is a pure-inference cache
+          * hit — the sustained-throughput run measures inference, not
+          * decode+preprocess+infer. Omitted/0 for live frames (all different →
+          * full preprocess every call, correct). Fresh per sustained run;
+          * released via `uncacheFrame`.
+          */
+          frameId: zod.z.number().int().nonnegative().optional(),
+          /** Inference-device selector (Phase 2 multi-device); see runPipeline. */
+          deviceKey: zod.z.string().optional()
+        }), zod.z.object({ results: zod.z.array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
+        /**
+        * Cache a raw frame inside the Python inference pool's memory.
+        * Returns a numeric `frameId` that `inferCached` references —
+        * subsequent calls send only 5 bytes through the pipe instead of
+        * 1.2MB raw data, eliminating the pipe transfer bottleneck.
+        */
+        cacheFrameInPool: method(zod.z.object({
+          data: zod.z.instanceof(Uint8Array),
+          width: zod.z.number().int().positive(),
+          height: zod.z.number().int().positive(),
+          format: zod.z.enum([
+            "rgb",
+            "bgr",
+            "gray"
+          ])
+        }), zod.z.object({
+          frameId: zod.z.number(),
+          width: zod.z.number(),
+          height: zod.z.number()
+        }), { kind: "mutation" }),
+        /**
+        * Run inference on a previously cached frame. Sends only 5 bytes
+        * (model_idx + frameId) through the IPC pipe — eliminates the
+        * ~35ms per-call overhead of transferring 1.2MB raw data.
+        */
+        inferCached: method(zod.z.object({
+          stepId: zod.z.string(),
+          frameId: zod.z.number().int()
+        }), zod.z.record(zod.z.string(), zod.z.unknown()), { kind: "mutation" }),
+        /**
+        * Release a cached frame from the Python pool's memory.
+        */
+        uncacheFrame: method(zod.z.object({ frameId: zod.z.number().int() }), zod.z.void(), { kind: "mutation" }),
+        /** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
+        getEffectiveTuning: method(zod.z.void(), zod.z.object({
+          batchMode: zod.z.string(),
+          windowMs: zod.z.number(),
+          maxBatchSize: zod.z.number(),
+          concurrency: zod.z.number()
+        })),
+        /**
+        * List every EngineFactory currently loaded in this executor's RAM,
+        * with the models resident and a coarse "in use" marker derived from
+        * ongoing inference activity. Used by the Pipeline page Engines tab.
+        */
+        listLoadedEngines: method(zod.z.void(), zod.z.array(zod.z.object({
+          engineKey: zod.z.string(),
+          engine: PipelineEngineChoiceSchema,
+          modelsLoaded: zod.z.array(zod.z.string()).readonly(),
+          inUseByCameras: zod.z.array(zod.z.number()).readonly(),
+          /**
+          * Origin of this resident factory.
+          *  - `runtime`       — main camera-serving engine (no idle TTL).
+          *  - `warm-override` — benchmark/test override held in the warm
+          *                      cache; auto-disposed after the idle TTL.
+          *  - `device-pool`   — a concurrent per-device pool (Phase 2
+          *                      multi-device, keyed by `deviceKey`) resolved
+          *                      via `resolveDeviceFactory`. Runs alongside the
+          *                      `runtime` engine on a DIFFERENT accelerator
+          *                      (NPU / iGPU / Coral) — this is how the
+          *                      Engines tab shows all pools running at once.
+          */
+          kind: zod.z.enum([
+            "runtime",
+            "warm-override",
+            "device-pool"
+          ]),
+          /** Native pid of the underlying Python pool (null when no pool). */
+          poolPid: zod.z.number().nullable(),
+          /** ms since this factory was last used (null when not warm-tracked). */
+          idleMs: zod.z.number().nullable(),
+          /** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
+          idleTtlMs: zod.z.number().nullable()
+        })).readonly()),
+        /** Warm up an engine without running a frame. No-op if already loaded. */
+        spinEngine: method(zod.z.object({ engine: PipelineEngineChoiceSchema }), zod.z.object({ success: zod.z.literal(true) }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        /**
+        * Unload an engine from RAM. `force:true` unloads even when cameras
+        * are actively using it (they re-spin on next frame). Default is
+        * gated — returns `{success:false, reason}` when in use.
+        */
+        killEngine: method(zod.z.object({
+          engine: PipelineEngineChoiceSchema,
+          force: zod.z.boolean().optional()
+        }), zod.z.object({
+          success: zod.z.boolean(),
+          reason: zod.z.string().optional()
+        }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        listReferenceImages: method(zod.z.void(), zod.z.array(ReferenceImageEntrySchema).readonly()),
+        getReferenceImage: method(zod.z.object({ filename: zod.z.string() }), ReferenceImageBodySchema.nullable()),
+        getReferenceAudioFiles: method(zod.z.void(), zod.z.array(ReferenceAudioEntrySchema).readonly()),
+        getReferenceAudio: method(zod.z.object({ filename: zod.z.string() }), ReferenceAudioBodySchema.nullable()),
+        getAudioCapabilities: method(zod.z.void(), AudioCapabilitiesSchema),
+        runAudioTest: method(zod.z.object({
+          addonId: zod.z.string(),
+          modelId: zod.z.string(),
+          filename: zod.z.string().optional(),
+          settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+        }), AudioTestResultSchema, { kind: "mutation" }),
+        getDetectionConfigSchema: method(zod.z.void(), ConfigUISchemaNullableBridge)
+      }
+    };
+    var ZoneRuleModeEnum = zod.z.enum(["include", "exclude"]);
+    var ZoneRuleSchema = zod.z.object({
+      /** Stable rule id — survives edits, used by the UI for diffing. */
+      id: zod.z.string(),
+      /** Optional human-readable label rendered in the rule editor. */
+      name: zod.z.string().optional(),
+      /** Zones this rule targets. The rule's `mode` applies to ALL
+      *  listed zones (OR-set: a detection in any one of them counts).
+      *  At least one zone id required — a rule with no targets is a
+      *  configuration mistake and the form validator rejects it. */
+      zoneIds: zod.z.array(zod.z.string()).min(1).readonly(),
+      mode: ZoneRuleModeEnum,
+      /**
+      * Class names this rule applies to. Empty / undefined ⇒ rule
+      * applies to every class. Class strings match the `macroClass`
+      * field on detections (e.g. `person`, `car`, `dog`).
+      */
+      classFilter: zod.z.array(zod.z.string()).readonly().optional(),
+      /**
+      * Minimum bbox/mask overlap (0–1) with any of the rule's zones
+      * required to consider an entity "in the zone". Defaults to the
+      * consumer's stage default when omitted. Kept for back-compat with
+      * existing per-rule overrides; new operators pick the value via
+      * `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
+      * set, the lower-level engine reads it as a 0–1 fraction.
+      */
+      overlapThreshold: zod.z.number().min(0).max(1).optional(),
+      /**
+      * Operator-friendly version of `overlapThreshold` — the percentage
+      * of the detection's bbox that must lie inside the zone for the
+      * rule to match. Documented default is 85%; the engine substitutes
+      * that when the field is omitted (kept optional so existing rules
+      * stored without it stay valid).
+      *
+      * When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
+      * rule, the engine prefers `bboxInclusionPct` because it's the
+      * field exposed in the UI. Internally both feed the same gate.
+      */
+      bboxInclusionPct: zod.z.number().min(0).max(100).optional(),
+      /**
+      * When `true` and a detection has a segmentation mask, use the
+      * mask for overlap instead of the bbox. Detection-stage only;
+      * motion rules ignore this field.
+      */
+      preferMask: zod.z.boolean().optional(),
+      /**
+      * Soft-toggle: `false` disables the rule without deleting it.
+      * Defaults to `true` so operators creating a rule via the UI
+      * see it active immediately.
+      */
+      enabled: zod.z.boolean().default(true)
+    });
+    zod.z.array(ZoneRuleSchema).readonly();
+    var ZoneKindEnum = zod.z.enum(["polygon", "tripwire"]);
+    var PolygonPointSchema = zod.z.object({
+      x: zod.z.number(),
+      y: zod.z.number()
+    });
+    var ZoneSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      kind: ZoneKindEnum.default("polygon"),
+      /** Polygon vertices, fraction of frame (0–1). */
+      polygon: zod.z.array(PolygonPointSchema).readonly(),
+      /** Visual color for UI rendering. */
+      color: zod.z.string().default("#3b82f6")
+    });
+    var zonesCapability = {
+      name: "zones",
+      scope: "device",
+      mode: "singleton",
+      deviceTypes: [DeviceType.Camera],
+      methods: {
+        listZones: method(zod.z.object({ deviceId: zod.z.number() }), zod.z.array(ZoneSchema).readonly()),
+        addZone: method(zod.z.object({
+          deviceId: zod.z.number(),
+          zone: ZoneSchema
+        }), zod.z.void(), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        removeZone: method(zod.z.object({
+          deviceId: zod.z.number(),
+          zoneId: zod.z.string()
+        }), zod.z.void(), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        updateZone: method(zod.z.object({
+          deviceId: zod.z.number(),
+          zone: ZoneSchema
+        }), zod.z.void(), {
+          kind: "mutation",
+          auth: "admin"
+        })
+      },
+      /**
+      * Runtime-state slice — the live zone catalogue mirrored by the
+      * orchestrator on every CRUD mutation. Consumers read via
+      * `device.state.zones.value` / `.watch(...)` without round-tripping
+      * the cap, and the codegen DeviceProxy auto-wires the reactive
+      * handle. Slice shape is `{ zones: Zone[] }` so future extensions
+      * (e.g. zone groupings) can sit alongside the polygon list.
+      */
+      runtimeState: zod.z.object({ zones: zod.z.array(ZoneSchema).readonly() }),
+      /**
+      * Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
+      *
+      * See `RuntimeStateDurability`. Enforced by
+      * `scripts/check-runtime-state-durability.ts`.
+      */
+      durability: "restored"
+    };
     var TrackStateSchema = zod.z.enum([
       "new",
       "entered",
@@ -35441,6 +36191,25 @@ var require_dist_D5Jhh8Vk = __commonJS({
       /** Present when the pass ended by throwing. */
       error: zod.z.string().nullable()
     });
+    var ReplayFrameInputSchema = zod.z.object({
+      timestamp: zod.z.number(),
+      frame: PipelineRunResultBridge
+    });
+    var ReplayTrackSchema = zod.z.object({
+      className: zod.z.string(),
+      firstSeenMs: zod.z.number(),
+      lastSeenMs: zod.z.number(),
+      /** Bbox of the track's FIRST matched detection, pixel-space in the clip's
+      *  frame — a representative box for the diff's `(className, window, IoU)`
+      *  pairing (`replay-diff.ts`). A replay does not need the full per-frame
+      *  trajectory production's `Track.positions` keeps. */
+      bbox: BoundingBoxSchema,
+      /** How many of the input frames this track matched a real detection on
+      *  (never a coasted/extrapolated frame) — the replay's own signal for "how
+      *  solid is this track", cheaper than re-deriving it from a trajectory. */
+      framesMatched: zod.z.number().int()
+    });
+    var RunReplayFrameProcessorResultSchema = zod.z.object({ tracks: zod.z.array(ReplayTrackSchema).readonly() });
     var pipelineAnalyticsCapability = {
       name: "pipeline-analytics",
       scope: "device",
@@ -35931,6 +36700,32 @@ var require_dist_D5Jhh8Vk = __commonJS({
           kind: "mutation",
           auth: "admin"
         }),
+        /**
+        * The FrameProcessor pass of a replay run — see the `Replay` section
+        * above this capability's definition for why this is not the
+        * `processFrame` method this file's header says pipeline-analytics does
+        * not have.
+        *
+        * Constructs a FRESH `FrameProcessor` for `(deviceId, source)`, feeds it
+        * `frames` IN THE ORDER GIVEN (the caller is responsible for time
+        * ordering — this method does not sort), and returns the tracks it
+        * produced. Zero persistence: no `TrackStore`, no event bus, no media
+        * capture. `zones` / `detectionRules` are the run's OWN zone set —
+        * typically the camera's real zones plus an ephemeral overlay
+        * (`addon-benchmark`'s `replay-plan.ts`), never read from or written to
+        * the `zones` capability by this method itself.
+        */
+        runReplayFrameProcessor: method(zod.z.object({
+          deviceId: zod.z.number(),
+          source: DetectionSourceSchema,
+          zones: zod.z.array(ZoneSchema).readonly().optional(),
+          detectionRules: zod.z.array(ZoneRuleSchema).readonly().optional(),
+          zoneMembershipMinOverlap: zod.z.number().min(0).max(1).optional(),
+          frames: zod.z.array(ReplayFrameInputSchema).min(1)
+        }), RunReplayFrameProcessorResultSchema, {
+          kind: "mutation",
+          auth: "admin"
+        }),
         /** Every annotation on a track, oldest first. */
         listRetrainAnnotations: method(zod.z.object({ trackId: zod.z.string() }), zod.z.array(RetrainAnnotationSchema).readonly(), {
           kind: "query",
@@ -36097,559 +36892,6 @@ var require_dist_D5Jhh8Vk = __commonJS({
         }) }
       }
     };
-    var NativeCropRefSchema = zod.z.object({
-      /** Handle keying the retained native surface (node-pinned to its owner). */
-      handle: FrameHandleSchema,
-      /** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
-      cropFrameSpace: zod.z.object({
-        x: zod.z.number(),
-        y: zod.z.number(),
-        w: zod.z.number(),
-        h: zod.z.number()
-      })
-    });
-    zod.z.object({
-      crop: zod.z.object({
-        left: zod.z.number(),
-        top: zod.z.number(),
-        width: zod.z.number().positive(),
-        height: zod.z.number().positive()
-      }).optional(),
-      content: zod.z.object({
-        width: zod.z.number().int().positive(),
-        height: zod.z.number().int().positive()
-      }),
-      fit: zod.z.enum(["stretch", "contain"]),
-      format: zod.z.enum([
-        "rgb",
-        "gray",
-        "jpeg"
-      ])
-    });
-    var FrameRefSchema = zod.z.object({
-      registryId: zod.z.string().min(1),
-      id: zod.z.string().min(1),
-      width: zod.z.number().int().positive(),
-      height: zod.z.number().int().positive(),
-      format: zod.z.enum(["rgb", "gray"]),
-      timestamp: zod.z.number(),
-      capturedAt: zod.z.number().optional()
-    });
-    var ModelFormatSchema$1 = zod.z.enum([
-      "onnx",
-      "coreml",
-      "openvino",
-      "tflite",
-      "pt",
-      "gguf"
-    ]);
-    var PipelineSlotSchema = zod.z.enum([
-      "detector",
-      "cropper",
-      "classifier",
-      "refiner",
-      "audio-classifier"
-    ]);
-    var PipelineEngineChoiceSchema = zod.z.object({
-      runtime: zod.z.enum(["node", "python"]),
-      backend: zod.z.string(),
-      format: ModelFormatSchema$1,
-      device: zod.z.string().optional()
-    });
-    var EngineDeviceInfoSchema = zod.z.object({
-      id: zod.z.string(),
-      label: zod.z.string(),
-      description: zod.z.string().optional()
-    });
-    var AvailableEngineSchema = zod.z.object({
-      engine: PipelineEngineChoiceSchema,
-      devices: zod.z.array(EngineDeviceInfoSchema).readonly(),
-      defaultDevice: zod.z.string()
-    });
-    var PipelineDefaultStepSchema = zod.z.lazy(() => zod.z.object({
-      addonId: zod.z.string(),
-      addonName: zod.z.string(),
-      slot: PipelineSlotSchema,
-      inputClasses: zod.z.array(zod.z.string()).readonly(),
-      outputClasses: zod.z.array(zod.z.string()).readonly(),
-      enabled: zod.z.boolean(),
-      modelId: zod.z.string(),
-      children: zod.z.array(PipelineDefaultStepSchema).readonly(),
-      group: zod.z.string().optional(),
-      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-    }));
-    var PipelineTemplateStepSchema = zod.z.lazy(() => zod.z.object({
-      addonId: zod.z.string(),
-      enabled: zod.z.boolean(),
-      modelId: zod.z.string(),
-      children: zod.z.array(PipelineTemplateStepSchema).readonly(),
-      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-    }));
-    var PipelineTemplateSchema$1 = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      createdAt: zod.z.string(),
-      updatedAt: zod.z.string(),
-      engine: PipelineEngineChoiceSchema,
-      steps: zod.z.array(PipelineTemplateStepSchema).readonly()
-    });
-    var PipelineModelOptionSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      formats: zod.z.record(zod.z.string(), zod.z.object({
-        downloaded: zod.z.boolean(),
-        sizeMB: zod.z.number()
-      })),
-      group: ModelVariantGroupSchema.optional(),
-      legacy: zod.z.boolean().optional(),
-      provider: ModelProviderIdSchema.optional()
-    });
-    var ConfigFieldBridge = zod.z.custom();
-    var PipelineAddonSchemaSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      slot: PipelineSlotSchema,
-      inputClasses: zod.z.array(zod.z.string()).readonly(),
-      outputClasses: zod.z.array(zod.z.string()).readonly(),
-      childSlots: zod.z.array(PipelineSlotSchema).readonly(),
-      models: zod.z.array(PipelineModelOptionSchema).readonly(),
-      defaultModelId: zod.z.string(),
-      defaultModelIdByFormat: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-      enabledByDefault: zod.z.boolean().optional(),
-      backfillIntoExistingOverrides: zod.z.boolean().optional(),
-      defaultConfidence: zod.z.number(),
-      group: zod.z.string().optional(),
-      configSchema: zod.z.array(ConfigFieldBridge).readonly().optional()
-    });
-    var PipelineSlotSchemaSchema = zod.z.object({
-      id: PipelineSlotSchema,
-      label: zod.z.string(),
-      priority: zod.z.number(),
-      parentSlot: PipelineSlotSchema.nullable(),
-      addons: zod.z.array(PipelineAddonSchemaSchema).readonly()
-    });
-    var PipelineSchemaSchema = zod.z.object({
-      availableEngines: zod.z.array(AvailableEngineSchema).readonly(),
-      selectedEngine: PipelineEngineChoiceSchema,
-      slots: zod.z.array(PipelineSlotSchemaSchema).readonly()
-    });
-    var EngineProvisioningSchema = zod.z.object({
-      runtimeId: zod.z.enum([
-        "onnx",
-        "openvino",
-        "coreml",
-        "edgetpu"
-      ]).nullable(),
-      device: zod.z.string().nullable(),
-      state: zod.z.enum([
-        "idle",
-        "installing",
-        "verifying",
-        "ready",
-        "failed"
-      ]),
-      progress: zod.z.number().optional(),
-      error: zod.z.string().optional(),
-      nextRetryAt: zod.z.number().optional(),
-      /**
-      * Gate A (config-correctness gate at engine change): human-readable
-      * config issues surfaced EAGERLY when the node's engine changes — model
-      * substitutions ("chose X, running Y") and zero-build steps ("no model
-      * has a <format> build"). Additive/optional: informational only, never
-      * enforced here — `assertEngineReady` (readiness) still gates inference.
-      * Absent/empty when the node-default tree resolves cleanly.
-      */
-      configIssues: zod.z.array(zod.z.string()).optional()
-    });
-    var PipelineStepInputSchema = zod.z.lazy(() => zod.z.object({
-      addonId: zod.z.string(),
-      modelId: zod.z.string().optional(),
-      enabled: zod.z.boolean().default(true),
-      children: zod.z.array(PipelineStepInputSchema).optional(),
-      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-      jumpDeviceKey: zod.z.string().optional()
-    }));
-    var ModelSubstitutionSchema = zod.z.object({
-      addonId: zod.z.string(),
-      chosen: zod.z.string(),
-      running: zod.z.string(),
-      format: zod.z.string()
-    });
-    var PipelineValidationIssueSchema = zod.z.object({
-      addonId: zod.z.string(),
-      kind: zod.z.enum(["unknown-addon", "no-format-build"]),
-      detail: zod.z.string()
-    });
-    var PipelineValidationResultSchema = zod.z.object({
-      ok: zod.z.boolean(),
-      issues: zod.z.array(PipelineValidationIssueSchema).readonly(),
-      substitutions: zod.z.array(ModelSubstitutionSchema).readonly(),
-      /** The node's `currentEngine.format` this validation ran against. */
-      format: zod.z.string()
-    });
-    var ReferenceImageEntrySchema = zod.z.object({
-      filename: zod.z.string(),
-      stepIds: zod.z.array(zod.z.string()).readonly().optional()
-    });
-    var ReferenceImageBodySchema = zod.z.object({
-      base64: zod.z.string(),
-      filename: zod.z.string()
-    });
-    var ReferenceAudioEntrySchema = zod.z.object({
-      filename: zod.z.string(),
-      sizeKb: zod.z.number()
-    });
-    var ReferenceAudioBodySchema = zod.z.object({ base64: zod.z.string() });
-    var AudioBackendSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      description: zod.z.string(),
-      available: zod.z.boolean(),
-      /**
-      * Raw classifier labels this backend can emit (e.g. YAMNet's
-      * 521-class set or Apple SoundAnalysis's 303-class set). Used by
-      * the benchmark UI to populate the `enabledMicroClasses` filter
-      * specific to the selected backend without a separate fetch.
-      */
-      rawLabels: zod.z.array(zod.z.string()).readonly().optional()
-    });
-    var AudioCapabilitiesSchema = zod.z.object({
-      activeBackend: zod.z.string(),
-      availableBackends: zod.z.array(AudioBackendSchema).readonly(),
-      sampleRate: zod.z.number(),
-      chunkDurationMs: zod.z.number()
-    });
-    var DownloadModelResultSchema = zod.z.object({
-      filePath: zod.z.string(),
-      sizeMB: zod.z.number(),
-      durationMs: zod.z.number()
-    });
-    var AudioTestResultSchema = zod.z.object({
-      success: zod.z.boolean(),
-      error: zod.z.string().optional(),
-      frame: zod.z.custom().optional()
-    });
-    var PipelineConfigBridge = zod.z.custom();
-    var ConfigUISchemaBridge = zod.z.custom();
-    var ConfigUISchemaNullableBridge = zod.z.custom();
-    var InferenceCapabilitiesBridge = zod.z.custom();
-    var ModelAvailabilityListBridge = zod.z.custom();
-    var PipelineRunResultBridge = zod.z.custom();
-    var pipelineExecutorCapability = {
-      name: "pipeline-executor",
-      scope: "system",
-      mode: "singleton",
-      methods: {
-        getAvailableEngines: method(zod.z.void(), zod.z.array(PipelineEngineChoiceSchema)),
-        getSelectedEngine: method(zod.z.void(), PipelineEngineChoiceSchema),
-        getDefaultSteps: method(PipelineEngineChoiceSchema, zod.z.array(PipelineDefaultStepSchema)),
-        /**
-        * Per-node detection-engine provisioning snapshot. Returns the live
-        * state of the lazy runtime-provisioning machine on `nodeId`
-        * (idle / installing / verifying / ready / failed). The UI pairs this
-        * one-shot query with the `pipeline.engine-provisioning` live event
-        * (emitted on every transition) to drive a per-node "engine ready?"
-        * indicator without polling. Phase 2.
-        */
-        getEngineProvisioning: method(zod.z.object({ nodeId: zod.z.string() }), EngineProvisioningSchema),
-        getVideoPipelineSteps: method(zod.z.void(), zod.z.record(zod.z.string(), zod.z.object({
-          modelId: zod.z.string(),
-          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
-        }))),
-        setVideoPipelineSteps: method(zod.z.object({ steps: zod.z.record(zod.z.string(), zod.z.object({
-          modelId: zod.z.string(),
-          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
-        })) }), zod.z.object({ success: zod.z.literal(true) }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        /**
-        * Clear THIS node's executor-side PER-DEVICE settings stores (the
-        * per-camera step overrides the object-detection root reads via
-        * `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
-        * generated cap-router strips it (default `nodeIdMode: 'routing'`) and
-        * dispatches to that node, so the provider method runs ON the target
-        * node and receives no `nodeId`.
-        *
-        * This is the slimmed executor leg of the orchestrator's
-        * `resetNodePipelineDefaults` flow (which owns the real reset: node
-        * addonDefaults pins + per-camera orchestrator overrides). The legacy
-        * `resetToDefault` — which reset a persisted global step-tree seed
-        * nothing in the live per-camera path read — was removed together with
-        * that seed.
-        */
-        clearDeviceOverrides: method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({
-          success: zod.z.literal(true),
-          clearedDevices: zod.z.number()
-        }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        getSchema: method(zod.z.void(), PipelineSchemaSchema),
-        getGlobalSteps: method(zod.z.void(), zod.z.array(PipelineDefaultStepSchema).readonly().nullable()),
-        getGlobalPipelineConfig: method(zod.z.void(), PipelineConfigBridge),
-        getOrchestratorConfigSchema: method(zod.z.void(), ConfigUISchemaBridge),
-        /**
-        * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
-        * node's `currentEngine.format` — resolves `steps` the same way the
-        * runtime dispatch path would, and reports what WOULD happen without
-        * touching any node-global state. Called by the orchestrator at attach
-        * time (`attachOn`), node-pinned to the TARGET node, so config problems
-        * surface BEFORE `pipelineRunner.attachCamera` rather than at the first
-        * per-frame resolve. `ok` is false iff `issues` is non-empty (both
-        * `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
-        * is informational (a degraded-but-loadable model swap) and never
-        * affects `ok`. Never throws.
-        */
-        validatePipeline: method(zod.z.object({ steps: zod.z.array(PipelineStepInputSchema) }), PipelineValidationResultSchema),
-        listTemplates: method(zod.z.void(), zod.z.array(PipelineTemplateSchema$1).readonly()),
-        saveTemplate: method(zod.z.object({
-          name: zod.z.string(),
-          steps: zod.z.array(PipelineTemplateStepSchema).readonly(),
-          engine: PipelineEngineChoiceSchema
-        }), PipelineTemplateSchema$1, { kind: "mutation" }),
-        updateTemplate: method(zod.z.object({
-          id: zod.z.string(),
-          name: zod.z.string().optional(),
-          steps: zod.z.array(PipelineTemplateStepSchema).readonly().optional()
-        }), PipelineTemplateSchema$1, { kind: "mutation" }),
-        deleteTemplate: method(zod.z.object({ id: zod.z.string() }), zod.z.void(), { kind: "mutation" }),
-        getCapabilities: method(zod.z.void(), InferenceCapabilitiesBridge),
-        getAddonModels: method(zod.z.object({ addonId: zod.z.string() }), ModelAvailabilityListBridge),
-        downloadModel: method(zod.z.object({
-          addonId: zod.z.string(),
-          modelId: zod.z.string(),
-          format: ModelFormatSchema$1
-        }), DownloadModelResultSchema, { kind: "mutation" }),
-        deleteModel: method(zod.z.object({
-          addonId: zod.z.string(),
-          modelId: zod.z.string(),
-          format: ModelFormatSchema$1
-        }), zod.z.object({ success: zod.z.literal(true) }), { kind: "mutation" }),
-        /**
-        * Stateless single-frame execution. Callers (runner, benchmark) pass
-        * the complete `engine` + `steps` tree; the executor holds no state
-        * about cameras or saved pipelines.
-        *
-        * `engine` is optional during the migration window to preserve the
-        * legacy call shape used by existing benchmark code; once all
-        * callers pass it explicitly we make it required.
-        *
-        * Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
-        * `referenceImage` must be provided:
-        *  - `frame`: runtime dispatch path (runner → decoded broker frame).
-        *    Carries the raw buffer, dimensions, and format; the executor
-        *    uses it directly without base64 round-tripping.
-        *  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
-        *    decoded frame. Both runner and executor are hub-local processes
-        *    sharing `/dev/shm`, so the executor maps the named segment and
-        *    reads the pixels back zero-copy — eliminating the ~1.2MB
-        *    re-serialisation over UDS/MsgPack the `frame` path pays per call.
-        *    High-risk: the FrameRing is a latest-wins seqlock with no
-        *    refcount, so a recycled slot yields a null read; the executor
-        *    then degrades to an empty result and the runner ships pixels via
-        *    `frame` as the fallback (queue-depth gated on the runner side).
-        *  - `imageBase64`: one-shot test path (benchmark ImageTab).
-        *  - `referenceImage`: named file from the reference-image store.
-        */
-        runPipeline: method(zod.z.object({
-          engine: PipelineEngineChoiceSchema.optional(),
-          steps: zod.z.array(PipelineStepInputSchema).min(1),
-          frame: FrameInputSchema.optional(),
-          /**
-          * Process-local lazy frame. Valid only when caller and provider resolve
-          * in the same execution-group process; split/cross-node callers use
-          * `frame`/`image` inline compatibility instead.
-          */
-          frameRef: FrameRefSchema.optional(),
-          /**
-          * CB5 shm passthrough — a `FrameHandle` naming the same ring slot
-          * the decoded pixels live in. One more member of the one-of
-          * frame/frameHandle/image/imageBase64/referenceImage group.
-          */
-          frameHandle: FrameHandleSchema.optional(),
-          imageBase64: zod.z.string().optional(),
-          /**
-          * Binary JPEG bytes — preferred over `imageBase64` on internal
-          * hops (hub → forked worker via Moleculer MsgPack) because it
-          * skips the 33% base64 overhead + the per-call base64 decode on
-          * the detection-pipeline worker. Callers can pass either; exactly
-          * one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
-          */
-          image: zod.z.instanceof(Uint8Array).optional(),
-          referenceImage: zod.z.string().optional(),
-          deviceId: zod.z.number().optional(),
-          sessionId: zod.z.string().optional(),
-          /**
-          * Execution plane. 'full' (default) runs the whole tree — benchmark,
-          * reference-image, and detail-subtree calls. 'frame' is the live
-          * per-frame dispatch: ONLY root-plane steps run; crop children
-          * (inputClasses ≠ null) are skipped and served per-track via
-          * pipelineRunner.runDetailSubtree (two-plane design).
-          */
-          plane: zod.z.enum(["full", "frame"]).optional(),
-          /**
-          * Inference-device selector (Phase 2 multi-device). Format
-          * `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
-          * Omitted ⇒ the runner's default device (current single-engine
-          * behaviour). Selects WHICH device pool of the node runs the call.
-          */
-          deviceKey: zod.z.string().optional(),
-          /**
-          * Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
-          * when the parent crop was resolved from the frame's retained NATIVE
-          * surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
-          * child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
-          * resolution from that surface — the SAME quality path faces already
-          * had — instead of the downscaled parent tile. `handle` keys the native
-          * surface (node-pinned to its owner); `cropFrameSpace` is the parent
-          * crop's padded/clamped rectangle in FRAME-space pixels, used to compose
-          * the executor's crop-normalized child ROI back into frame-normalized
-          * coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
-          * of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
-          * (today's behaviour on the fallback path).
-          */
-          nativeCropRef: NativeCropRefSchema.optional()
-        }), PipelineRunResultBridge, { kind: "mutation" }),
-        /**
-        * Batched run — N raw frames packed into one cap call. The provider
-        * routes the batch through `SharedInferencePool.inferBatch`
-        * (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
-        * envelope cost is amortised N:1 vs N concurrent `runPipeline`
-        * calls. Single root step + uniform model assumed; trees with crop
-        * children fall back to sequential execution.
-        *
-        * Used by `scripts/bench-batch-style.mts` for batch benchmarking —
-        * N frames in one call to amortise per-call IPC overhead.
-        */
-        runPipelineBatch: method(zod.z.object({
-          engine: PipelineEngineChoiceSchema.optional(),
-          steps: zod.z.array(PipelineStepInputSchema).min(1),
-          frames: zod.z.array(FrameInputSchema).min(1).max(255),
-          deviceId: zod.z.number().optional(),
-          sessionId: zod.z.string().optional(),
-          /**
-          * Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
-          * the batch to the Python pool's bench preprocess cache
-          * (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
-          * preprocessed ONCE and every later inference is a pure-inference cache
-          * hit — the sustained-throughput run measures inference, not
-          * decode+preprocess+infer. Omitted/0 for live frames (all different →
-          * full preprocess every call, correct). Fresh per sustained run;
-          * released via `uncacheFrame`.
-          */
-          frameId: zod.z.number().int().nonnegative().optional(),
-          /** Inference-device selector (Phase 2 multi-device); see runPipeline. */
-          deviceKey: zod.z.string().optional()
-        }), zod.z.object({ results: zod.z.array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
-        /**
-        * Cache a raw frame inside the Python inference pool's memory.
-        * Returns a numeric `frameId` that `inferCached` references —
-        * subsequent calls send only 5 bytes through the pipe instead of
-        * 1.2MB raw data, eliminating the pipe transfer bottleneck.
-        */
-        cacheFrameInPool: method(zod.z.object({
-          data: zod.z.instanceof(Uint8Array),
-          width: zod.z.number().int().positive(),
-          height: zod.z.number().int().positive(),
-          format: zod.z.enum([
-            "rgb",
-            "bgr",
-            "gray"
-          ])
-        }), zod.z.object({
-          frameId: zod.z.number(),
-          width: zod.z.number(),
-          height: zod.z.number()
-        }), { kind: "mutation" }),
-        /**
-        * Run inference on a previously cached frame. Sends only 5 bytes
-        * (model_idx + frameId) through the IPC pipe — eliminates the
-        * ~35ms per-call overhead of transferring 1.2MB raw data.
-        */
-        inferCached: method(zod.z.object({
-          stepId: zod.z.string(),
-          frameId: zod.z.number().int()
-        }), zod.z.record(zod.z.string(), zod.z.unknown()), { kind: "mutation" }),
-        /**
-        * Release a cached frame from the Python pool's memory.
-        */
-        uncacheFrame: method(zod.z.object({ frameId: zod.z.number().int() }), zod.z.void(), { kind: "mutation" }),
-        /** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
-        getEffectiveTuning: method(zod.z.void(), zod.z.object({
-          batchMode: zod.z.string(),
-          windowMs: zod.z.number(),
-          maxBatchSize: zod.z.number(),
-          concurrency: zod.z.number()
-        })),
-        /**
-        * List every EngineFactory currently loaded in this executor's RAM,
-        * with the models resident and a coarse "in use" marker derived from
-        * ongoing inference activity. Used by the Pipeline page Engines tab.
-        */
-        listLoadedEngines: method(zod.z.void(), zod.z.array(zod.z.object({
-          engineKey: zod.z.string(),
-          engine: PipelineEngineChoiceSchema,
-          modelsLoaded: zod.z.array(zod.z.string()).readonly(),
-          inUseByCameras: zod.z.array(zod.z.number()).readonly(),
-          /**
-          * Origin of this resident factory.
-          *  - `runtime`       — main camera-serving engine (no idle TTL).
-          *  - `warm-override` — benchmark/test override held in the warm
-          *                      cache; auto-disposed after the idle TTL.
-          *  - `device-pool`   — a concurrent per-device pool (Phase 2
-          *                      multi-device, keyed by `deviceKey`) resolved
-          *                      via `resolveDeviceFactory`. Runs alongside the
-          *                      `runtime` engine on a DIFFERENT accelerator
-          *                      (NPU / iGPU / Coral) — this is how the
-          *                      Engines tab shows all pools running at once.
-          */
-          kind: zod.z.enum([
-            "runtime",
-            "warm-override",
-            "device-pool"
-          ]),
-          /** Native pid of the underlying Python pool (null when no pool). */
-          poolPid: zod.z.number().nullable(),
-          /** ms since this factory was last used (null when not warm-tracked). */
-          idleMs: zod.z.number().nullable(),
-          /** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
-          idleTtlMs: zod.z.number().nullable()
-        })).readonly()),
-        /** Warm up an engine without running a frame. No-op if already loaded. */
-        spinEngine: method(zod.z.object({ engine: PipelineEngineChoiceSchema }), zod.z.object({ success: zod.z.literal(true) }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        /**
-        * Unload an engine from RAM. `force:true` unloads even when cameras
-        * are actively using it (they re-spin on next frame). Default is
-        * gated — returns `{success:false, reason}` when in use.
-        */
-        killEngine: method(zod.z.object({
-          engine: PipelineEngineChoiceSchema,
-          force: zod.z.boolean().optional()
-        }), zod.z.object({
-          success: zod.z.boolean(),
-          reason: zod.z.string().optional()
-        }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        listReferenceImages: method(zod.z.void(), zod.z.array(ReferenceImageEntrySchema).readonly()),
-        getReferenceImage: method(zod.z.object({ filename: zod.z.string() }), ReferenceImageBodySchema.nullable()),
-        getReferenceAudioFiles: method(zod.z.void(), zod.z.array(ReferenceAudioEntrySchema).readonly()),
-        getReferenceAudio: method(zod.z.object({ filename: zod.z.string() }), ReferenceAudioBodySchema.nullable()),
-        getAudioCapabilities: method(zod.z.void(), AudioCapabilitiesSchema),
-        runAudioTest: method(zod.z.object({
-          addonId: zod.z.string(),
-          modelId: zod.z.string(),
-          filename: zod.z.string().optional(),
-          settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-        }), AudioTestResultSchema, { kind: "mutation" }),
-        getDetectionConfigSchema: method(zod.z.void(), ConfigUISchemaNullableBridge)
-      }
-    };
     zod.z.object({
       activeCameras: zod.z.number(),
       throttledCameras: zod.z.number(),
@@ -36674,66 +36916,6 @@ var require_dist_D5Jhh8Vk = __commonJS({
       ])
     });
     var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: zod.z.number() });
-    var ZoneKindEnum = zod.z.enum(["polygon", "tripwire"]);
-    var PolygonPointSchema = zod.z.object({
-      x: zod.z.number(),
-      y: zod.z.number()
-    });
-    var ZoneSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      kind: ZoneKindEnum.default("polygon"),
-      /** Polygon vertices, fraction of frame (0–1). */
-      polygon: zod.z.array(PolygonPointSchema).readonly(),
-      /** Visual color for UI rendering. */
-      color: zod.z.string().default("#3b82f6")
-    });
-    var zonesCapability = {
-      name: "zones",
-      scope: "device",
-      mode: "singleton",
-      deviceTypes: [DeviceType.Camera],
-      methods: {
-        listZones: method(zod.z.object({ deviceId: zod.z.number() }), zod.z.array(ZoneSchema).readonly()),
-        addZone: method(zod.z.object({
-          deviceId: zod.z.number(),
-          zone: ZoneSchema
-        }), zod.z.void(), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        removeZone: method(zod.z.object({
-          deviceId: zod.z.number(),
-          zoneId: zod.z.string()
-        }), zod.z.void(), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        updateZone: method(zod.z.object({
-          deviceId: zod.z.number(),
-          zone: ZoneSchema
-        }), zod.z.void(), {
-          kind: "mutation",
-          auth: "admin"
-        })
-      },
-      /**
-      * Runtime-state slice — the live zone catalogue mirrored by the
-      * orchestrator on every CRUD mutation. Consumers read via
-      * `device.state.zones.value` / `.watch(...)` without round-tripping
-      * the cap, and the codegen DeviceProxy auto-wires the reactive
-      * handle. Slice shape is `{ zones: Zone[] }` so future extensions
-      * (e.g. zone groupings) can sit alongside the polygon list.
-      */
-      runtimeState: zod.z.object({ zones: zod.z.array(ZoneSchema).readonly() }),
-      /**
-      * Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
-      *
-      * See `RuntimeStateDurability`. Enforced by
-      * `scripts/check-runtime-state-durability.ts`.
-      */
-      durability: "restored"
-    };
     var NativeCropBboxSchema = zod.z.object({
       x: zod.z.number(),
       y: zod.z.number(),
@@ -45526,6 +45708,23 @@ var require_dist_D5Jhh8Vk = __commonJS({
       /** Media ms the returned fragment covers. */
       gopDurMs: zod.z.number()
     });
+    var ReadWindowBytesResultSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+      kind: zod.z.literal("ok"),
+      data: zod.z.instanceof(Uint8Array),
+      /** Absolute epoch ms of the returned bytes' first sample — at or before
+      *  the requested `fromMs` (anchored on the nearest keyframe). */
+      gopStartMs: zod.z.number(),
+      /** Media ms the returned bytes cover, from `gopStartMs`. */
+      gopDurMs: zod.z.number(),
+      /** `false` ⇒ the safety byte cap cut the read short before it reached
+      *  the requested `toMs`; the caller got fewer frames than asked for. */
+      reachesRequestedEnd: zod.z.boolean()
+    }), zod.z.object({
+      kind: zod.z.literal("spans-multiple-segments"),
+      /** Where the covering segment's own footage runs out — informational,
+      *  not a retry hint (retrying the same window would refuse again). */
+      segmentEndMs: zod.z.number()
+    })]);
     var recordingCapability = {
       name: "recording",
       scope: "system",
@@ -45605,6 +45804,21 @@ var require_dist_D5Jhh8Vk = __commonJS({
           kind: "query",
           auth: "admin"
         }),
+        /** Read a WINDOW `[fromMs, toMs)` of segment `startMs`, by mfra byte
+        *  range — the multi-GOP twin of `readGopBytes`. Refuses (does not
+        *  degrade) when the window runs past the covering segment. Used by the
+        *  replay clip's `recording` source to fetch several seconds of native
+        *  footage for its single ffmpeg decode pass. */
+        readWindowBytes: method(zod.z.object({
+          deviceId: zod.z.number(),
+          profile: zod.z.string(),
+          startMs: zod.z.number(),
+          fromMs: zod.z.number(),
+          toMs: zod.z.number()
+        }), ReadWindowBytesResultSchema, {
+          kind: "query",
+          auth: "admin"
+        }),
         setDeviceConfig: method(zod.z.object({
           deviceId: zod.z.number(),
           config: RecordingConfigSchema
@@ -46167,59 +46381,6 @@ var require_dist_D5Jhh8Vk = __commonJS({
       */
       durability: "session"
     };
-    var ZoneRuleModeEnum = zod.z.enum(["include", "exclude"]);
-    var ZoneRuleSchema = zod.z.object({
-      /** Stable rule id — survives edits, used by the UI for diffing. */
-      id: zod.z.string(),
-      /** Optional human-readable label rendered in the rule editor. */
-      name: zod.z.string().optional(),
-      /** Zones this rule targets. The rule's `mode` applies to ALL
-      *  listed zones (OR-set: a detection in any one of them counts).
-      *  At least one zone id required — a rule with no targets is a
-      *  configuration mistake and the form validator rejects it. */
-      zoneIds: zod.z.array(zod.z.string()).min(1).readonly(),
-      mode: ZoneRuleModeEnum,
-      /**
-      * Class names this rule applies to. Empty / undefined ⇒ rule
-      * applies to every class. Class strings match the `macroClass`
-      * field on detections (e.g. `person`, `car`, `dog`).
-      */
-      classFilter: zod.z.array(zod.z.string()).readonly().optional(),
-      /**
-      * Minimum bbox/mask overlap (0–1) with any of the rule's zones
-      * required to consider an entity "in the zone". Defaults to the
-      * consumer's stage default when omitted. Kept for back-compat with
-      * existing per-rule overrides; new operators pick the value via
-      * `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
-      * set, the lower-level engine reads it as a 0–1 fraction.
-      */
-      overlapThreshold: zod.z.number().min(0).max(1).optional(),
-      /**
-      * Operator-friendly version of `overlapThreshold` — the percentage
-      * of the detection's bbox that must lie inside the zone for the
-      * rule to match. Documented default is 85%; the engine substitutes
-      * that when the field is omitted (kept optional so existing rules
-      * stored without it stay valid).
-      *
-      * When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
-      * rule, the engine prefers `bboxInclusionPct` because it's the
-      * field exposed in the UI. Internally both feed the same gate.
-      */
-      bboxInclusionPct: zod.z.number().min(0).max(100).optional(),
-      /**
-      * When `true` and a detection has a segmentation mask, use the
-      * mask for overlap instead of the bbox. Detection-stage only;
-      * motion rules ignore this field.
-      */
-      preferMask: zod.z.boolean().optional(),
-      /**
-      * Soft-toggle: `false` disables the rule without deleting it.
-      * Defaults to `true` so operators creating a rule via the UI
-      * see it active immediately.
-      */
-      enabled: zod.z.boolean().default(true)
-    });
-    zod.z.array(ZoneRuleSchema).readonly();
     var ScriptRunnerStatusSchema = zod.z.object({
       /** Whether the script is currently executing. */
       isRunning: zod.z.boolean(),
@@ -51166,6 +51327,12 @@ var require_dist_D5Jhh8Vk = __commonJS({
         addonId: null,
         access: "view"
       },
+      "notificationRules.resolveArtifactUrl": {
+        capName: "notification-rules",
+        capScope: "system",
+        addonId: null,
+        access: "view"
+      },
       "notificationRules.setAlarmConfig": {
         capName: "notification-rules",
         capScope: "system",
@@ -51610,6 +51777,12 @@ var require_dist_D5Jhh8Vk = __commonJS({
         addonId: null,
         access: "create"
       },
+      "pipelineAnalytics.runReplayFrameProcessor": {
+        capName: "pipeline-analytics",
+        capScope: "device",
+        addonId: null,
+        access: "create"
+      },
       "pipelineAnalytics.saveRetrainAnnotations": {
         capName: "pipeline-analytics",
         capScope: "device",
@@ -51742,6 +51915,12 @@ var require_dist_D5Jhh8Vk = __commonJS({
         addonId: null,
         access: "view"
       },
+      "pipelineExecutor.getInferenceDeviceHealth": {
+        capName: "pipeline-executor",
+        capScope: "system",
+        addonId: null,
+        access: "view"
+      },
       "pipelineExecutor.getOrchestratorConfigSchema": {
         capName: "pipeline-executor",
         capScope: "system",
@@ -51814,6 +51993,12 @@ var require_dist_D5Jhh8Vk = __commonJS({
         addonId: null,
         access: "view"
       },
+      "pipelineExecutor.rearmInferenceDevice": {
+        capName: "pipeline-executor",
+        capScope: "system",
+        addonId: null,
+        access: "create"
+      },
       "pipelineExecutor.runAudioTest": {
         capName: "pipeline-executor",
         capScope: "system",
@@ -52552,6 +52737,12 @@ var require_dist_D5Jhh8Vk = __commonJS({
         addonId: null,
         access: "view"
       },
+      "recording.readWindowBytes": {
+        capName: "recording",
+        capScope: "system",
+        addonId: null,
+        access: "view"
+      },
       "recording.refreshStorageLocationsForMigration": {
         capName: "recording",
         capScope: "system",
@@ -55062,6 +55253,11 @@ var require_dist_D5Jhh8Vk = __commonJS({
         form: "single",
         optional: false
       }],
+      "pipelineAnalytics.runReplayFrameProcessor": [{
+        name: "deviceId",
+        form: "single",
+        optional: false
+      }],
       "pipelineAnalytics.saveRetrainAnnotations": [{
         name: "deviceId",
         form: "single",
@@ -55377,6 +55573,11 @@ var require_dist_D5Jhh8Vk = __commonJS({
         form: "single",
         optional: false
       }],
+      "recording.readWindowBytes": [{
+        name: "deviceId",
+        form: "single",
+        optional: false
+      }],
       "recording.relocateFootage": [{
         name: "deviceId",
         form: "single",
@@ -57031,7 +57232,7 @@ var require_alerts_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     function selectExpired(alerts, cutoffMs) {
       return alerts.filter((a) => a.createdAt < cutoffMs).sort((a, b) => a.createdAt - b.createdAt).map((a) => a.id);
     }
@@ -57850,7 +58051,7 @@ var require_console_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var require_formatter = require_formatter_DqAKDlvN();
     var LEVEL_RANK = {
       debug: 0,
@@ -57944,7 +58145,7 @@ var require_core_blocks_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     node_fs_promises = require_chunk.__toESM(node_fs_promises);
@@ -58841,11 +59042,11 @@ var require_core_blocks = __commonJS({
   }
 });
 
-// ../system/dist/retired-settings-keys-Dflres-F.js
-var require_retired_settings_keys_Dflres_F = __commonJS({
-  "../system/dist/retired-settings-keys-Dflres-F.js"(exports) {
+// ../system/dist/retired-settings-keys-ovd_DQzc.js
+var require_retired_settings_keys_ovd_DQzc = __commonJS({
+  "../system/dist/retired-settings-keys-ovd_DQzc.js"(exports) {
     "use strict";
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     function settingsStoreIsAuthoritativeHere(env) {
       const raw = (env["CAMSTACK_ROLE"] ?? "").trim().toLowerCase();
       return raw === "" || raw === "hub";
@@ -60888,8 +61089,8 @@ var require_device_manager_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
-    var require_retired_settings_keys = require_retired_settings_keys_Dflres_F();
+    var require_dist10 = require_dist_jRSrzoXr();
+    var require_retired_settings_keys = require_retired_settings_keys_ovd_DQzc();
     var node_crypto = __require("crypto");
     var _camstack_types_node = require_node();
     var JOB_HISTORY = 20;
@@ -61908,6 +62109,10 @@ var require_device_manager_addon = __commonJS({
         device
       };
     }
+    function extractCallerAddonId(input) {
+      const raw = Reflect.get(input, "callerAddonId");
+      return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+    }
     async function listPersistedByAddon(pctx, input) {
       const { addonId } = input;
       return (await pctx.metaStore.rows.listByAddon(addonId)).map(({ meta: m }) => ({
@@ -61935,6 +62140,7 @@ var require_device_manager_addon = __commonJS({
     async function listAll(pctx, input) {
       const ownerFilter = Reflect.get(input, "addonId");
       if (ownerFilter !== void 0 && (typeof ownerFilter !== "string" || ownerFilter.length === 0)) throw new Error(`deviceManager.listAll: addonId must be a non-empty string or be omitted \u2014 got ${JSON.stringify(ownerFilter)}. An owner filter that is present but empty is never widened to every device. On an addon context the id is \`ctx.id\`; there is no \`ctx.addonId\`.`);
+      const callerAddonId = pctx.metaStore.rows.censusArmed ? extractCallerAddonId(input) : void 0;
       const { addonId } = input;
       const slim = input.projection === "slim";
       const camerasOnly = input.isCamera === true;
@@ -61944,7 +62150,7 @@ var require_device_manager_addon = __commonJS({
       const fleet = addonId ? await pctx.metaStore.rows.listByAddon(addonId) : await pctx.metaStore.rows.listFleet({
         ...input.deviceIds !== void 0 ? { deviceIds: input.deviceIds } : {},
         slim
-      });
+      }, callerAddonId);
       const rowById = /* @__PURE__ */ new Map();
       for (const row of fleet) rowById.set(row.meta.id, row);
       if (pctx.registry) {
@@ -62446,18 +62652,38 @@ var require_device_manager_addon = __commonJS({
         manualIds
       };
     }
+    function expandContainer(id, byId, byParent, visited, out) {
+      if (visited.has(id)) return;
+      const candidate = byId.get(id);
+      if (!candidate) return;
+      if (candidate.type !== require_dist10.DeviceType.Container) {
+        out.add(id);
+        return;
+      }
+      const nextVisited = new Set(visited);
+      nextVisited.add(id);
+      const children = byParent.get(id) ?? [];
+      for (const child of children) expandContainer(child.id, byId, byParent, nextVisited, out);
+    }
     function resolveLinkedDeviceIds(params) {
       const { selfId, selfLocation, config, candidates } = params;
+      const byId = new Map(candidates.map((c) => [c.id, c]));
+      const byParent = /* @__PURE__ */ new Map();
+      for (const c of candidates) {
+        if (c.parentDeviceId === null) continue;
+        const siblings = byParent.get(c.parentDeviceId);
+        if (siblings) siblings.push(c);
+        else byParent.set(c.parentDeviceId, [c]);
+      }
       const ids = /* @__PURE__ */ new Set();
-      for (const c of candidates) if (c.parentDeviceId === selfId) ids.add(c.id);
+      const expand = (id) => expandContainer(id, byId, byParent, /* @__PURE__ */ new Set(), ids);
+      for (const c of candidates) if (c.parentDeviceId === selfId) expand(c.id);
       if (config.mode === "auto") {
-        if (selfLocation !== null && selfLocation.length > 0) {
-          for (const c of candidates) if (c.location === selfLocation) ids.add(c.id);
+        if (selfLocation !== null && selfLocation.length > 0) for (const c of candidates) {
+          if (c.type === require_dist10.DeviceType.Container) continue;
+          if (c.location === selfLocation) ids.add(c.id);
         }
-      } else {
-        const known = new Set(candidates.map((c) => c.id));
-        for (const id of config.manualIds) if (known.has(id)) ids.add(id);
-      }
+      } else for (const id of config.manualIds) if (byId.has(id)) expand(id);
       ids.delete(selfId);
       return [...ids];
     }
@@ -62524,7 +62750,7 @@ var require_device_manager_addon = __commonJS({
       if (!persisted || persisted.meta.type !== require_dist10.DeviceType.Camera) return null;
       const [all, blob] = await Promise.all([listAll(pctx, LINK_CANDIDATE_PROJECTION), pctx.settings.readDeviceStore(deviceId)]);
       const config = parseLinkedDevicesConfig(blob);
-      const options = all.filter((d) => d.id !== deviceId).map((d) => ({
+      const options = all.filter((d) => d.id !== deviceId && d.type !== require_dist10.DeviceType.Container).map((d) => ({
         value: String(d.id),
         label: d.location !== null ? `${d.name} (${d.location})` : d.name
       }));
@@ -63528,11 +63754,42 @@ var require_device_manager_addon = __commonJS({
         }
       });
     }
+    async function collectDescendants(metaStore, rootId) {
+      const out = [];
+      const visited = /* @__PURE__ */ new Set([rootId]);
+      const queue = [rootId];
+      while (queue.length > 0) {
+        const parentId = queue.shift();
+        if (parentId === void 0) break;
+        for (const row of await metaStore.rows.listByParent(parentId)) {
+          if (visited.has(row.meta.id)) continue;
+          visited.add(row.meta.id);
+          out.push(row.meta);
+          queue.push(row.meta.id);
+        }
+      }
+      return out;
+    }
     async function setLocation(pctx, input) {
       const { deviceId, location } = input;
+      const cascaded = [];
+      const failed = [];
       await pctx.metaStore.withMetaWriteLock(async () => {
-        if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] setLocation: unknown device id=${deviceId}`);
+        const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
+        if (!persisted) throw new Error(`[device-manager] setLocation: unknown device id=${deviceId}`);
         await pctx.metaStore.rows.patch(deviceId, { location });
+        if (persisted.meta.type === require_dist10.DeviceType.Container) {
+          const descendants = await collectDescendants(pctx.metaStore, deviceId);
+          for (const descendant of descendants) try {
+            await pctx.metaStore.rows.patch(descendant.id, { location });
+            cascaded.push(descendant.id);
+          } catch (err) {
+            failed.push({
+              id: descendant.id,
+              error: err
+            });
+          }
+        }
       });
       pctx.host.ctx.eventBus.emit({
         id: (0, node_crypto.randomUUID)(),
@@ -63548,6 +63805,36 @@ var require_device_manager_addon = __commonJS({
           value: location
         }
       });
+      for (const childId of cascaded) pctx.host.ctx.eventBus.emit({
+        id: (0, node_crypto.randomUUID)(),
+        timestamp: /* @__PURE__ */ new Date(),
+        source: {
+          type: "device",
+          id: childId
+        },
+        category: require_dist10.EventCategory.DeviceMetaChanged,
+        data: {
+          deviceId: childId,
+          field: "location",
+          value: location
+        }
+      });
+      if (cascaded.length > 0 || failed.length > 0) pctx.host.ctx.logger.info("setLocation: cascaded location to container descendants", {
+        tags: { deviceId },
+        meta: {
+          location,
+          updated: cascaded.length,
+          failed: failed.length
+        }
+      });
+      if (failed.length > 0) pctx.host.ctx.logger.error("setLocation: cascade partially failed \u2014 some descendants NOT aligned to the new location", {
+        tags: { deviceId },
+        meta: {
+          location,
+          failedIds: failed.map((f) => f.id),
+          errors: failed.map((f) => f.error instanceof Error ? f.error.message : String(f.error))
+        }
+      });
     }
     async function setType(pctx, input) {
       const { deviceId, type } = input;
@@ -64039,9 +64326,29 @@ var require_device_manager_addon = __commonJS({
       * to it even if it lands after the close — otherwise the slow reads at the
       * edge would be attributed to nobody, and the slow ones are the interesting
       * ones.
-      */
-      siteOf(nowMs = Date.now()) {
+      *
+      * `callerAddonId`, when given, is formatted as the site VERBATIM instead of
+      * walking the local stack. A call that arrived over the cap channel — a
+      * forked addon's `ctx.api.deviceManager.listAll.query()`, routed through
+      * `LocalChildRegistry` → `onUnownedCall` → `CapRouteResolver` — carries its
+      * origin as DATA (the registered `childId` the parent captured off the UDS
+      * connection), and no amount of stack depth would ever recover it: every
+      * frame between the socket read and this call is the SAME generic
+      * dispatcher code (`onUnownedCall`, `dispatch`, `invoke`) regardless of
+      * which addon called — the 2026-08-25 boot census measured this directly,
+      * five thousand calls landing on `listAll` with nothing nameable above it.
+      *
+      * `isOpen` is checked FIRST, before the id is even looked at — a caller
+      * threading a (cheap, already-known) `callerAddonId` through on every
+      * request, armed or not, must not pay for the template string when
+      * disarmed. This is also why formatting lives HERE rather than at the call
+      * site: `DeviceRowStore` passes the raw id through unconditionally, and
+      * only this method — which already knows whether armed — decides whether
+      * to spend anything on it.
+      */
+      siteOf(callerAddonId, nowMs = Date.now()) {
         if (!this.isOpen(nowMs)) return null;
+        if (callerAddonId !== void 0) return `addon:${callerAddonId}`;
         const holder = {};
         Error.captureStackTrace(holder, this.siteOf);
         return siteFromStack(holder.stack);
@@ -64329,6 +64636,16 @@ var require_device_manager_addon = __commonJS({
       /** Call-site attribution for fleet reads. Armed only by
       *  `CAMSTACK_FLEET_READ_CENSUS_MS`; see `fleet-read-census.ts`. */
       census;
+      /**
+      * Is the fleet-read census armed right now? Exposed so a caller ABOVE this
+      * store (`device-queries.ts`) can skip extracting a caller identity off its
+      * input entirely when nobody is measuring — "the boolean field read first"
+      * pattern this repo already uses elsewhere to keep a diagnostic seam at
+      * zero cost while disarmed.
+      */
+      get censusArmed() {
+        return this.census.armed;
+      }
       constructor(backend, logger, census) {
         this.backend = backend;
         this.logger = logger;
@@ -64377,15 +64694,23 @@ var require_device_manager_addon = __commonJS({
         }
         return decoded;
       }
-      /** Every device, ordered by numeric id. */
-      async listAll() {
+      /**
+      * Every device, ordered by numeric id.
+      *
+      * `callerAddonId`, when known, is the addon that ORIGINATED this call —
+      * captured off the cap-channel envelope (`CapCallInput.callerAddonId`, set
+      * by `LocalChildRegistry` from the registered `childId`), never guessed.
+      * Passed straight to the census; a stack walk can never name it (see
+      * `fleet-read-census.ts#siteOf`).
+      */
+      async listAll(callerAddonId) {
         return this.list({
           orderBy: {
             field: "deviceId",
             direction: "asc"
           },
           limit: DEVICE_ROWS_FLEET_LIMIT
-        });
+        }, void 0, callerAddonId);
       }
       /**
       * The fleet, read as narrowly as the question allows.
@@ -64402,8 +64727,10 @@ var require_device_manager_addon = __commonJS({
       *
       * `isCamera` is deliberately NOT one of them — see that constant's note and
       * `device-row-store-filtered.spec.ts`.
+      *
+      * `callerAddonId` — see {@link listAll}'s doc; same meaning here.
       */
-      async listFleet(opts) {
+      async listFleet(opts, callerAddonId) {
         if (opts.deviceIds !== void 0 && opts.deviceIds.length === 0) return [];
         return this.list({
           ...opts.deviceIds !== void 0 ? { whereIn: { deviceId: [...new Set(opts.deviceIds)] } } : {},
@@ -64412,7 +64739,7 @@ var require_device_manager_addon = __commonJS({
             direction: "asc"
           },
           limit: DEVICE_ROWS_FLEET_LIMIT
-        }, opts.slim === true ? DEVICE_ROWS_SLIM_COLUMNS : void 0);
+        }, opts.slim === true ? DEVICE_ROWS_SLIM_COLUMNS : void 0, callerAddonId);
       }
       /**
       * Many devices, by numeric id, in ONE query.
@@ -64503,8 +64830,8 @@ var require_device_manager_addon = __commonJS({
         await this.declare();
         return this.backend.count({ collection: DEVICE_ROWS_COLLECTION });
       }
-      async list(filter, columns) {
-        const site = this.census.siteOf();
+      async list(filter, columns, callerAddonId) {
+        const site = this.census.siteOf(callerAddonId);
         await this.declare();
         const records = await this.backend.query({
           collection: DEVICE_ROWS_COLLECTION,
@@ -65432,7 +65759,7 @@ var require_hub_forwarder = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var require_formatter = require_formatter_DqAKDlvN();
     var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;
     var HubForwarderDestination = class {
@@ -65569,7 +65896,7 @@ var require_liveness_monitor_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var NO_DEVICES = "liveness:no-devices";
     var ALL_OFFLINE = "liveness:all-devices-offline";
     var NO_FOOTAGE_PREFIX = "liveness:no-footage:";
@@ -65759,7 +66086,7 @@ var require_local_auth_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var node_crypto = __require("crypto");
     node_crypto = require_chunk.__toESM(node_crypto);
     var crypto$1 = __require("crypto");
@@ -73443,7 +73770,7 @@ var require_loki_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     function sanitizeLabelName(raw) {
       const replaced = raw.replaceAll(/[^a-zA-Z0-9_]/g, "_");
       return /^[a-zA-Z_]/.test(replaced) ? replaced : `_${replaced}`;
@@ -74008,7 +74335,7 @@ var require_native_metrics_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var node_child_process = __require("child_process");
     var node_util = __require("util");
     var node_os = __require("os");
@@ -74950,7 +75277,7 @@ var require_filesystem_storage_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     var node_path = __require("path");
@@ -76066,8 +76393,8 @@ var require_sqlite_settings_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
-    var require_retired_settings_keys = require_retired_settings_keys_Dflres_F();
+    var require_dist10 = require_dist_jRSrzoXr();
+    var require_retired_settings_keys = require_retired_settings_keys_ovd_DQzc();
     var node_crypto = __require("crypto");
     var node_fs = __require("fs");
     var node_module = __require("module");
@@ -78261,7 +78588,7 @@ var require_storage_orchestrator_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     node_fs_promises = require_chunk.__toESM(node_fs_promises);
@@ -80140,7 +80467,7 @@ var require_system_config_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var SECTION_TITLES = {
       server: "Server",
       auth: "Authentication"
@@ -98201,7 +98528,7 @@ var require_winston_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var require_formatter = require_formatter_DqAKDlvN();
     var node_path = __require("path");
     node_path = require_chunk.__toESM(node_path);
@@ -100144,9 +100471,9 @@ var require_event_category_EY0GNjV9 = __commonJS({
   }
 });
 
-// ../types/dist/sleep-DnbNfEhn.js
-var require_sleep_DnbNfEhn = __commonJS({
-  "../types/dist/sleep-DnbNfEhn.js"(exports) {
+// ../types/dist/sleep-CSodb2vQ.js
+var require_sleep_CSodb2vQ = __commonJS({
+  "../types/dist/sleep-CSodb2vQ.js"(exports) {
     "use strict";
     var require_event_category = require_event_category_EY0GNjV9();
     var zod = require_zod();
@@ -102674,6 +103001,7 @@ var require_sleep_DnbNfEhn = __commonJS({
           testRule: (input) => dispatch("notification-rules", "notificationRules", "testRule", "mutation", input),
           getConditionCatalog: (input) => dispatch("notification-rules", "notificationRules", "getConditionCatalog", "query", input),
           getHistory: (input) => dispatch("notification-rules", "notificationRules", "getHistory", "query", input),
+          resolveArtifactUrl: (input) => dispatch("notification-rules", "notificationRules", "resolveArtifactUrl", "query", input),
           listSnoozes: (input) => dispatch("notification-rules", "notificationRules", "listSnoozes", "query", input),
           createSnooze: (input) => dispatch("notification-rules", "notificationRules", "createSnooze", "mutation", input),
           cancelSnooze: (input) => dispatch("notification-rules", "notificationRules", "cancelSnooze", "mutation", input),
@@ -102746,6 +103074,7 @@ var require_sleep_DnbNfEhn = __commonJS({
           deselectRetrainFrame: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "deselectRetrainFrame", "mutation", input),
           getRetrainFrameImage: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getRetrainFrameImage", "query", input),
           proposeRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "proposeRetrainAnnotations", "mutation", input),
+          runReplayFrameProcessor: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "runReplayFrameProcessor", "mutation", input),
           listRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRetrainAnnotations", "query", input),
           saveRetrainAnnotations: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "saveRetrainAnnotations", "mutation", input),
           completeRetrainTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "completeRetrainTrack", "mutation", input),
@@ -103016,6 +103345,7 @@ var require_sleep_DnbNfEhn = __commonJS({
           locateSegment: (input) => dispatchSystem("recording", "locateSegment", "query", input),
           readSegmentBytes: (input) => dispatchSystem("recording", "readSegmentBytes", "query", input),
           readGopBytes: (input) => dispatchSystem("recording", "readGopBytes", "query", input),
+          readWindowBytes: (input) => dispatchSystem("recording", "readWindowBytes", "query", input),
           setDeviceConfig: (input) => dispatchSystem("recording", "setDeviceConfig", "mutation", input),
           rescanStorage: (input) => dispatchSystem("recording", "rescanStorage", "mutation", input),
           pruneFootage: (input) => dispatchSystem("recording", "pruneFootage", "mutation", input),
@@ -103697,7 +104027,7 @@ var require_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_event_category = require_event_category_EY0GNjV9();
-    var require_sleep = require_sleep_DnbNfEhn();
+    var require_sleep = require_sleep_CSodb2vQ();
     var require_err_msg = require_err_msg_COpsHMw2();
     var CAP_INPUT_DEFAULTS = Object.freeze({
       "addons": { "getLogs": { "limit": 100 } },
@@ -110573,9 +110903,9 @@ var require_dist2 = __commonJS({
   }
 });
 
-// ../system/dist/manifest-python-deps-Bu8H1_rg.js
-var require_manifest_python_deps_Bu8H1_rg = __commonJS({
-  "../system/dist/manifest-python-deps-Bu8H1_rg.js"(exports) {
+// ../system/dist/manifest-python-deps-DBQarwp9.js
+var require_manifest_python_deps_DBQarwp9 = __commonJS({
+  "../system/dist/manifest-python-deps-DBQarwp9.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
     var node_crypto = __require("crypto");
@@ -114426,6 +114756,14 @@ var require_manifest_python_deps_Bu8H1_rg = __commonJS({
       const raw = Reflect.get(args, "nodeId");
       return typeof raw === "string" && raw.length > 0 ? raw : void 0;
     }
+    function withCallerAddonId(args, callerAddonId) {
+      if (callerAddonId === void 0) return args;
+      if (args === null || typeof args !== "object" || Array.isArray(args)) return args;
+      return {
+        ...args,
+        callerAddonId
+      };
+    }
     var CapRouteResolver = class {
       hubNodeId;
       broker;
@@ -114493,10 +114831,20 @@ var require_manifest_python_deps_Bu8H1_rg = __commonJS({
       *   `hub-local-uds` caller that already knows the addonId (`buildCapCallFn`)
       *   talks to `LocalChildRegistry.callCapOnChild` directly rather than through
       *   `dispatch`.
-      */
-      async dispatch(route, method, args, addonId) {
+      * @param callerAddonId Optional out-of-band CALLER-identity hint — the
+      *   addon that ORIGINATED the call, distinct from `addonId` above (which
+      *   names the resolved PROVIDER, not the caller). Set by
+      *   `onUnownedCall` from `CapCallInput.callerAddonId`
+      *   (`LocalChildRegistry` stamped it off the registered `childId`). Only
+      *   the `hub-in-process` branch consumes it — merged into `args` so a
+      *   diagnostic tool deep in that provider (e.g. device-manager's
+      *   fleet-read census) can read it without every provider method changing
+      *   signature, the same "extra field the provider destructures or
+      *   ignores" convention `nodeId` already uses on this path.
+      */
+      async dispatch(route, method, args, addonId, callerAddonId) {
         try {
-          return await this.dispatchInner(route, method, args, addonId);
+          return await this.dispatchInner(route, method, args, addonId, callerAddonId);
         } catch (err) {
           if (err instanceof CapRouteError) throw err;
           const nodeId = this.routeNodeId(route);
@@ -114515,10 +114863,10 @@ var require_manifest_python_deps_Bu8H1_rg = __commonJS({
       * Inner dispatch: may throw CapRouteError (validation failures) or arbitrary
       * transport errors. The outer `dispatch` wraps non-CapRouteErrors.
       */
-      async dispatchInner(route, method, args, addonId) {
+      async dispatchInner(route, method, args, addonId, callerAddonId) {
         switch (route.kind) {
           case "hub-in-process":
-            return route.ref.invoke(method, args);
+            return route.ref.invoke(method, withCallerAddonId(args, callerAddonId));
           case "hub-local-uds": {
             const registry = this.hubLocalRegistry;
             if (registry === null) throw new CapRouteError(route.capName, method, {
@@ -115052,7 +115400,8 @@ var require_manifest_python_deps_Bu8H1_rg = __commonJS({
               args: out.args,
               ...out.deviceId !== void 0 ? { deviceId: out.deviceId } : {},
               ...out.nodeId !== void 0 ? { nodeId: out.nodeId } : {},
-              ...out.native === true ? { native: true } : {}
+              ...out.native === true ? { native: true } : {},
+              ...childId !== null ? { callerAddonId: childId } : {}
             };
             const pinnedNodeId = out.nodeId ?? extractNodeId(out.args);
             const pinTargetsThisNode = pinnedNodeId !== void 0 && this.ownNodeId !== void 0 && pinnedNodeId === this.ownNodeId;
@@ -115546,7 +115895,7 @@ var require_manifest_python_deps_Bu8H1_rg = __commonJS({
             ...nodeId !== void 0 ? { nodeId } : {},
             ...deviceId !== void 0 ? { deviceId } : {}
           });
-          return await resolver.dispatch(route, input.method, input.args);
+          return input.callerAddonId !== void 0 ? await resolver.dispatch(route, input.method, input.args, void 0, input.callerAddonId) : await resolver.dispatch(route, input.method, input.args);
         } catch (err) {
           if (!(err instanceof CapRouteError) || err.reason !== "no-provider") throw err;
         }
@@ -121417,7 +121766,7 @@ var require_dist3 = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_D5Jhh8Vk();
+    var require_dist10 = require_dist_jRSrzoXr();
     var require_builtins_alerts_alerts_addon = require_alerts_addon();
     require_alerts();
     var require_formatter = require_formatter_DqAKDlvN();
@@ -121443,7 +121792,7 @@ var require_dist3 = __commonJS({
     var require_builtins_winston_logging_index = require_winston_logging();
     var require_file_data_plane = require_file_data_plane_DO8KbxCe();
     var require_tls$1 = require_tls_u8QCJCFE();
-    var require_manifest_python_deps = require_manifest_python_deps_Bu8H1_rg();
+    var require_manifest_python_deps = require_manifest_python_deps_DBQarwp9();
     var require_resource_monitor = require_resource_monitor_CdnzxBLP();
     var require_custom_action_registry = require_custom_action_registry_jY0NOZK8();
     var zod = require_zod();
@@ -202065,7 +202414,7 @@ var require_dist4 = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_event_category = require_event_category_EY0GNjV9();
-    var require_sleep = require_sleep_DnbNfEhn();
+    var require_sleep = require_sleep_CSodb2vQ();
     var require_canonical_hash = require_canonical_hash_DNV8S5ET();
     var require_enums2 = require_enums();
     var require_err_msg = require_err_msg_COpsHMw2();
@@ -213052,7 +213401,23 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       updatedAt: zod.z.number(),
       /** Failure detail — present on a `dead` row. */
       error: zod.z.string().optional(),
-      subject: NcHistorySubjectSchema
+      subject: NcHistorySubjectSchema,
+      /**
+      * Ids of the artefacts (still, then gif, then clip) this row's successful
+      * delivery indexed in the artefact library — a REFERENCE, never the bytes
+      * (an artefact is often megabytes; this row is durable JSON rewritten on
+      * every delivery attempt). Absent on a row still pending/dead, a row
+      * delivered before this field shipped, or a wiring with no artefact index.
+      *
+      * Resolve one to a fetchable URL with `resolveArtifactUrl` — an id
+      * outlives any one URL's TTL, so a caller mints a fresh link on demand
+      * rather than trusting one frozen at delivery time. `resolveArtifactUrl`
+      * also answers `null` for an id whose artefact has since expired past the
+      * retained shelf's own age bound — the degrade a caller (the Home
+      * Assistant export) must render as "no image right now", never as a
+      * broken link.
+      */
+      artifactIds: zod.z.array(zod.z.string().min(1)).optional()
     });
     var NC_HISTORY_LIMIT_DEFAULT = 100;
     var NC_HISTORY_LIMIT_MAX = 500;
@@ -213300,6 +213665,20 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         */
         getHistory: require_sleep.method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" }),
         /**
+        * Mint a fresh, externally-reachable URL for one artefact a history row
+        * named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
+        * signed-link mechanism the dispatcher uses to attach media to an
+        * outgoing notification (one derivation; this never re-implements it).
+        *
+        * `url: null` on THREE causes a caller must treat identically ("no image
+        * right now", never a broken link): the id is unknown, its artefact has
+        * expired past the retained shelf's own age bound, or this install has no
+        * externally-reachable base URL. A caller that received a URL on a
+        * previous call and now gets `null` must stop showing it — a link that
+        * worked five minutes ago is not proof it works now.
+        */
+        resolveArtifactUrl: require_sleep.method(zod.z.object({ artifactId: zod.z.string().min(1) }), zod.z.object({ url: zod.z.string().nullable() }), { auth: "admin" }),
+        /**
         * Snooze windows currently in effect, plus any whose digest has not yet
         * gone out. `caller: 'required'`: a user sees their OWN windows and the
         * global ones that silence them, never another person's private silence.
@@ -213539,6 +213918,726 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         getDescriptor: require_sleep.method(zod.z.void(), OauthIntegrationDescriptorSchema, { auth: "admin" })
       }
     };
+    var NativeCropRefSchema = zod.z.object({
+      /** Handle keying the retained native surface (node-pinned to its owner). */
+      handle: require_sleep.FrameHandleSchema,
+      /** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
+      cropFrameSpace: zod.z.object({
+        x: zod.z.number(),
+        y: zod.z.number(),
+        w: zod.z.number(),
+        h: zod.z.number()
+      })
+    });
+    zod.z.object({
+      crop: zod.z.object({
+        left: zod.z.number(),
+        top: zod.z.number(),
+        width: zod.z.number().positive(),
+        height: zod.z.number().positive()
+      }).optional(),
+      content: zod.z.object({
+        width: zod.z.number().int().positive(),
+        height: zod.z.number().int().positive()
+      }),
+      fit: zod.z.enum(["stretch", "contain"]),
+      format: zod.z.enum([
+        "rgb",
+        "gray",
+        "jpeg"
+      ])
+    });
+    var FrameRefSchema = zod.z.object({
+      registryId: zod.z.string().min(1),
+      id: zod.z.string().min(1),
+      width: zod.z.number().int().positive(),
+      height: zod.z.number().int().positive(),
+      format: zod.z.enum(["rgb", "gray"]),
+      timestamp: zod.z.number(),
+      capturedAt: zod.z.number().optional()
+    });
+    var ModelFormatSchema$1 = zod.z.enum([
+      "onnx",
+      "coreml",
+      "openvino",
+      "tflite",
+      "pt",
+      "gguf"
+    ]);
+    var PipelineSlotSchema = zod.z.enum([
+      "detector",
+      "cropper",
+      "classifier",
+      "refiner",
+      "audio-classifier"
+    ]);
+    var PipelineEngineChoiceSchema = zod.z.object({
+      runtime: zod.z.enum(["node", "python"]),
+      backend: zod.z.string(),
+      format: ModelFormatSchema$1,
+      device: zod.z.string().optional()
+    });
+    var EngineDeviceInfoSchema = zod.z.object({
+      id: zod.z.string(),
+      label: zod.z.string(),
+      description: zod.z.string().optional()
+    });
+    var AvailableEngineSchema = zod.z.object({
+      engine: PipelineEngineChoiceSchema,
+      devices: zod.z.array(EngineDeviceInfoSchema).readonly(),
+      defaultDevice: zod.z.string()
+    });
+    var PipelineDefaultStepSchema = zod.z.lazy(() => zod.z.object({
+      addonId: zod.z.string(),
+      addonName: zod.z.string(),
+      slot: PipelineSlotSchema,
+      inputClasses: zod.z.array(zod.z.string()).readonly(),
+      outputClasses: zod.z.array(zod.z.string()).readonly(),
+      enabled: zod.z.boolean(),
+      modelId: zod.z.string(),
+      children: zod.z.array(PipelineDefaultStepSchema).readonly(),
+      group: zod.z.string().optional(),
+      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }));
+    var PipelineTemplateStepSchema = zod.z.lazy(() => zod.z.object({
+      addonId: zod.z.string(),
+      enabled: zod.z.boolean(),
+      modelId: zod.z.string(),
+      children: zod.z.array(PipelineTemplateStepSchema).readonly(),
+      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+    }));
+    var PipelineTemplateSchema$1 = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      createdAt: zod.z.string(),
+      updatedAt: zod.z.string(),
+      engine: PipelineEngineChoiceSchema,
+      steps: zod.z.array(PipelineTemplateStepSchema).readonly()
+    });
+    var PipelineModelOptionSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      formats: zod.z.record(zod.z.string(), zod.z.object({
+        downloaded: zod.z.boolean(),
+        sizeMB: zod.z.number()
+      })),
+      group: ModelVariantGroupSchema.optional(),
+      legacy: zod.z.boolean().optional(),
+      provider: ModelProviderIdSchema.optional()
+    });
+    var ConfigFieldBridge = zod.z.custom();
+    var PipelineAddonSchemaSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      slot: PipelineSlotSchema,
+      inputClasses: zod.z.array(zod.z.string()).readonly(),
+      outputClasses: zod.z.array(zod.z.string()).readonly(),
+      childSlots: zod.z.array(PipelineSlotSchema).readonly(),
+      models: zod.z.array(PipelineModelOptionSchema).readonly(),
+      defaultModelId: zod.z.string(),
+      defaultModelIdByFormat: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+      enabledByDefault: zod.z.boolean().optional(),
+      backfillIntoExistingOverrides: zod.z.boolean().optional(),
+      defaultConfidence: zod.z.number(),
+      group: zod.z.string().optional(),
+      configSchema: zod.z.array(ConfigFieldBridge).readonly().optional()
+    });
+    var PipelineSlotSchemaSchema = zod.z.object({
+      id: PipelineSlotSchema,
+      label: zod.z.string(),
+      priority: zod.z.number(),
+      parentSlot: PipelineSlotSchema.nullable(),
+      addons: zod.z.array(PipelineAddonSchemaSchema).readonly()
+    });
+    var PipelineSchemaSchema = zod.z.object({
+      availableEngines: zod.z.array(AvailableEngineSchema).readonly(),
+      selectedEngine: PipelineEngineChoiceSchema,
+      slots: zod.z.array(PipelineSlotSchemaSchema).readonly()
+    });
+    var EngineProvisioningSchema = zod.z.object({
+      runtimeId: zod.z.enum([
+        "onnx",
+        "openvino",
+        "coreml",
+        "edgetpu"
+      ]).nullable(),
+      device: zod.z.string().nullable(),
+      state: zod.z.enum([
+        "idle",
+        "installing",
+        "verifying",
+        "ready",
+        "failed"
+      ]),
+      progress: zod.z.number().optional(),
+      error: zod.z.string().optional(),
+      nextRetryAt: zod.z.number().optional(),
+      /**
+      * Gate A (config-correctness gate at engine change): human-readable
+      * config issues surfaced EAGERLY when the node's engine changes — model
+      * substitutions ("chose X, running Y") and zero-build steps ("no model
+      * has a <format> build"). Additive/optional: informational only, never
+      * enforced here — `assertEngineReady` (readiness) still gates inference.
+      * Absent/empty when the node-default tree resolves cleanly.
+      */
+      configIssues: zod.z.array(zod.z.string()).optional()
+    });
+    var PipelineStepInputSchema = zod.z.lazy(() => zod.z.object({
+      addonId: zod.z.string(),
+      modelId: zod.z.string().optional(),
+      enabled: zod.z.boolean().default(true),
+      children: zod.z.array(PipelineStepInputSchema).optional(),
+      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+      jumpDeviceKey: zod.z.string().optional()
+    }));
+    var ModelSubstitutionSchema = zod.z.object({
+      addonId: zod.z.string(),
+      chosen: zod.z.string(),
+      running: zod.z.string(),
+      format: zod.z.string()
+    });
+    var PipelineValidationIssueSchema = zod.z.object({
+      addonId: zod.z.string(),
+      kind: zod.z.enum(["unknown-addon", "no-format-build"]),
+      detail: zod.z.string()
+    });
+    var PipelineValidationResultSchema = zod.z.object({
+      ok: zod.z.boolean(),
+      issues: zod.z.array(PipelineValidationIssueSchema).readonly(),
+      substitutions: zod.z.array(ModelSubstitutionSchema).readonly(),
+      /** The node's `currentEngine.format` this validation ran against. */
+      format: zod.z.string()
+    });
+    var ReferenceImageEntrySchema = zod.z.object({
+      filename: zod.z.string(),
+      stepIds: zod.z.array(zod.z.string()).readonly().optional()
+    });
+    var ReferenceImageBodySchema = zod.z.object({
+      base64: zod.z.string(),
+      filename: zod.z.string()
+    });
+    var ReferenceAudioEntrySchema = zod.z.object({
+      filename: zod.z.string(),
+      sizeKb: zod.z.number()
+    });
+    var ReferenceAudioBodySchema = zod.z.object({ base64: zod.z.string() });
+    var AudioBackendSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      description: zod.z.string(),
+      available: zod.z.boolean(),
+      /**
+      * Raw classifier labels this backend can emit (e.g. YAMNet's
+      * 521-class set or Apple SoundAnalysis's 303-class set). Used by
+      * the benchmark UI to populate the `enabledMicroClasses` filter
+      * specific to the selected backend without a separate fetch.
+      */
+      rawLabels: zod.z.array(zod.z.string()).readonly().optional()
+    });
+    var AudioCapabilitiesSchema = zod.z.object({
+      activeBackend: zod.z.string(),
+      availableBackends: zod.z.array(AudioBackendSchema).readonly(),
+      sampleRate: zod.z.number(),
+      chunkDurationMs: zod.z.number()
+    });
+    var DownloadModelResultSchema = zod.z.object({
+      filePath: zod.z.string(),
+      sizeMB: zod.z.number(),
+      durationMs: zod.z.number()
+    });
+    var AudioTestResultSchema = zod.z.object({
+      success: zod.z.boolean(),
+      error: zod.z.string().optional(),
+      frame: zod.z.custom().optional()
+    });
+    var PipelineConfigBridge = zod.z.custom();
+    var ConfigUISchemaBridge = zod.z.custom();
+    var ConfigUISchemaNullableBridge = zod.z.custom();
+    var InferenceCapabilitiesBridge = zod.z.custom();
+    var ModelAvailabilityListBridge = zod.z.custom();
+    var PipelineRunResultBridge = zod.z.custom();
+    var pipelineExecutorCapability = {
+      name: "pipeline-executor",
+      scope: "system",
+      mode: "singleton",
+      methods: {
+        getAvailableEngines: require_sleep.method(zod.z.void(), zod.z.array(PipelineEngineChoiceSchema)),
+        getSelectedEngine: require_sleep.method(zod.z.void(), PipelineEngineChoiceSchema),
+        getDefaultSteps: require_sleep.method(PipelineEngineChoiceSchema, zod.z.array(PipelineDefaultStepSchema)),
+        /**
+        * Per-node detection-engine provisioning snapshot. Returns the live
+        * state of the lazy runtime-provisioning machine on `nodeId`
+        * (idle / installing / verifying / ready / failed). The UI pairs this
+        * one-shot query with the `pipeline.engine-provisioning` live event
+        * (emitted on every transition) to drive a per-node "engine ready?"
+        * indicator without polling. Phase 2.
+        */
+        getEngineProvisioning: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), EngineProvisioningSchema),
+        getVideoPipelineSteps: require_sleep.method(zod.z.void(), zod.z.record(zod.z.string(), zod.z.object({
+          modelId: zod.z.string(),
+          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
+        }))),
+        setVideoPipelineSteps: require_sleep.method(zod.z.object({ steps: zod.z.record(zod.z.string(), zod.z.object({
+          modelId: zod.z.string(),
+          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
+        })) }), zod.z.object({ success: zod.z.literal(true) }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        /**
+        * Clear THIS node's executor-side PER-DEVICE settings stores (the
+        * per-camera step overrides the object-detection root reads via
+        * `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
+        * generated cap-router strips it (default `nodeIdMode: 'routing'`) and
+        * dispatches to that node, so the provider method runs ON the target
+        * node and receives no `nodeId`.
+        *
+        * This is the slimmed executor leg of the orchestrator's
+        * `resetNodePipelineDefaults` flow (which owns the real reset: node
+        * addonDefaults pins + per-camera orchestrator overrides). The legacy
+        * `resetToDefault` — which reset a persisted global step-tree seed
+        * nothing in the live per-camera path read — was removed together with
+        * that seed.
+        */
+        clearDeviceOverrides: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({
+          success: zod.z.literal(true),
+          clearedDevices: zod.z.number()
+        }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        /**
+        * Which of THIS node's inference devices the executor currently refuses,
+        * and why. `nodeId` is the ROUTING key (stripped by the generated router).
+        *
+        * The channel that did not exist. Pool health was known only inside the
+        * detection addon and was an input to no routing decision anywhere: the
+        * per-dispatch capability gate is keyed on model FORMAT and so can never
+        * separate `openvino:gpu` from `openvino:npu`, and the orchestrator's live
+        * eligibility probe (`platformProbe.getCapabilities`) answers about
+        * HARDWARE — which was present throughout. So when the hub's `openvino:gpu`
+        * Python worker was SIGABRT'd by the Intel GPU plugin on 2026-08-25, the
+        * balancer went on handing that dead pool cameras by rotation for 31 hours:
+        * ~370 000 `PoolWorker[w0]: not initialized` lines, every frame lost.
+        *
+        * Read semantics the caller depends on, and which the provider guarantees:
+        * this is a synchronous read of in-memory state. It never probes hardware,
+        * never spawns a pool and never throws — an EMPTY `unhealthy` means "asked,
+        * nothing is refused", which is what re-admits a device. A read that FAILS
+        * (node offline, version skew) must therefore be distinguishable from an
+        * empty answer, and it is: it rejects.
+        */
+        getInferenceDeviceHealth: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({ unhealthy: zod.z.array(zod.z.object({
+          /** `<backend>:<device>`, e.g. `openvino:gpu`. */
+          deviceKey: zod.z.string(),
+          /**
+          * `failed` — the per-device restart budget is exhausted; no pool
+          * will be spawned until an operator re-arms it or the runner
+          * respawns. `backoff` — under budget, waiting out the backoff (or
+          * a cached pool observed dead and not yet condemned).
+          */
+          state: zod.z.enum(["failed", "backoff"]),
+          /** Epoch ms of the death that produced this state. */
+          since: zod.z.number(),
+          /** Pool deaths inside the current window. */
+          deaths: zod.z.number(),
+          /** The last death's message. */
+          lastError: zod.z.string()
+        })).readonly() })),
+        /**
+        * Re-arm a terminally `failed` inference device on `nodeId`: forget its
+        * restart budget so the next dispatch builds a fresh pool.
+        *
+        * The terminal state is deliberate (the abort it bounds is deterministic —
+        * an automatic probation would just respawn Python forever, more slowly),
+        * and a terminal state an operator cannot leave is a silent fault. This is
+        * the way out. `rearmed:false` means there was nothing to forget.
+        */
+        rearmInferenceDevice: require_sleep.method(zod.z.object({
+          nodeId: zod.z.string(),
+          deviceKey: zod.z.string()
+        }), zod.z.object({ rearmed: zod.z.boolean() }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        getSchema: require_sleep.method(zod.z.void(), PipelineSchemaSchema),
+        getGlobalSteps: require_sleep.method(zod.z.void(), zod.z.array(PipelineDefaultStepSchema).readonly().nullable()),
+        getGlobalPipelineConfig: require_sleep.method(zod.z.void(), PipelineConfigBridge),
+        getOrchestratorConfigSchema: require_sleep.method(zod.z.void(), ConfigUISchemaBridge),
+        /**
+        * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
+        * node's `currentEngine.format` — resolves `steps` the same way the
+        * runtime dispatch path would, and reports what WOULD happen without
+        * touching any node-global state. Called by the orchestrator at attach
+        * time (`attachOn`), node-pinned to the TARGET node, so config problems
+        * surface BEFORE `pipelineRunner.attachCamera` rather than at the first
+        * per-frame resolve. `ok` is false iff `issues` is non-empty (both
+        * `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
+        * is informational (a degraded-but-loadable model swap) and never
+        * affects `ok`. Never throws.
+        */
+        validatePipeline: require_sleep.method(zod.z.object({ steps: zod.z.array(PipelineStepInputSchema) }), PipelineValidationResultSchema),
+        listTemplates: require_sleep.method(zod.z.void(), zod.z.array(PipelineTemplateSchema$1).readonly()),
+        saveTemplate: require_sleep.method(zod.z.object({
+          name: zod.z.string(),
+          steps: zod.z.array(PipelineTemplateStepSchema).readonly(),
+          engine: PipelineEngineChoiceSchema
+        }), PipelineTemplateSchema$1, { kind: "mutation" }),
+        updateTemplate: require_sleep.method(zod.z.object({
+          id: zod.z.string(),
+          name: zod.z.string().optional(),
+          steps: zod.z.array(PipelineTemplateStepSchema).readonly().optional()
+        }), PipelineTemplateSchema$1, { kind: "mutation" }),
+        deleteTemplate: require_sleep.method(zod.z.object({ id: zod.z.string() }), zod.z.void(), { kind: "mutation" }),
+        getCapabilities: require_sleep.method(zod.z.void(), InferenceCapabilitiesBridge),
+        getAddonModels: require_sleep.method(zod.z.object({ addonId: zod.z.string() }), ModelAvailabilityListBridge),
+        downloadModel: require_sleep.method(zod.z.object({
+          addonId: zod.z.string(),
+          modelId: zod.z.string(),
+          format: ModelFormatSchema$1
+        }), DownloadModelResultSchema, { kind: "mutation" }),
+        deleteModel: require_sleep.method(zod.z.object({
+          addonId: zod.z.string(),
+          modelId: zod.z.string(),
+          format: ModelFormatSchema$1
+        }), zod.z.object({ success: zod.z.literal(true) }), { kind: "mutation" }),
+        /**
+        * Stateless single-frame execution. Callers (runner, benchmark) pass
+        * the complete `engine` + `steps` tree; the executor holds no state
+        * about cameras or saved pipelines.
+        *
+        * `engine` is optional during the migration window to preserve the
+        * legacy call shape used by existing benchmark code; once all
+        * callers pass it explicitly we make it required.
+        *
+        * Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
+        * `referenceImage` must be provided:
+        *  - `frame`: runtime dispatch path (runner → decoded broker frame).
+        *    Carries the raw buffer, dimensions, and format; the executor
+        *    uses it directly without base64 round-tripping.
+        *  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
+        *    decoded frame. Both runner and executor are hub-local processes
+        *    sharing `/dev/shm`, so the executor maps the named segment and
+        *    reads the pixels back zero-copy — eliminating the ~1.2MB
+        *    re-serialisation over UDS/MsgPack the `frame` path pays per call.
+        *    High-risk: the FrameRing is a latest-wins seqlock with no
+        *    refcount, so a recycled slot yields a null read; the executor
+        *    then degrades to an empty result and the runner ships pixels via
+        *    `frame` as the fallback (queue-depth gated on the runner side).
+        *  - `imageBase64`: one-shot test path (benchmark ImageTab).
+        *  - `referenceImage`: named file from the reference-image store.
+        */
+        runPipeline: require_sleep.method(zod.z.object({
+          engine: PipelineEngineChoiceSchema.optional(),
+          steps: zod.z.array(PipelineStepInputSchema).min(1),
+          frame: FrameInputSchema.optional(),
+          /**
+          * Process-local lazy frame. Valid only when caller and provider resolve
+          * in the same execution-group process; split/cross-node callers use
+          * `frame`/`image` inline compatibility instead.
+          */
+          frameRef: FrameRefSchema.optional(),
+          /**
+          * CB5 shm passthrough — a `FrameHandle` naming the same ring slot
+          * the decoded pixels live in. One more member of the one-of
+          * frame/frameHandle/image/imageBase64/referenceImage group.
+          */
+          frameHandle: require_sleep.FrameHandleSchema.optional(),
+          imageBase64: zod.z.string().optional(),
+          /**
+          * Binary JPEG bytes — preferred over `imageBase64` on internal
+          * hops (hub → forked worker via Moleculer MsgPack) because it
+          * skips the 33% base64 overhead + the per-call base64 decode on
+          * the detection-pipeline worker. Callers can pass either; exactly
+          * one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
+          */
+          image: zod.z.instanceof(Uint8Array).optional(),
+          referenceImage: zod.z.string().optional(),
+          deviceId: zod.z.number().optional(),
+          sessionId: zod.z.string().optional(),
+          /**
+          * Execution plane. 'full' (default) runs the whole tree — benchmark,
+          * reference-image, and detail-subtree calls. 'frame' is the live
+          * per-frame dispatch: ONLY root-plane steps run; crop children
+          * (inputClasses ≠ null) are skipped and served per-track via
+          * pipelineRunner.runDetailSubtree (two-plane design).
+          */
+          plane: zod.z.enum(["full", "frame"]).optional(),
+          /**
+          * Inference-device selector (Phase 2 multi-device). Format
+          * `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
+          * Omitted ⇒ the runner's default device (current single-engine
+          * behaviour). Selects WHICH device pool of the node runs the call.
+          */
+          deviceKey: zod.z.string().optional(),
+          /**
+          * Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
+          * when the parent crop was resolved from the frame's retained NATIVE
+          * surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
+          * child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
+          * resolution from that surface — the SAME quality path faces already
+          * had — instead of the downscaled parent tile. `handle` keys the native
+          * surface (node-pinned to its owner); `cropFrameSpace` is the parent
+          * crop's padded/clamped rectangle in FRAME-space pixels, used to compose
+          * the executor's crop-normalized child ROI back into frame-normalized
+          * coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
+          * of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
+          * (today's behaviour on the fallback path).
+          */
+          nativeCropRef: NativeCropRefSchema.optional()
+        }), PipelineRunResultBridge, { kind: "mutation" }),
+        /**
+        * Batched run — N raw frames packed into one cap call. The provider
+        * routes the batch through `SharedInferencePool.inferBatch`
+        * (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
+        * envelope cost is amortised N:1 vs N concurrent `runPipeline`
+        * calls. Single root step + uniform model assumed; trees with crop
+        * children fall back to sequential execution.
+        *
+        * Used by `scripts/bench-batch-style.mts` for batch benchmarking —
+        * N frames in one call to amortise per-call IPC overhead.
+        */
+        runPipelineBatch: require_sleep.method(zod.z.object({
+          engine: PipelineEngineChoiceSchema.optional(),
+          steps: zod.z.array(PipelineStepInputSchema).min(1),
+          frames: zod.z.array(FrameInputSchema).min(1).max(255),
+          deviceId: zod.z.number().optional(),
+          sessionId: zod.z.string().optional(),
+          /**
+          * Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
+          * the batch to the Python pool's bench preprocess cache
+          * (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
+          * preprocessed ONCE and every later inference is a pure-inference cache
+          * hit — the sustained-throughput run measures inference, not
+          * decode+preprocess+infer. Omitted/0 for live frames (all different →
+          * full preprocess every call, correct). Fresh per sustained run;
+          * released via `uncacheFrame`.
+          */
+          frameId: zod.z.number().int().nonnegative().optional(),
+          /** Inference-device selector (Phase 2 multi-device); see runPipeline. */
+          deviceKey: zod.z.string().optional()
+        }), zod.z.object({ results: zod.z.array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
+        /**
+        * Cache a raw frame inside the Python inference pool's memory.
+        * Returns a numeric `frameId` that `inferCached` references —
+        * subsequent calls send only 5 bytes through the pipe instead of
+        * 1.2MB raw data, eliminating the pipe transfer bottleneck.
+        */
+        cacheFrameInPool: require_sleep.method(zod.z.object({
+          data: zod.z.instanceof(Uint8Array),
+          width: zod.z.number().int().positive(),
+          height: zod.z.number().int().positive(),
+          format: zod.z.enum([
+            "rgb",
+            "bgr",
+            "gray"
+          ])
+        }), zod.z.object({
+          frameId: zod.z.number(),
+          width: zod.z.number(),
+          height: zod.z.number()
+        }), { kind: "mutation" }),
+        /**
+        * Run inference on a previously cached frame. Sends only 5 bytes
+        * (model_idx + frameId) through the IPC pipe — eliminates the
+        * ~35ms per-call overhead of transferring 1.2MB raw data.
+        */
+        inferCached: require_sleep.method(zod.z.object({
+          stepId: zod.z.string(),
+          frameId: zod.z.number().int()
+        }), zod.z.record(zod.z.string(), zod.z.unknown()), { kind: "mutation" }),
+        /**
+        * Release a cached frame from the Python pool's memory.
+        */
+        uncacheFrame: require_sleep.method(zod.z.object({ frameId: zod.z.number().int() }), zod.z.void(), { kind: "mutation" }),
+        /** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
+        getEffectiveTuning: require_sleep.method(zod.z.void(), zod.z.object({
+          batchMode: zod.z.string(),
+          windowMs: zod.z.number(),
+          maxBatchSize: zod.z.number(),
+          concurrency: zod.z.number()
+        })),
+        /**
+        * List every EngineFactory currently loaded in this executor's RAM,
+        * with the models resident and a coarse "in use" marker derived from
+        * ongoing inference activity. Used by the Pipeline page Engines tab.
+        */
+        listLoadedEngines: require_sleep.method(zod.z.void(), zod.z.array(zod.z.object({
+          engineKey: zod.z.string(),
+          engine: PipelineEngineChoiceSchema,
+          modelsLoaded: zod.z.array(zod.z.string()).readonly(),
+          inUseByCameras: zod.z.array(zod.z.number()).readonly(),
+          /**
+          * Origin of this resident factory.
+          *  - `runtime`       — main camera-serving engine (no idle TTL).
+          *  - `warm-override` — benchmark/test override held in the warm
+          *                      cache; auto-disposed after the idle TTL.
+          *  - `device-pool`   — a concurrent per-device pool (Phase 2
+          *                      multi-device, keyed by `deviceKey`) resolved
+          *                      via `resolveDeviceFactory`. Runs alongside the
+          *                      `runtime` engine on a DIFFERENT accelerator
+          *                      (NPU / iGPU / Coral) — this is how the
+          *                      Engines tab shows all pools running at once.
+          */
+          kind: zod.z.enum([
+            "runtime",
+            "warm-override",
+            "device-pool"
+          ]),
+          /** Native pid of the underlying Python pool (null when no pool). */
+          poolPid: zod.z.number().nullable(),
+          /** ms since this factory was last used (null when not warm-tracked). */
+          idleMs: zod.z.number().nullable(),
+          /** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
+          idleTtlMs: zod.z.number().nullable()
+        })).readonly()),
+        /** Warm up an engine without running a frame. No-op if already loaded. */
+        spinEngine: require_sleep.method(zod.z.object({ engine: PipelineEngineChoiceSchema }), zod.z.object({ success: zod.z.literal(true) }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        /**
+        * Unload an engine from RAM. `force:true` unloads even when cameras
+        * are actively using it (they re-spin on next frame). Default is
+        * gated — returns `{success:false, reason}` when in use.
+        */
+        killEngine: require_sleep.method(zod.z.object({
+          engine: PipelineEngineChoiceSchema,
+          force: zod.z.boolean().optional()
+        }), zod.z.object({
+          success: zod.z.boolean(),
+          reason: zod.z.string().optional()
+        }), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        listReferenceImages: require_sleep.method(zod.z.void(), zod.z.array(ReferenceImageEntrySchema).readonly()),
+        getReferenceImage: require_sleep.method(zod.z.object({ filename: zod.z.string() }), ReferenceImageBodySchema.nullable()),
+        getReferenceAudioFiles: require_sleep.method(zod.z.void(), zod.z.array(ReferenceAudioEntrySchema).readonly()),
+        getReferenceAudio: require_sleep.method(zod.z.object({ filename: zod.z.string() }), ReferenceAudioBodySchema.nullable()),
+        getAudioCapabilities: require_sleep.method(zod.z.void(), AudioCapabilitiesSchema),
+        runAudioTest: require_sleep.method(zod.z.object({
+          addonId: zod.z.string(),
+          modelId: zod.z.string(),
+          filename: zod.z.string().optional(),
+          settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+        }), AudioTestResultSchema, { kind: "mutation" }),
+        getDetectionConfigSchema: require_sleep.method(zod.z.void(), ConfigUISchemaNullableBridge)
+      }
+    };
+    var ZoneRuleModeEnum = zod.z.enum(["include", "exclude"]);
+    var ZoneRuleSchema = zod.z.object({
+      /** Stable rule id — survives edits, used by the UI for diffing. */
+      id: zod.z.string(),
+      /** Optional human-readable label rendered in the rule editor. */
+      name: zod.z.string().optional(),
+      /** Zones this rule targets. The rule's `mode` applies to ALL
+      *  listed zones (OR-set: a detection in any one of them counts).
+      *  At least one zone id required — a rule with no targets is a
+      *  configuration mistake and the form validator rejects it. */
+      zoneIds: zod.z.array(zod.z.string()).min(1).readonly(),
+      mode: ZoneRuleModeEnum,
+      /**
+      * Class names this rule applies to. Empty / undefined ⇒ rule
+      * applies to every class. Class strings match the `macroClass`
+      * field on detections (e.g. `person`, `car`, `dog`).
+      */
+      classFilter: zod.z.array(zod.z.string()).readonly().optional(),
+      /**
+      * Minimum bbox/mask overlap (0–1) with any of the rule's zones
+      * required to consider an entity "in the zone". Defaults to the
+      * consumer's stage default when omitted. Kept for back-compat with
+      * existing per-rule overrides; new operators pick the value via
+      * `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
+      * set, the lower-level engine reads it as a 0–1 fraction.
+      */
+      overlapThreshold: zod.z.number().min(0).max(1).optional(),
+      /**
+      * Operator-friendly version of `overlapThreshold` — the percentage
+      * of the detection's bbox that must lie inside the zone for the
+      * rule to match. Documented default is 85%; the engine substitutes
+      * that when the field is omitted (kept optional so existing rules
+      * stored without it stay valid).
+      *
+      * When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
+      * rule, the engine prefers `bboxInclusionPct` because it's the
+      * field exposed in the UI. Internally both feed the same gate.
+      */
+      bboxInclusionPct: zod.z.number().min(0).max(100).optional(),
+      /**
+      * When `true` and a detection has a segmentation mask, use the
+      * mask for overlap instead of the bbox. Detection-stage only;
+      * motion rules ignore this field.
+      */
+      preferMask: zod.z.boolean().optional(),
+      /**
+      * Soft-toggle: `false` disables the rule without deleting it.
+      * Defaults to `true` so operators creating a rule via the UI
+      * see it active immediately.
+      */
+      enabled: zod.z.boolean().default(true)
+    });
+    var ZoneRulesArraySchema = zod.z.array(ZoneRuleSchema).readonly();
+    var ZoneKindEnum = zod.z.enum(["polygon", "tripwire"]);
+    var PolygonPointSchema = zod.z.object({
+      x: zod.z.number(),
+      y: zod.z.number()
+    });
+    var ZoneSchema = zod.z.object({
+      id: zod.z.string(),
+      name: zod.z.string(),
+      kind: ZoneKindEnum.default("polygon"),
+      /** Polygon vertices, fraction of frame (0–1). */
+      polygon: zod.z.array(PolygonPointSchema).readonly(),
+      /** Visual color for UI rendering. */
+      color: zod.z.string().default("#3b82f6")
+    });
+    var zonesCapability = {
+      name: "zones",
+      scope: "device",
+      mode: "singleton",
+      deviceTypes: [require_sleep.DeviceType.Camera],
+      methods: {
+        listZones: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.array(ZoneSchema).readonly()),
+        addZone: require_sleep.method(zod.z.object({
+          deviceId: zod.z.number(),
+          zone: ZoneSchema
+        }), zod.z.void(), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        removeZone: require_sleep.method(zod.z.object({
+          deviceId: zod.z.number(),
+          zoneId: zod.z.string()
+        }), zod.z.void(), {
+          kind: "mutation",
+          auth: "admin"
+        }),
+        updateZone: require_sleep.method(zod.z.object({
+          deviceId: zod.z.number(),
+          zone: ZoneSchema
+        }), zod.z.void(), {
+          kind: "mutation",
+          auth: "admin"
+        })
+      },
+      /**
+      * Runtime-state slice — the live zone catalogue mirrored by the
+      * orchestrator on every CRUD mutation. Consumers read via
+      * `device.state.zones.value` / `.watch(...)` without round-tripping
+      * the cap, and the codegen DeviceProxy auto-wires the reactive
+      * handle. Slice shape is `{ zones: Zone[] }` so future extensions
+      * (e.g. zone groupings) can sit alongside the polygon list.
+      */
+      runtimeState: zod.z.object({ zones: zod.z.array(ZoneSchema).readonly() }),
+      /**
+      * Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
+      *
+      * See `RuntimeStateDurability`. Enforced by
+      * `scripts/check-runtime-state-durability.ts`.
+      */
+      durability: "restored"
+    };
     var TrackStateSchema = zod.z.enum([
       "new",
       "entered",
@@ -214359,6 +215458,25 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       /** Present when the pass ended by throwing. */
       error: zod.z.string().nullable()
     });
+    var ReplayFrameInputSchema = zod.z.object({
+      timestamp: zod.z.number(),
+      frame: PipelineRunResultBridge
+    });
+    var ReplayTrackSchema = zod.z.object({
+      className: zod.z.string(),
+      firstSeenMs: zod.z.number(),
+      lastSeenMs: zod.z.number(),
+      /** Bbox of the track's FIRST matched detection, pixel-space in the clip's
+      *  frame — a representative box for the diff's `(className, window, IoU)`
+      *  pairing (`replay-diff.ts`). A replay does not need the full per-frame
+      *  trajectory production's `Track.positions` keeps. */
+      bbox: BoundingBoxSchema,
+      /** How many of the input frames this track matched a real detection on
+      *  (never a coasted/extrapolated frame) — the replay's own signal for "how
+      *  solid is this track", cheaper than re-deriving it from a trajectory. */
+      framesMatched: zod.z.number().int()
+    });
+    var RunReplayFrameProcessorResultSchema = zod.z.object({ tracks: zod.z.array(ReplayTrackSchema).readonly() });
     var pipelineAnalyticsCapability = {
       name: "pipeline-analytics",
       scope: "device",
@@ -214849,6 +215967,32 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
           kind: "mutation",
           auth: "admin"
         }),
+        /**
+        * The FrameProcessor pass of a replay run — see the `Replay` section
+        * above this capability's definition for why this is not the
+        * `processFrame` method this file's header says pipeline-analytics does
+        * not have.
+        *
+        * Constructs a FRESH `FrameProcessor` for `(deviceId, source)`, feeds it
+        * `frames` IN THE ORDER GIVEN (the caller is responsible for time
+        * ordering — this method does not sort), and returns the tracks it
+        * produced. Zero persistence: no `TrackStore`, no event bus, no media
+        * capture. `zones` / `detectionRules` are the run's OWN zone set —
+        * typically the camera's real zones plus an ephemeral overlay
+        * (`addon-benchmark`'s `replay-plan.ts`), never read from or written to
+        * the `zones` capability by this method itself.
+        */
+        runReplayFrameProcessor: require_sleep.method(zod.z.object({
+          deviceId: zod.z.number(),
+          source: DetectionSourceSchema,
+          zones: zod.z.array(ZoneSchema).readonly().optional(),
+          detectionRules: zod.z.array(ZoneRuleSchema).readonly().optional(),
+          zoneMembershipMinOverlap: zod.z.number().min(0).max(1).optional(),
+          frames: zod.z.array(ReplayFrameInputSchema).min(1)
+        }), RunReplayFrameProcessorResultSchema, {
+          kind: "mutation",
+          auth: "admin"
+        }),
         /** Every annotation on a track, oldest first. */
         listRetrainAnnotations: require_sleep.method(zod.z.object({ trackId: zod.z.string() }), zod.z.array(RetrainAnnotationSchema).readonly(), {
           kind: "query",
@@ -215015,559 +216159,6 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         }) }
       }
     };
-    var NativeCropRefSchema = zod.z.object({
-      /** Handle keying the retained native surface (node-pinned to its owner). */
-      handle: require_sleep.FrameHandleSchema,
-      /** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
-      cropFrameSpace: zod.z.object({
-        x: zod.z.number(),
-        y: zod.z.number(),
-        w: zod.z.number(),
-        h: zod.z.number()
-      })
-    });
-    zod.z.object({
-      crop: zod.z.object({
-        left: zod.z.number(),
-        top: zod.z.number(),
-        width: zod.z.number().positive(),
-        height: zod.z.number().positive()
-      }).optional(),
-      content: zod.z.object({
-        width: zod.z.number().int().positive(),
-        height: zod.z.number().int().positive()
-      }),
-      fit: zod.z.enum(["stretch", "contain"]),
-      format: zod.z.enum([
-        "rgb",
-        "gray",
-        "jpeg"
-      ])
-    });
-    var FrameRefSchema = zod.z.object({
-      registryId: zod.z.string().min(1),
-      id: zod.z.string().min(1),
-      width: zod.z.number().int().positive(),
-      height: zod.z.number().int().positive(),
-      format: zod.z.enum(["rgb", "gray"]),
-      timestamp: zod.z.number(),
-      capturedAt: zod.z.number().optional()
-    });
-    var ModelFormatSchema$1 = zod.z.enum([
-      "onnx",
-      "coreml",
-      "openvino",
-      "tflite",
-      "pt",
-      "gguf"
-    ]);
-    var PipelineSlotSchema = zod.z.enum([
-      "detector",
-      "cropper",
-      "classifier",
-      "refiner",
-      "audio-classifier"
-    ]);
-    var PipelineEngineChoiceSchema = zod.z.object({
-      runtime: zod.z.enum(["node", "python"]),
-      backend: zod.z.string(),
-      format: ModelFormatSchema$1,
-      device: zod.z.string().optional()
-    });
-    var EngineDeviceInfoSchema = zod.z.object({
-      id: zod.z.string(),
-      label: zod.z.string(),
-      description: zod.z.string().optional()
-    });
-    var AvailableEngineSchema = zod.z.object({
-      engine: PipelineEngineChoiceSchema,
-      devices: zod.z.array(EngineDeviceInfoSchema).readonly(),
-      defaultDevice: zod.z.string()
-    });
-    var PipelineDefaultStepSchema = zod.z.lazy(() => zod.z.object({
-      addonId: zod.z.string(),
-      addonName: zod.z.string(),
-      slot: PipelineSlotSchema,
-      inputClasses: zod.z.array(zod.z.string()).readonly(),
-      outputClasses: zod.z.array(zod.z.string()).readonly(),
-      enabled: zod.z.boolean(),
-      modelId: zod.z.string(),
-      children: zod.z.array(PipelineDefaultStepSchema).readonly(),
-      group: zod.z.string().optional(),
-      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-    }));
-    var PipelineTemplateStepSchema = zod.z.lazy(() => zod.z.object({
-      addonId: zod.z.string(),
-      enabled: zod.z.boolean(),
-      modelId: zod.z.string(),
-      children: zod.z.array(PipelineTemplateStepSchema).readonly(),
-      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-    }));
-    var PipelineTemplateSchema$1 = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      createdAt: zod.z.string(),
-      updatedAt: zod.z.string(),
-      engine: PipelineEngineChoiceSchema,
-      steps: zod.z.array(PipelineTemplateStepSchema).readonly()
-    });
-    var PipelineModelOptionSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      formats: zod.z.record(zod.z.string(), zod.z.object({
-        downloaded: zod.z.boolean(),
-        sizeMB: zod.z.number()
-      })),
-      group: ModelVariantGroupSchema.optional(),
-      legacy: zod.z.boolean().optional(),
-      provider: ModelProviderIdSchema.optional()
-    });
-    var ConfigFieldBridge = zod.z.custom();
-    var PipelineAddonSchemaSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      slot: PipelineSlotSchema,
-      inputClasses: zod.z.array(zod.z.string()).readonly(),
-      outputClasses: zod.z.array(zod.z.string()).readonly(),
-      childSlots: zod.z.array(PipelineSlotSchema).readonly(),
-      models: zod.z.array(PipelineModelOptionSchema).readonly(),
-      defaultModelId: zod.z.string(),
-      defaultModelIdByFormat: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-      enabledByDefault: zod.z.boolean().optional(),
-      backfillIntoExistingOverrides: zod.z.boolean().optional(),
-      defaultConfidence: zod.z.number(),
-      group: zod.z.string().optional(),
-      configSchema: zod.z.array(ConfigFieldBridge).readonly().optional()
-    });
-    var PipelineSlotSchemaSchema = zod.z.object({
-      id: PipelineSlotSchema,
-      label: zod.z.string(),
-      priority: zod.z.number(),
-      parentSlot: PipelineSlotSchema.nullable(),
-      addons: zod.z.array(PipelineAddonSchemaSchema).readonly()
-    });
-    var PipelineSchemaSchema = zod.z.object({
-      availableEngines: zod.z.array(AvailableEngineSchema).readonly(),
-      selectedEngine: PipelineEngineChoiceSchema,
-      slots: zod.z.array(PipelineSlotSchemaSchema).readonly()
-    });
-    var EngineProvisioningSchema = zod.z.object({
-      runtimeId: zod.z.enum([
-        "onnx",
-        "openvino",
-        "coreml",
-        "edgetpu"
-      ]).nullable(),
-      device: zod.z.string().nullable(),
-      state: zod.z.enum([
-        "idle",
-        "installing",
-        "verifying",
-        "ready",
-        "failed"
-      ]),
-      progress: zod.z.number().optional(),
-      error: zod.z.string().optional(),
-      nextRetryAt: zod.z.number().optional(),
-      /**
-      * Gate A (config-correctness gate at engine change): human-readable
-      * config issues surfaced EAGERLY when the node's engine changes — model
-      * substitutions ("chose X, running Y") and zero-build steps ("no model
-      * has a <format> build"). Additive/optional: informational only, never
-      * enforced here — `assertEngineReady` (readiness) still gates inference.
-      * Absent/empty when the node-default tree resolves cleanly.
-      */
-      configIssues: zod.z.array(zod.z.string()).optional()
-    });
-    var PipelineStepInputSchema = zod.z.lazy(() => zod.z.object({
-      addonId: zod.z.string(),
-      modelId: zod.z.string().optional(),
-      enabled: zod.z.boolean().default(true),
-      children: zod.z.array(PipelineStepInputSchema).optional(),
-      settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-      jumpDeviceKey: zod.z.string().optional()
-    }));
-    var ModelSubstitutionSchema = zod.z.object({
-      addonId: zod.z.string(),
-      chosen: zod.z.string(),
-      running: zod.z.string(),
-      format: zod.z.string()
-    });
-    var PipelineValidationIssueSchema = zod.z.object({
-      addonId: zod.z.string(),
-      kind: zod.z.enum(["unknown-addon", "no-format-build"]),
-      detail: zod.z.string()
-    });
-    var PipelineValidationResultSchema = zod.z.object({
-      ok: zod.z.boolean(),
-      issues: zod.z.array(PipelineValidationIssueSchema).readonly(),
-      substitutions: zod.z.array(ModelSubstitutionSchema).readonly(),
-      /** The node's `currentEngine.format` this validation ran against. */
-      format: zod.z.string()
-    });
-    var ReferenceImageEntrySchema = zod.z.object({
-      filename: zod.z.string(),
-      stepIds: zod.z.array(zod.z.string()).readonly().optional()
-    });
-    var ReferenceImageBodySchema = zod.z.object({
-      base64: zod.z.string(),
-      filename: zod.z.string()
-    });
-    var ReferenceAudioEntrySchema = zod.z.object({
-      filename: zod.z.string(),
-      sizeKb: zod.z.number()
-    });
-    var ReferenceAudioBodySchema = zod.z.object({ base64: zod.z.string() });
-    var AudioBackendSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      description: zod.z.string(),
-      available: zod.z.boolean(),
-      /**
-      * Raw classifier labels this backend can emit (e.g. YAMNet's
-      * 521-class set or Apple SoundAnalysis's 303-class set). Used by
-      * the benchmark UI to populate the `enabledMicroClasses` filter
-      * specific to the selected backend without a separate fetch.
-      */
-      rawLabels: zod.z.array(zod.z.string()).readonly().optional()
-    });
-    var AudioCapabilitiesSchema = zod.z.object({
-      activeBackend: zod.z.string(),
-      availableBackends: zod.z.array(AudioBackendSchema).readonly(),
-      sampleRate: zod.z.number(),
-      chunkDurationMs: zod.z.number()
-    });
-    var DownloadModelResultSchema = zod.z.object({
-      filePath: zod.z.string(),
-      sizeMB: zod.z.number(),
-      durationMs: zod.z.number()
-    });
-    var AudioTestResultSchema = zod.z.object({
-      success: zod.z.boolean(),
-      error: zod.z.string().optional(),
-      frame: zod.z.custom().optional()
-    });
-    var PipelineConfigBridge = zod.z.custom();
-    var ConfigUISchemaBridge = zod.z.custom();
-    var ConfigUISchemaNullableBridge = zod.z.custom();
-    var InferenceCapabilitiesBridge = zod.z.custom();
-    var ModelAvailabilityListBridge = zod.z.custom();
-    var PipelineRunResultBridge = zod.z.custom();
-    var pipelineExecutorCapability = {
-      name: "pipeline-executor",
-      scope: "system",
-      mode: "singleton",
-      methods: {
-        getAvailableEngines: require_sleep.method(zod.z.void(), zod.z.array(PipelineEngineChoiceSchema)),
-        getSelectedEngine: require_sleep.method(zod.z.void(), PipelineEngineChoiceSchema),
-        getDefaultSteps: require_sleep.method(PipelineEngineChoiceSchema, zod.z.array(PipelineDefaultStepSchema)),
-        /**
-        * Per-node detection-engine provisioning snapshot. Returns the live
-        * state of the lazy runtime-provisioning machine on `nodeId`
-        * (idle / installing / verifying / ready / failed). The UI pairs this
-        * one-shot query with the `pipeline.engine-provisioning` live event
-        * (emitted on every transition) to drive a per-node "engine ready?"
-        * indicator without polling. Phase 2.
-        */
-        getEngineProvisioning: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), EngineProvisioningSchema),
-        getVideoPipelineSteps: require_sleep.method(zod.z.void(), zod.z.record(zod.z.string(), zod.z.object({
-          modelId: zod.z.string(),
-          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
-        }))),
-        setVideoPipelineSteps: require_sleep.method(zod.z.object({ steps: zod.z.record(zod.z.string(), zod.z.object({
-          modelId: zod.z.string(),
-          settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
-        })) }), zod.z.object({ success: zod.z.literal(true) }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        /**
-        * Clear THIS node's executor-side PER-DEVICE settings stores (the
-        * per-camera step overrides the object-detection root reads via
-        * `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
-        * generated cap-router strips it (default `nodeIdMode: 'routing'`) and
-        * dispatches to that node, so the provider method runs ON the target
-        * node and receives no `nodeId`.
-        *
-        * This is the slimmed executor leg of the orchestrator's
-        * `resetNodePipelineDefaults` flow (which owns the real reset: node
-        * addonDefaults pins + per-camera orchestrator overrides). The legacy
-        * `resetToDefault` — which reset a persisted global step-tree seed
-        * nothing in the live per-camera path read — was removed together with
-        * that seed.
-        */
-        clearDeviceOverrides: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({
-          success: zod.z.literal(true),
-          clearedDevices: zod.z.number()
-        }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        getSchema: require_sleep.method(zod.z.void(), PipelineSchemaSchema),
-        getGlobalSteps: require_sleep.method(zod.z.void(), zod.z.array(PipelineDefaultStepSchema).readonly().nullable()),
-        getGlobalPipelineConfig: require_sleep.method(zod.z.void(), PipelineConfigBridge),
-        getOrchestratorConfigSchema: require_sleep.method(zod.z.void(), ConfigUISchemaBridge),
-        /**
-        * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
-        * node's `currentEngine.format` — resolves `steps` the same way the
-        * runtime dispatch path would, and reports what WOULD happen without
-        * touching any node-global state. Called by the orchestrator at attach
-        * time (`attachOn`), node-pinned to the TARGET node, so config problems
-        * surface BEFORE `pipelineRunner.attachCamera` rather than at the first
-        * per-frame resolve. `ok` is false iff `issues` is non-empty (both
-        * `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
-        * is informational (a degraded-but-loadable model swap) and never
-        * affects `ok`. Never throws.
-        */
-        validatePipeline: require_sleep.method(zod.z.object({ steps: zod.z.array(PipelineStepInputSchema) }), PipelineValidationResultSchema),
-        listTemplates: require_sleep.method(zod.z.void(), zod.z.array(PipelineTemplateSchema$1).readonly()),
-        saveTemplate: require_sleep.method(zod.z.object({
-          name: zod.z.string(),
-          steps: zod.z.array(PipelineTemplateStepSchema).readonly(),
-          engine: PipelineEngineChoiceSchema
-        }), PipelineTemplateSchema$1, { kind: "mutation" }),
-        updateTemplate: require_sleep.method(zod.z.object({
-          id: zod.z.string(),
-          name: zod.z.string().optional(),
-          steps: zod.z.array(PipelineTemplateStepSchema).readonly().optional()
-        }), PipelineTemplateSchema$1, { kind: "mutation" }),
-        deleteTemplate: require_sleep.method(zod.z.object({ id: zod.z.string() }), zod.z.void(), { kind: "mutation" }),
-        getCapabilities: require_sleep.method(zod.z.void(), InferenceCapabilitiesBridge),
-        getAddonModels: require_sleep.method(zod.z.object({ addonId: zod.z.string() }), ModelAvailabilityListBridge),
-        downloadModel: require_sleep.method(zod.z.object({
-          addonId: zod.z.string(),
-          modelId: zod.z.string(),
-          format: ModelFormatSchema$1
-        }), DownloadModelResultSchema, { kind: "mutation" }),
-        deleteModel: require_sleep.method(zod.z.object({
-          addonId: zod.z.string(),
-          modelId: zod.z.string(),
-          format: ModelFormatSchema$1
-        }), zod.z.object({ success: zod.z.literal(true) }), { kind: "mutation" }),
-        /**
-        * Stateless single-frame execution. Callers (runner, benchmark) pass
-        * the complete `engine` + `steps` tree; the executor holds no state
-        * about cameras or saved pipelines.
-        *
-        * `engine` is optional during the migration window to preserve the
-        * legacy call shape used by existing benchmark code; once all
-        * callers pass it explicitly we make it required.
-        *
-        * Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
-        * `referenceImage` must be provided:
-        *  - `frame`: runtime dispatch path (runner → decoded broker frame).
-        *    Carries the raw buffer, dimensions, and format; the executor
-        *    uses it directly without base64 round-tripping.
-        *  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
-        *    decoded frame. Both runner and executor are hub-local processes
-        *    sharing `/dev/shm`, so the executor maps the named segment and
-        *    reads the pixels back zero-copy — eliminating the ~1.2MB
-        *    re-serialisation over UDS/MsgPack the `frame` path pays per call.
-        *    High-risk: the FrameRing is a latest-wins seqlock with no
-        *    refcount, so a recycled slot yields a null read; the executor
-        *    then degrades to an empty result and the runner ships pixels via
-        *    `frame` as the fallback (queue-depth gated on the runner side).
-        *  - `imageBase64`: one-shot test path (benchmark ImageTab).
-        *  - `referenceImage`: named file from the reference-image store.
-        */
-        runPipeline: require_sleep.method(zod.z.object({
-          engine: PipelineEngineChoiceSchema.optional(),
-          steps: zod.z.array(PipelineStepInputSchema).min(1),
-          frame: FrameInputSchema.optional(),
-          /**
-          * Process-local lazy frame. Valid only when caller and provider resolve
-          * in the same execution-group process; split/cross-node callers use
-          * `frame`/`image` inline compatibility instead.
-          */
-          frameRef: FrameRefSchema.optional(),
-          /**
-          * CB5 shm passthrough — a `FrameHandle` naming the same ring slot
-          * the decoded pixels live in. One more member of the one-of
-          * frame/frameHandle/image/imageBase64/referenceImage group.
-          */
-          frameHandle: require_sleep.FrameHandleSchema.optional(),
-          imageBase64: zod.z.string().optional(),
-          /**
-          * Binary JPEG bytes — preferred over `imageBase64` on internal
-          * hops (hub → forked worker via Moleculer MsgPack) because it
-          * skips the 33% base64 overhead + the per-call base64 decode on
-          * the detection-pipeline worker. Callers can pass either; exactly
-          * one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
-          */
-          image: zod.z.instanceof(Uint8Array).optional(),
-          referenceImage: zod.z.string().optional(),
-          deviceId: zod.z.number().optional(),
-          sessionId: zod.z.string().optional(),
-          /**
-          * Execution plane. 'full' (default) runs the whole tree — benchmark,
-          * reference-image, and detail-subtree calls. 'frame' is the live
-          * per-frame dispatch: ONLY root-plane steps run; crop children
-          * (inputClasses ≠ null) are skipped and served per-track via
-          * pipelineRunner.runDetailSubtree (two-plane design).
-          */
-          plane: zod.z.enum(["full", "frame"]).optional(),
-          /**
-          * Inference-device selector (Phase 2 multi-device). Format
-          * `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
-          * Omitted ⇒ the runner's default device (current single-engine
-          * behaviour). Selects WHICH device pool of the node runs the call.
-          */
-          deviceKey: zod.z.string().optional(),
-          /**
-          * Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
-          * when the parent crop was resolved from the frame's retained NATIVE
-          * surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
-          * child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
-          * resolution from that surface — the SAME quality path faces already
-          * had — instead of the downscaled parent tile. `handle` keys the native
-          * surface (node-pinned to its owner); `cropFrameSpace` is the parent
-          * crop's padded/clamped rectangle in FRAME-space pixels, used to compose
-          * the executor's crop-normalized child ROI back into frame-normalized
-          * coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
-          * of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
-          * (today's behaviour on the fallback path).
-          */
-          nativeCropRef: NativeCropRefSchema.optional()
-        }), PipelineRunResultBridge, { kind: "mutation" }),
-        /**
-        * Batched run — N raw frames packed into one cap call. The provider
-        * routes the batch through `SharedInferencePool.inferBatch`
-        * (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
-        * envelope cost is amortised N:1 vs N concurrent `runPipeline`
-        * calls. Single root step + uniform model assumed; trees with crop
-        * children fall back to sequential execution.
-        *
-        * Used by `scripts/bench-batch-style.mts` for batch benchmarking —
-        * N frames in one call to amortise per-call IPC overhead.
-        */
-        runPipelineBatch: require_sleep.method(zod.z.object({
-          engine: PipelineEngineChoiceSchema.optional(),
-          steps: zod.z.array(PipelineStepInputSchema).min(1),
-          frames: zod.z.array(FrameInputSchema).min(1).max(255),
-          deviceId: zod.z.number().optional(),
-          sessionId: zod.z.string().optional(),
-          /**
-          * Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
-          * the batch to the Python pool's bench preprocess cache
-          * (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
-          * preprocessed ONCE and every later inference is a pure-inference cache
-          * hit — the sustained-throughput run measures inference, not
-          * decode+preprocess+infer. Omitted/0 for live frames (all different →
-          * full preprocess every call, correct). Fresh per sustained run;
-          * released via `uncacheFrame`.
-          */
-          frameId: zod.z.number().int().nonnegative().optional(),
-          /** Inference-device selector (Phase 2 multi-device); see runPipeline. */
-          deviceKey: zod.z.string().optional()
-        }), zod.z.object({ results: zod.z.array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
-        /**
-        * Cache a raw frame inside the Python inference pool's memory.
-        * Returns a numeric `frameId` that `inferCached` references —
-        * subsequent calls send only 5 bytes through the pipe instead of
-        * 1.2MB raw data, eliminating the pipe transfer bottleneck.
-        */
-        cacheFrameInPool: require_sleep.method(zod.z.object({
-          data: zod.z.instanceof(Uint8Array),
-          width: zod.z.number().int().positive(),
-          height: zod.z.number().int().positive(),
-          format: zod.z.enum([
-            "rgb",
-            "bgr",
-            "gray"
-          ])
-        }), zod.z.object({
-          frameId: zod.z.number(),
-          width: zod.z.number(),
-          height: zod.z.number()
-        }), { kind: "mutation" }),
-        /**
-        * Run inference on a previously cached frame. Sends only 5 bytes
-        * (model_idx + frameId) through the IPC pipe — eliminates the
-        * ~35ms per-call overhead of transferring 1.2MB raw data.
-        */
-        inferCached: require_sleep.method(zod.z.object({
-          stepId: zod.z.string(),
-          frameId: zod.z.number().int()
-        }), zod.z.record(zod.z.string(), zod.z.unknown()), { kind: "mutation" }),
-        /**
-        * Release a cached frame from the Python pool's memory.
-        */
-        uncacheFrame: require_sleep.method(zod.z.object({ frameId: zod.z.number().int() }), zod.z.void(), { kind: "mutation" }),
-        /** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
-        getEffectiveTuning: require_sleep.method(zod.z.void(), zod.z.object({
-          batchMode: zod.z.string(),
-          windowMs: zod.z.number(),
-          maxBatchSize: zod.z.number(),
-          concurrency: zod.z.number()
-        })),
-        /**
-        * List every EngineFactory currently loaded in this executor's RAM,
-        * with the models resident and a coarse "in use" marker derived from
-        * ongoing inference activity. Used by the Pipeline page Engines tab.
-        */
-        listLoadedEngines: require_sleep.method(zod.z.void(), zod.z.array(zod.z.object({
-          engineKey: zod.z.string(),
-          engine: PipelineEngineChoiceSchema,
-          modelsLoaded: zod.z.array(zod.z.string()).readonly(),
-          inUseByCameras: zod.z.array(zod.z.number()).readonly(),
-          /**
-          * Origin of this resident factory.
-          *  - `runtime`       — main camera-serving engine (no idle TTL).
-          *  - `warm-override` — benchmark/test override held in the warm
-          *                      cache; auto-disposed after the idle TTL.
-          *  - `device-pool`   — a concurrent per-device pool (Phase 2
-          *                      multi-device, keyed by `deviceKey`) resolved
-          *                      via `resolveDeviceFactory`. Runs alongside the
-          *                      `runtime` engine on a DIFFERENT accelerator
-          *                      (NPU / iGPU / Coral) — this is how the
-          *                      Engines tab shows all pools running at once.
-          */
-          kind: zod.z.enum([
-            "runtime",
-            "warm-override",
-            "device-pool"
-          ]),
-          /** Native pid of the underlying Python pool (null when no pool). */
-          poolPid: zod.z.number().nullable(),
-          /** ms since this factory was last used (null when not warm-tracked). */
-          idleMs: zod.z.number().nullable(),
-          /** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
-          idleTtlMs: zod.z.number().nullable()
-        })).readonly()),
-        /** Warm up an engine without running a frame. No-op if already loaded. */
-        spinEngine: require_sleep.method(zod.z.object({ engine: PipelineEngineChoiceSchema }), zod.z.object({ success: zod.z.literal(true) }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        /**
-        * Unload an engine from RAM. `force:true` unloads even when cameras
-        * are actively using it (they re-spin on next frame). Default is
-        * gated — returns `{success:false, reason}` when in use.
-        */
-        killEngine: require_sleep.method(zod.z.object({
-          engine: PipelineEngineChoiceSchema,
-          force: zod.z.boolean().optional()
-        }), zod.z.object({
-          success: zod.z.boolean(),
-          reason: zod.z.string().optional()
-        }), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        listReferenceImages: require_sleep.method(zod.z.void(), zod.z.array(ReferenceImageEntrySchema).readonly()),
-        getReferenceImage: require_sleep.method(zod.z.object({ filename: zod.z.string() }), ReferenceImageBodySchema.nullable()),
-        getReferenceAudioFiles: require_sleep.method(zod.z.void(), zod.z.array(ReferenceAudioEntrySchema).readonly()),
-        getReferenceAudio: require_sleep.method(zod.z.object({ filename: zod.z.string() }), ReferenceAudioBodySchema.nullable()),
-        getAudioCapabilities: require_sleep.method(zod.z.void(), AudioCapabilitiesSchema),
-        runAudioTest: require_sleep.method(zod.z.object({
-          addonId: zod.z.string(),
-          modelId: zod.z.string(),
-          filename: zod.z.string().optional(),
-          settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-        }), AudioTestResultSchema, { kind: "mutation" }),
-        getDetectionConfigSchema: require_sleep.method(zod.z.void(), ConfigUISchemaNullableBridge)
-      }
-    };
     var OrchestratorMetricsSchema = zod.z.object({
       activeCameras: zod.z.number(),
       throttledCameras: zod.z.number(),
@@ -215592,66 +216183,6 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       ])
     });
     var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: zod.z.number() });
-    var ZoneKindEnum = zod.z.enum(["polygon", "tripwire"]);
-    var PolygonPointSchema = zod.z.object({
-      x: zod.z.number(),
-      y: zod.z.number()
-    });
-    var ZoneSchema = zod.z.object({
-      id: zod.z.string(),
-      name: zod.z.string(),
-      kind: ZoneKindEnum.default("polygon"),
-      /** Polygon vertices, fraction of frame (0–1). */
-      polygon: zod.z.array(PolygonPointSchema).readonly(),
-      /** Visual color for UI rendering. */
-      color: zod.z.string().default("#3b82f6")
-    });
-    var zonesCapability = {
-      name: "zones",
-      scope: "device",
-      mode: "singleton",
-      deviceTypes: [require_sleep.DeviceType.Camera],
-      methods: {
-        listZones: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.array(ZoneSchema).readonly()),
-        addZone: require_sleep.method(zod.z.object({
-          deviceId: zod.z.number(),
-          zone: ZoneSchema
-        }), zod.z.void(), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        removeZone: require_sleep.method(zod.z.object({
-          deviceId: zod.z.number(),
-          zoneId: zod.z.string()
-        }), zod.z.void(), {
-          kind: "mutation",
-          auth: "admin"
-        }),
-        updateZone: require_sleep.method(zod.z.object({
-          deviceId: zod.z.number(),
-          zone: ZoneSchema
-        }), zod.z.void(), {
-          kind: "mutation",
-          auth: "admin"
-        })
-      },
-      /**
-      * Runtime-state slice — the live zone catalogue mirrored by the
-      * orchestrator on every CRUD mutation. Consumers read via
-      * `device.state.zones.value` / `.watch(...)` without round-tripping
-      * the cap, and the codegen DeviceProxy auto-wires the reactive
-      * handle. Slice shape is `{ zones: Zone[] }` so future extensions
-      * (e.g. zone groupings) can sit alongside the polygon list.
-      */
-      runtimeState: zod.z.object({ zones: zod.z.array(ZoneSchema).readonly() }),
-      /**
-      * Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
-      *
-      * See `RuntimeStateDurability`. Enforced by
-      * `scripts/check-runtime-state-durability.ts`.
-      */
-      durability: "restored"
-    };
     var NativeCropBboxSchema = zod.z.object({
       x: zod.z.number(),
       y: zod.z.number(),
@@ -224617,6 +225148,23 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       /** Media ms the returned fragment covers. */
       gopDurMs: zod.z.number()
     });
+    var ReadWindowBytesResultSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+      kind: zod.z.literal("ok"),
+      data: zod.z.instanceof(Uint8Array),
+      /** Absolute epoch ms of the returned bytes' first sample — at or before
+      *  the requested `fromMs` (anchored on the nearest keyframe). */
+      gopStartMs: zod.z.number(),
+      /** Media ms the returned bytes cover, from `gopStartMs`. */
+      gopDurMs: zod.z.number(),
+      /** `false` ⇒ the safety byte cap cut the read short before it reached
+      *  the requested `toMs`; the caller got fewer frames than asked for. */
+      reachesRequestedEnd: zod.z.boolean()
+    }), zod.z.object({
+      kind: zod.z.literal("spans-multiple-segments"),
+      /** Where the covering segment's own footage runs out — informational,
+      *  not a retry hint (retrying the same window would refuse again). */
+      segmentEndMs: zod.z.number()
+    })]);
     var recordingCapability = {
       name: "recording",
       scope: "system",
@@ -224696,6 +225244,21 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
           kind: "query",
           auth: "admin"
         }),
+        /** Read a WINDOW `[fromMs, toMs)` of segment `startMs`, by mfra byte
+        *  range — the multi-GOP twin of `readGopBytes`. Refuses (does not
+        *  degrade) when the window runs past the covering segment. Used by the
+        *  replay clip's `recording` source to fetch several seconds of native
+        *  footage for its single ffmpeg decode pass. */
+        readWindowBytes: require_sleep.method(zod.z.object({
+          deviceId: zod.z.number(),
+          profile: zod.z.string(),
+          startMs: zod.z.number(),
+          fromMs: zod.z.number(),
+          toMs: zod.z.number()
+        }), ReadWindowBytesResultSchema, {
+          kind: "query",
+          auth: "admin"
+        }),
         setDeviceConfig: require_sleep.method(zod.z.object({
           deviceId: zod.z.number(),
           config: RecordingConfigSchema
@@ -225275,59 +225838,6 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       */
       durability: "session"
     };
-    var ZoneRuleModeEnum = zod.z.enum(["include", "exclude"]);
-    var ZoneRuleSchema = zod.z.object({
-      /** Stable rule id — survives edits, used by the UI for diffing. */
-      id: zod.z.string(),
-      /** Optional human-readable label rendered in the rule editor. */
-      name: zod.z.string().optional(),
-      /** Zones this rule targets. The rule's `mode` applies to ALL
-      *  listed zones (OR-set: a detection in any one of them counts).
-      *  At least one zone id required — a rule with no targets is a
-      *  configuration mistake and the form validator rejects it. */
-      zoneIds: zod.z.array(zod.z.string()).min(1).readonly(),
-      mode: ZoneRuleModeEnum,
-      /**
-      * Class names this rule applies to. Empty / undefined ⇒ rule
-      * applies to every class. Class strings match the `macroClass`
-      * field on detections (e.g. `person`, `car`, `dog`).
-      */
-      classFilter: zod.z.array(zod.z.string()).readonly().optional(),
-      /**
-      * Minimum bbox/mask overlap (0–1) with any of the rule's zones
-      * required to consider an entity "in the zone". Defaults to the
-      * consumer's stage default when omitted. Kept for back-compat with
-      * existing per-rule overrides; new operators pick the value via
-      * `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
-      * set, the lower-level engine reads it as a 0–1 fraction.
-      */
-      overlapThreshold: zod.z.number().min(0).max(1).optional(),
-      /**
-      * Operator-friendly version of `overlapThreshold` — the percentage
-      * of the detection's bbox that must lie inside the zone for the
-      * rule to match. Documented default is 85%; the engine substitutes
-      * that when the field is omitted (kept optional so existing rules
-      * stored without it stay valid).
-      *
-      * When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
-      * rule, the engine prefers `bboxInclusionPct` because it's the
-      * field exposed in the UI. Internally both feed the same gate.
-      */
-      bboxInclusionPct: zod.z.number().min(0).max(100).optional(),
-      /**
-      * When `true` and a detection has a segmentation mask, use the
-      * mask for overlap instead of the bbox. Detection-stage only;
-      * motion rules ignore this field.
-      */
-      preferMask: zod.z.boolean().optional(),
-      /**
-      * Soft-toggle: `false` disables the rule without deleting it.
-      * Defaults to `true` so operators creating a rule via the UI
-      * see it active immediately.
-      */
-      enabled: zod.z.boolean().default(true)
-    });
-    var ZoneRulesArraySchema = zod.z.array(ZoneRuleSchema).readonly();
     var ScriptRunnerStatusSchema = zod.z.object({
       /** Whether the script is currently executing. */
       isRunning: zod.z.boolean(),
@@ -233176,6 +233686,12 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         addonId: null,
         access: "view"
       },
+      "notificationRules.resolveArtifactUrl": {
+        capName: "notification-rules",
+        capScope: "system",
+        addonId: null,
+        access: "view"
+      },
       "notificationRules.setAlarmConfig": {
         capName: "notification-rules",
         capScope: "system",
@@ -233620,6 +234136,12 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         addonId: null,
         access: "create"
       },
+      "pipelineAnalytics.runReplayFrameProcessor": {
+        capName: "pipeline-analytics",
+        capScope: "device",
+        addonId: null,
+        access: "create"
+      },
       "pipelineAnalytics.saveRetrainAnnotations": {
         capName: "pipeline-analytics",
         capScope: "device",
@@ -233752,6 +234274,12 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         addonId: null,
         access: "view"
       },
+      "pipelineExecutor.getInferenceDeviceHealth": {
+        capName: "pipeline-executor",
+        capScope: "system",
+        addonId: null,
+        access: "view"
+      },
       "pipelineExecutor.getOrchestratorConfigSchema": {
         capName: "pipeline-executor",
         capScope: "system",
@@ -233824,6 +234352,12 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         addonId: null,
         access: "view"
       },
+      "pipelineExecutor.rearmInferenceDevice": {
+        capName: "pipeline-executor",
+        capScope: "system",
+        addonId: null,
+        access: "create"
+      },
       "pipelineExecutor.runAudioTest": {
         capName: "pipeline-executor",
         capScope: "system",
@@ -234562,6 +235096,12 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         addonId: null,
         access: "view"
       },
+      "recording.readWindowBytes": {
+        capName: "recording",
+        capScope: "system",
+        addonId: null,
+        access: "view"
+      },
       "recording.refreshStorageLocationsForMigration": {
         capName: "recording",
         capScope: "system",
@@ -237324,6 +237864,11 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         form: "single",
         optional: false
       }],
+      "pipelineAnalytics.runReplayFrameProcessor": [{
+        name: "deviceId",
+        form: "single",
+        optional: false
+      }],
       "pipelineAnalytics.saveRetrainAnnotations": [{
         name: "deviceId",
         form: "single",
@@ -237639,6 +238184,11 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
         form: "single",
         optional: false
       }],
+      "recording.readWindowBytes": [{
+        name: "deviceId",
+        form: "single",
+        optional: false
+      }],
       "recording.relocateFootage": [{
         name: "deviceId",
         form: "single",
@@ -238115,6 +238665,7 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       "recording.pruneFootage",
       "recording.readGopBytes",
       "recording.readSegmentBytes",
+      "recording.readWindowBytes",
       "recording.relocateFootage",
       "recording.renderClip",
       "recording.renderGif",
@@ -238900,6 +239451,8 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
           getVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "getVideoPipelineSteps", "query", input),
           setVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "setVideoPipelineSteps", "mutation", input),
           clearDeviceOverrides: (input) => dispatch("pipelineExecutor", "clearDeviceOverrides", "mutation", input),
+          getInferenceDeviceHealth: (input) => dispatch("pipelineExecutor", "getInferenceDeviceHealth", "query", input),
+          rearmInferenceDevice: (input) => dispatch("pipelineExecutor", "rearmInferenceDevice", "mutation", input),
           getSchema: (input) => dispatch("pipelineExecutor", "getSchema", "query", input),
           getGlobalSteps: (input) => dispatch("pipelineExecutor", "getGlobalSteps", "query", input),
           getGlobalPipelineConfig: (input) => dispatch("pipelineExecutor", "getGlobalPipelineConfig", "query", input),
@@ -242434,6 +242987,7 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
     exports.RawStateResultSchema = require_sleep.RawStateResultSchema;
     exports.ReadGopBytesResultSchema = ReadGopBytesResultSchema;
     exports.ReadSegmentBytesResultSchema = ReadSegmentBytesResultSchema;
+    exports.ReadWindowBytesResultSchema = ReadWindowBytesResultSchema;
     exports.ReadinessRegistry = require_sleep.ReadinessRegistry;
     exports.ReadinessTimeoutError = require_sleep.ReadinessTimeoutError;
     exports.RecentTracksPageSchema = RecentTracksPageSchema;