CMK Pipe Peek Detailer

The whole point of a detail pass is that it's a masked img2img loop: detect or paint a region, crop it, re-render the crop at a resolution the model can actually resolve, paste it back. Every pack that does this wraps it slightly differently, and the wrappers don't talk to each other.

CMK Pipe Peek Detailer is a translator. It takes CMK's CMK_DETAILER_PIPE - the bundle that CMK Pipe Create Detailer built - and unpacks it into shapes the wider ecosystem understands.

The nine outputs

• basic_pipe (BASIC_PIPE) - a five-tuple of (model, clip, vae, conditioning_pos, conditioning_neg).
• image (IMAGE)
• seed (INT)
• steps (INT)
• cfg (FLOAT)
• sampler - the core sampler enum.
• scheduler - the core scheduler enum.
• boolean_detailer_enable (BOOLEAN)
• sam_model (SAM_MODEL) - keeps its type; may be None.

That BASIC_PIPE output is the interesting one. BASIC_PIPE isn't a CMK type - it's Impact Pack's, the tuple that DetailerForEach, FaceDetailer and friends accept as their "here's the model stack" input. So this node is the seam where CMK's proprietary pipe turns back into the lingua franca.

Which means you can: build a pipe with CMK's nodes, run a CMK detailer module, then hand the same pipe to somebody else's detailer node and compare. Or use CMK's loader, prompt handling and image prep while letting an Impact Pack consumer do the loop.

The internal mapping

The tuple is assembled from the prefixed keys you saw go in: detailer_model, detailer_clip, detailer_vae, detailer_conditioning_pos, detailer_conditioning_neg. The scalars come from detailer_seed, detailer_steps, detailer_cfg, detailer_sampler, detailer_scheduler. The boolean reads boolean_detailer_enable with a False default, and the SAM model reads detailer_sam_model.

Note the boolean's name in the pipe is boolean_detailer_enable while the widget on the Create node is detailer_enable. If you're tracing values through a workflow and the names don't match, that's why - the pack treats visible titles and technical identities as two separate things on purpose.

One thing this node does not do: validate. There's no contract check, no required-key check. Feed it a dict that isn't a detailer pipe and you get a tuple of Nones. Compare that with CMK Pipe Peek Preprocess Detailer, which does validate and raises a named error listing what's missing. The Peek family is not internally consistent about this, and it's worth knowing which one scolds you.

The Impact Pack thing people get wrong

Here's the confusion this node sits in the middle of. SEGS is Impact Pack's container type. CMK speaks SEGS. So people assume CMK wraps Impact Pack, or needs it installed, or is a fork of it.

None of that is true. The README states flatly that CMK's core nodes for detection, SEGS, detailer, pasteback, FaceProcess restore and SAM loading need no foreign custom-node packages, and you can see it in the source: the pack ships its own SEGSDetailer and SEGSPaste under engine/native_detailer.py. The compatibility here is at the data shape level, via BASIC_PIPE and SEGS semantics, not at the dependency level.

Which is a good design, honestly. Agreeing on a container format is cheap; inheriting another pack's install graph is not.

Install

Part of CMKFlow/cmk_nodes. ComfyUI Manager → search CMK Flow → install the CMKFlow entry → restart ComfyUI. Manual, ComfyUI closed:

git clone https://github.com/CMKFlow/cmk_nodes.git custom_nodes/cmk_nodes
python3 custom_nodes/cmk_nodes/scripts/install_cmk_requirements.py

CMK dependency check: OK and you're done. If you're feeding the BASIC_PIPE into an Impact Pack node, that's a separate install - and if you're pinning ultralytics, pin it deliberately. The December 2024 poisoned Ultralytics release shipped a cryptominer, and the detailing node packs were the route it took to reach ComfyUI users.

When to reach for it

You want to compare detailer implementations. Same pipe, two loops, one honest before/after.

You're on a mixed stack. CMK's front half, somebody else's consumer.

You're debugging. Nine outputs that show you exactly what the pipe carries is a fast way to find out that your sam_model was always None and the SAM path never ran.

If none of those apply, you probably don't need this node - inside a pure CMK flow the modules wire pipe-to-pipe and you never see the unpacking.