Workflow1111 — Automatic1111-style diffusion studio on gr.Workflow

README.md

@@ -80,12 +80,12 @@ install too.
 
 ```
 14 references  →  32 operators  →  18 subjects        73 edges
-                  ├─ 26 fn      19 pure-local · 7 calling InferenceClient
-                  ├─  4 model   HF Inference Providers
+                  ├─ 28 fn      19 pure-local · 9 calling InferenceClient
+                  ├─  2 model   HF Inference Providers
                   └─  2 space   Gradio Spaces on the Hub
 ```
 
-19 of the 26 `fn` nodes are pure local Pillow/numpy — all the prompt logic,
+19 of the 28 `fn` nodes are pure local Pillow/numpy — all the prompt logic,
 post-processing, annotators, masking, grid composition and metadata parsing —
 so most of the app keeps working with no token, no quota and no network. 13
 nodes in total leave the machine.
@@ -95,7 +95,7 @@ nodes in total leave the machine.
 | File | What it is |
 |---|---|
 | `app.py` | Entry point — 12 lines of actual wiring |
-| `nodes.py` | The 19 bound functions (the `fn` node library) |
+| `nodes.py` | The 21 bound functions (the `fn` node library) |
 | `build_workflow.py` | **Generates + verifies** `workflow.json` |
 | `workflow.json` | The committed graph |
 | `test_nodes.py` | 53 offline unit tests (~2s) |
@@ -116,9 +116,9 @@ and no node is orphaned.
 
 ---
 
-## Five gotchas this app is built around
+## Six gotchas this app is built around
 
-All five were found by probing gradio 6.22.0 / huggingface_hub 1.26.0
+All six were found by probing gradio 6.22.0 / huggingface_hub 1.26.0
 directly, not from the docs. They are the difference between "renders on the
 canvas" and "actually runs".
 
@@ -139,8 +139,9 @@ replying "Hello! It seems like your message might be missing something").
 
 The fix is to stop using `model` nodes wherever the control surface is richer
 than the schema: `txt2img`, `chat_llm` and `interrogate` are `fn` nodes that
-call `InferenceClient` themselves. `fn` ports are never rewritten. The four
-remaining `model` nodes have ports exactly equal to their schema, and
+call `InferenceClient` themselves. `fn` ports are never rewritten. The two
+remaining `model` nodes (`image_to_image`) have ports exactly equal to their
+schema, and
 `build_workflow.py` now **refuses to build** if that ever stops being true.
 
 A useful side effect: an `fn` node can validate. `interrogate` requires its
@@ -203,6 +204,29 @@ So `_emit` returns **both**: `{"path": <temp file>, "url": <data: URI>}`.
 `_from_output` takes `path` first (endpoint happy), the frontend and `_img_url`
 take `url` first (canvas and providers happy).
 
+### 6. A `json` port silently destroys its value in the canvas
+
+The canvas serializes a `json`-typed port with JavaScript's `String(obj)`
+instead of `JSON.stringify`, so the receiving node gets the literal six-word
+string `"[object Object]"`. Everything downstream then sees *no data*, with no
+error anywhere:
+
+- DETR detections reached `draw_detections` as `"[object Object]"` → zero boxes
+  → an annotated image identical to the input, and
+  `mask_from_detections` failing with "No detections matched" at **every**
+  `min_score`.
+- ViT labels reached `top_labels` the same way → "No labels above the score
+  threshold".
+- `png_info`'s field dict reached its output node as `"[object Object]"`.
+
+Both the executor and the REST API handle `json` ports perfectly, so this is
+invisible to `test_pipelines.py` *and* `test_api.py` — only the canvas is
+affected. The graph therefore contains **no `json` ports at all**: structured
+data travels as JSON *text*, which survives, and `_as_list` parses it back.
+`detect_objects` and `classify_image` are `fn` nodes calling `InferenceClient`
+for the same reason a `model` node could not be used (their output port type is
+fixed by the endpoint schema — gotcha #1).
+
 Reference-node *defaults* are a separate case with the opposite answer: the
 canvas strips `path` out of a graph default and keeps only `url`, so the sample
 images are referenced by their **public Hub URL** — the one form that renders

build_workflow.py

@@ -393,16 +393,19 @@ fn("op_clean_interrogate", "clean_prompt", COL[2], Y, label="② Tidy up",
    data={"max_tags": 45},
    outputs=[("out_0", "prompt", "text")])
 
-model("op_classify", CLASSIFY_MODEL, "image_classification", "image-classification",
-      COL[1], Y + 260, label="③ Classify · ViT",
-      inputs=[("image", "image", "image", True)],
-      outputs=[("out_0", "Labels", "json")])
+# `fn`, not `model`: a `json` output port reaches the canvas as the literal
+# string "[object Object]" (JS String(obj) instead of JSON.stringify), so the
+# labels never survive the edge. Text ports carrying JSON do.
+fn("op_classify", "classify_image", COL[1], Y + 260, label="③ Classify · ViT",
+   types={"image": "image"}, required=("image",),
+   data={"model_id": CLASSIFY_MODEL},
+   outputs=[("out_0", "labels", "text")])
 
 fn("op_labels", "top_labels", COL[2], Y + 260, label="④ Rank labels",
-   types={"labels": "json", "top_k": "number", "min_score": "number"},
+   types={"labels": "text", "top_k": "number", "min_score": "number"},
    required=("labels",),
    data={"top_k": 5, "min_score": 0.01},
-   outputs=[("out_0", "table", "text"), ("out_1", "rows", "json")])
+   outputs=[("out_0", "table", "text"), ("out_1", "rows", "text")])
 
 out("sub_interrogated", "🔍 Recovered prompt", "text", COL[3], Y)
 out("sub_labels", "🏷 Classification", "text", COL[3], Y + 260)
@@ -410,7 +413,7 @@ out("sub_labels", "🏷 Classification", "text", COL[3], Y + 260)
 link("ref_interrogate_image.out", "op_vlm.in_image")
 link("op_vlm.out_0", "op_clean_interrogate.in_raw")
 link("op_clean_interrogate.out_0", "sub_interrogated.in")
-link("ref_interrogate_image.out", "op_classify.image")
+link("ref_interrogate_image.out", "op_classify.in_image")
 link("op_classify.out_0", "op_labels.in_labels")
 link("op_labels.out_0", "sub_labels.in")
 
@@ -420,20 +423,20 @@ link("op_labels.out_0", "sub_labels.in")
 Y = 2200
 ref("ref_detect_image", "Image to analyse", "image", COL[0], Y, sample("detect.jpg"))
 
-model("op_detect", DETECT_MODEL, "object_detection", "object-detection", COL[1], Y,
-      label="① Detect · DETR",
-      inputs=[("image", "image", "image", True)],
-      outputs=[("out_0", "Detections", "json")])
+fn("op_detect", "detect_objects", COL[1], Y, label="① Detect · DETR",
+   types={"image": "image", "min_score": "number"}, required=("image",),
+   data={"model_id": DETECT_MODEL, "min_score": 0.0},
+   outputs=[("out_0", "detections", "text")])
 
 fn("op_draw", "draw_detections", COL[2], Y, label="② Annotate",
-   types={"image": "image", "detections": "json", "min_score": "number",
+   types={"image": "image", "detections": "text", "min_score": "number",
           "show_labels": "boolean"},
    required=("image", "detections"),
    data={"min_score": 0.5, "show_labels": True},
    outputs=[("out_0", "image", "image"), ("out_1", "summary", "text")])
 
 fn("op_mask", "mask_from_detections", COL[2], Y + 300, label="③ Build inpaint mask",
-   types={"image": "image", "detections": "json", "min_score": "number",
+   types={"image": "image", "detections": "text", "min_score": "number",
           "feather": "number", "invert": "boolean", "preview": "boolean"},
    required=("image", "detections"),
    data={"label_filter": "", "min_score": 0.5, "feather": 8,
@@ -444,7 +447,7 @@ out("sub_detected", "📦 Detected objects", "image", COL[3], Y)
 out("sub_detect_summary", "📝 Detection summary", "text", COL[3], Y + 300)
 out("sub_mask", "🎭 Inpaint mask", "image", COL[4], Y + 300)
 
-link("ref_detect_image.out", "op_detect.image")
+link("ref_detect_image.out", "op_detect.in_image")
 link("ref_detect_image.out", "op_draw.in_image")
 link("op_detect.out_0", "op_draw.in_detections")
 link("ref_detect_image.out", "op_mask.in_image")
@@ -559,10 +562,10 @@ ref("ref_pnginfo_image", "PNG to inspect", "image", COL[0], Y,
 
 fn("op_pnginfo", "png_info", COL[1], Y, label="Read PNG metadata",
    types={"image": "image"}, required=("image",),
-   outputs=[("out_0", "report", "text"), ("out_1", "fields", "json")])
+   outputs=[("out_0", "report", "text"), ("out_1", "fields", "text")])
 
 out("sub_png_report", "🧾 PNG info", "text", COL[2], Y)
-out("sub_png_fields", "🧮 Parsed fields", "json", COL[3], Y)
+out("sub_png_fields", "🧮 Parsed fields", "text", COL[3], Y)
 
 link("ref_pnginfo_image.out", "op_pnginfo.in_image")
 link("op_pnginfo.out_0", "sub_png_report.in")

make_samples.py

@@ -99,7 +99,22 @@ def main():
                                  steps, cfg, seed, img.width, img.height,
                                  "black-forest-labs/FLUX.1-schnell")
         stamped = N.postprocess(N._emit(img), 1, "Lanczos", 0, 1, 1, 1, 0, 0, 0, "", info)
-        shutil.copyfile(stamped["path"], png)
+        # Quantize to a 256-colour palette before shipping. This sample has to
+        # stay PNG (a JPEG cannot carry the `parameters` text chunk), and a
+        # full-colour 768×512 photo PNG is ~471 KB — slow enough over the Hub
+        # (~4.8s) that the reference node looks broken while it loads. The
+        # palette version is ~161 KB and keeps the text chunk and the
+        # dimensions, so the embedded `Size:` still matches the image.
+        from PIL import PngImagePlugin
+        full = Image.open(stamped["path"])
+        full.load()
+        meta = PngImagePlugin.PngInfo()
+        for key, value in (full.info or {}).items():
+            if isinstance(value, str):
+                meta.add_text(key, value)
+        quantized = full.convert("RGB").quantize(
+            colors=256, method=Image.MEDIANCUT, dither=Image.FLOYDSTEINBERG)
+        quantized.save(png, format="PNG", optimize=True, pnginfo=meta)
         print(f"  made   with_parameters.png  {os.path.getsize(png)//1024} KB "
               "— PNG Info, with a real embedded parameter block")
     manifest["ref_pnginfo_image"] = "with_parameters.png"
@@ -116,7 +131,8 @@ def main():
     labels = sorted({d["label"] for d in det[0]} if isinstance(det[0], list) else set())
     print(f"  detect.jpg  → DETR finds: {labels or 'NOTHING (bad sample)'}")
 
-    report, fields = N.png_info(png)
+    report, fields_json = N.png_info(png)
+    fields = json.loads(fields_json)
     ok = fields.get("prompt", "").startswith("a red fox curled")
     print(f"  with_parameters.png → embedded params readable: {ok} "
           f"(seed={fields.get('seed')}, size={fields.get('size')})")

nodes.py

@@ -15,12 +15,15 @@ Two conventions matter, and both are load-bearing (see the module docstring in
    it can be a ``{"path"/"url"}`` dict, a ``data:`` URI, an ``http(s)`` URL, a
    ``/gradio_api/file=`` reference, or a plain path. `_load_image` normalizes
    all of them.
-2. **Image outputs are always ``data:`` URIs.** That is the one shape that both
-   renders in the canvas *and* chains correctly into a `model` node's
-   ``image_to_image`` port. Returning the ``{"path", "url"}`` dict that model
-   nodes emit would break the chain, because gradio's `_img_url()` prefers the
-   ``url`` key and a ``/gradio_api/file=`` path means nothing to a remote
-   provider.
+2. **Image outputs are ``{"path": <file>, "url": <data: URI>}``** — see `_emit`.
+   The REST endpoint needs the real file, the canvas and any chained `model`
+   node need the URI, so the value carries both.
+3. **Structured data travels as JSON *text*, never on a ``json`` port.** The
+   canvas stringifies a `json` port value with JavaScript's ``String(obj)``
+   rather than ``JSON.stringify``, so the receiving node gets the literal text
+   ``"[object Object]"`` and the data is gone. `detect_objects`,
+   `classify_image`, `top_labels` and `png_info` therefore emit JSON strings,
+   and `_as_list` parses them back.
 
 Everything returned must be JSON-serializable — that is the contract for
 `bind=` functions.
@@ -707,6 +710,74 @@ def interrogate(image, instruction, model_id, max_tokens,
                  max_tokens=_num(max_tokens, 512, lo=32, hi=4096, integer=True))
 
 
+def _image_file(image, label="image"):
+    """Materialize any accepted image value as a temp file path.
+
+    A **path**, not bytes: handing `InferenceClient` raw bytes makes the router
+    reject the call with "No content type provided and no default one
+    configured", whereas from a path huggingface_hub infers the MIME type.
+    """
+    img = _load_image(image, label)
+    path = os.path.join(tempfile.gettempdir(), f"wf1111_in_{os.urandom(8).hex()}.jpg")
+    _rgb(img).save(path, format="JPEG", quality=94, optimize=True)
+    return path
+
+
+def detect_objects(image, model_id, min_score, oauth_token: Optional[OAuthToken] = None):
+    """Object detection, returning the detections as a **JSON string**.
+
+    An `fn` node calling `InferenceClient` rather than a `model` node, because
+    the canvas destroys `json`-typed port values: it stringifies them with
+    JavaScript's `String(obj)` instead of `JSON.stringify`, so the downstream
+    node receives the literal text ``"[object Object]"`` and sees zero
+    detections. Text ports survive intact, so the detections travel as JSON
+    text and `_as_list` parses them back.
+    """
+    from huggingface_hub import InferenceClient
+
+    model = _text(model_id, "facebook/detr-resnet-50")
+    floor = _num(min_score, 0.0, lo=0.0, hi=1.0)
+    client = InferenceClient(model=model, token=_hf_token(oauth_token), provider="auto")
+    try:
+        results = client.object_detection(image=_image_file(image, "image to analyse"))
+    except Exception as e:
+        raise ValueError(f"{model} failed: {str(e)[:300]}") from e
+
+    found = []
+    for r in results:
+        box = getattr(r, "box", None) or {}
+        get = (lambda k: getattr(box, k, None)) if not isinstance(box, dict) else box.get
+        try:
+            coords = {k: int(get(k)) for k in ("xmin", "ymin", "xmax", "ymax")}
+        except (TypeError, ValueError):
+            continue
+        score = float(getattr(r, "score", 0.0) or 0.0)
+        if score < floor:
+            continue
+        found.append({"label": str(getattr(r, "label", "object")),
+                      "score": round(score, 4), "box": coords})
+    found.sort(key=lambda d: d["score"], reverse=True)
+    return json.dumps(found)
+
+
+def classify_image(image, model_id, oauth_token: Optional[OAuthToken] = None):
+    """Image classification, returning the labels as a **JSON string**
+    (same reason as `detect_objects`)."""
+    from huggingface_hub import InferenceClient
+
+    model = _text(model_id, "google/vit-base-patch16-224")
+    client = InferenceClient(model=model, token=_hf_token(oauth_token), provider="auto")
+    try:
+        results = client.image_classification(
+            image=_image_file(image, "image to classify"))
+    except Exception as e:
+        raise ValueError(f"{model} failed: {str(e)[:300]}") from e
+
+    return json.dumps([{"label": str(getattr(r, "label", "?")),
+                        "score": round(float(getattr(r, "score", 0.0) or 0.0), 5)}
+                       for r in results])
+
+
 def top_labels(labels, top_k, min_score):
     """Format an image-classification payload. Returns (text, json)."""
     items = _as_list(labels)
@@ -725,13 +796,15 @@ def top_labels(labels, top_k, min_score):
     rows = rows[:k]
 
     if not rows:
-        return "No labels above the score threshold.", []
+        return "No labels above the score threshold.", "[]"
     width = max(len(r["label"]) for r in rows)
     lines = [
         f"{r['label']:<{width}}  {r['score'] * 100:5.1f}%  {'█' * max(1, int(r['score'] * 24))}"
         for r in rows
     ]
-    return "\n".join(lines), rows
+    # JSON *text*, not a list: a `json` port would reach the canvas as
+    # "[object Object]" (see `detect_objects`).
+    return "\n".join(lines), json.dumps(rows, indent=2)
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1086,8 +1159,10 @@ def draw_detections(image, detections, min_score, show_labels):
     found = _boxes(detections, min_score)
 
     draw = ImageDraw.Draw(img, "RGBA")
-    stroke = max(2, int(min(img.size) * 0.005))
-    font = _font(max(13, int(min(img.size) * 0.028)))
+    # Sized generously on purpose: a canvas node renders a 768px image at
+    # roughly a third of its size, where a hairline box is invisible.
+    stroke = max(3, int(min(img.size) * 0.008))
+    font = _font(max(15, int(min(img.size) * 0.034)))
 
     for i, det in enumerate(found):
         color = _PALETTE[i % len(_PALETTE)]
@@ -1209,8 +1284,9 @@ def contact_sheet(image_1, image_2, image_3, image_4, labels, columns, gap, titl
 def png_info(image):
     """A1111's 'PNG Info' tab: recover generation parameters from a file.
 
-    Returns (report, fields). Reads the ``parameters`` text chunk that
-    `postprocess` writes, so images this app produced round-trip exactly.
+    Returns (report, fields-as-JSON-text). The fields are serialized rather
+    than returned as a dict because a `json` port arrives in the canvas as
+    "[object Object]" (see `detect_objects`).
     """
     img = _load_image(image)
     img.load()  # force chunk parsing so text metadata is populated
@@ -1260,7 +1336,7 @@ def png_info(image):
             + ("Other metadata:\n" + "\n".join(extra) if extra else
                "This image carries no text metadata at all.")
         )
-    return head + body, fields
+    return head + body, json.dumps(fields, indent=2, default=str)
 
 
 # What `app.py` binds onto the canvas. Keys must match the "fn" field of each
@@ -1276,6 +1352,8 @@ BIND = {
     "txt2img": txt2img,
     "chat_llm": chat_llm,
     "interrogate": interrogate,
+    "detect_objects": detect_objects,
+    "classify_image": classify_image,
     "top_labels": top_labels,
     "postprocess": postprocess,
     "prep_image": prep_image,

test_nodes.py

@@ -210,10 +210,14 @@ check("clean_prompt strips LLM chatter", t_clean)
 
 
 def t_labels():
-    text, rows = N.top_labels(
+    text, rows_json = N.top_labels(
         [{"label": "tiger", "score": 0.88}, {"label": "cat", "score": 0.10},
          {"label": "dog", "score": 0.001}], 2, 0.05)
+    # second output is JSON *text* — a json port arrives as "[object Object]"
+    rows = __import__("json").loads(rows_json)
     assert rows[0]["label"] == "tiger" and len(rows) == 2
+    # and it must survive a round trip through a text port
+    assert N.top_labels(rows_json, 2, 0.05)[0].startswith("tiger")
     assert "tiger" in text and "%" in text
     empty, _ = N.top_labels([], 5, 0.5)
     assert "No labels" in empty
@@ -348,7 +352,8 @@ def t_png_roundtrip():
     stamped = N.postprocess(DATA_URI, 1, "Lanczos", 0, 1, 1, 1, 0, 0, 0, "", info)
     assert stamped["url"].startswith("data:image/png"), "metadata must force PNG"
 
-    report, fields = N.png_info(stamped)
+    report, fields_json = N.png_info(stamped)
+    fields = __import__("json").loads(fields_json)
     assert "Generation parameters" in report
     assert fields["prompt"] == "a fox in snow", fields.get("prompt")
     assert fields["negative_prompt"] == "ugly, blurry", fields.get("negative_prompt")
@@ -362,7 +367,8 @@ check("generation params survive the round trip", t_png_roundtrip)
 
 
 def t_png_bare():
-    report, fields = N.png_info(DATA_URI)
+    report, fields_json = N.png_info(DATA_URI)
+    fields = __import__("json").loads(fields_json)
     assert "No generation parameters" in report
     assert fields["width"] == 256 and fields["height"] == 192
 

workflow.json

@@ -1260,32 +1260,37 @@
     {
       "id": "op_classify",
       "role": "operator",
-      "kind": "model",
-      "model_id": "google/vit-base-patch16-224",
-      "pipeline_tag": "image-classification",
-      "endpoint": "image_classification",
+      "kind": "fn",
+      "fn": "classify_image",
       "label": "③ Classify · ViT",
       "inputs": [
         {
-          "id": "image",
+          "id": "in_image",
           "label": "image",
           "type": "image",
           "required": true
+        },
+        {
+          "id": "in_model_id",
+          "label": "model_id",
+          "type": "text"
         }
       ],
       "outputs": [
         {
           "id": "out_0",
-          "label": "Labels",
-          "type": "json",
+          "label": "labels",
+          "type": "text",
           "output_index": 0
         }
       ],
-      "data": {},
+      "data": {
+        "in_model_id": "google/vit-base-patch16-224"
+      },
       "x": 514.3,
       "y": 2007.2,
       "width": 290,
-      "height": 94
+      "height": 124
     },
     {
       "id": "op_labels",
@@ -1297,7 +1302,7 @@
         {
           "id": "in_labels",
           "label": "labels",
-          "type": "json",
+          "type": "text",
           "required": true
         },
         {
@@ -1321,7 +1326,7 @@
         {
           "id": "out_1",
           "label": "rows",
-          "type": "json",
+          "type": "text",
           "output_index": 1
         }
       ],
@@ -1337,32 +1342,43 @@
     {
       "id": "op_detect",
       "role": "operator",
-      "kind": "model",
-      "model_id": "facebook/detr-resnet-50",
-      "pipeline_tag": "object-detection",
-      "endpoint": "object_detection",
+      "kind": "fn",
+      "fn": "detect_objects",
       "label": "① Detect · DETR",
       "inputs": [
         {
-          "id": "image",
+          "id": "in_image",
           "label": "image",
           "type": "image",
           "required": true
+        },
+        {
+          "id": "in_model_id",
+          "label": "model_id",
+          "type": "text"
+        },
+        {
+          "id": "in_min_score",
+          "label": "min_score",
+          "type": "number"
         }
       ],
       "outputs": [
         {
           "id": "out_0",
-          "label": "Detections",
-          "type": "json",
+          "label": "detections",
+          "type": "text",
           "output_index": 0
         }
       ],
-      "data": {},
+      "data": {
+        "in_model_id": "facebook/detr-resnet-50",
+        "in_min_score": 0.0
+      },
       "x": 302.4,
       "y": 2154.9,
       "width": 290,
-      "height": 94
+      "height": 154
     },
     {
       "id": "op_draw",
@@ -1380,7 +1396,7 @@
         {
           "id": "in_detections",
           "label": "detections",
-          "type": "json",
+          "type": "text",
           "required": true
         },
         {
@@ -1433,7 +1449,7 @@
         {
           "id": "in_detections",
           "label": "detections",
-          "type": "json",
+          "type": "text",
           "required": true
         },
         {
@@ -2102,7 +2118,7 @@
         {
           "id": "out_1",
           "label": "fields",
-          "type": "json",
+          "type": "text",
           "output_index": 1
         }
       ],
@@ -2543,19 +2559,19 @@
       "id": "sub_png_fields",
       "role": "subject",
       "label": "🧮 Parsed fields",
-      "asset_type": "json",
+      "asset_type": "text",
       "inputs": [
         {
           "id": "in",
           "label": "🧮 Parsed fields",
-          "type": "json"
+          "type": "text"
         }
       ],
       "outputs": [
         {
           "id": "out",
           "label": "🧮 Parsed fields",
-          "type": "json"
+          "type": "text"
         }
       ],
       "data": {},
@@ -2875,7 +2891,7 @@
       "from_node_id": "ref_interrogate_image",
       "from_port_id": "out",
       "to_node_id": "op_classify",
-      "to_port_id": "image",
+      "to_port_id": "in_image",
       "type": "image"
     },
     {
@@ -2884,7 +2900,7 @@
       "from_port_id": "out_0",
       "to_node_id": "op_labels",
       "to_port_id": "in_labels",
-      "type": "json"
+      "type": "text"
     },
     {
       "id": "e41",
@@ -2899,7 +2915,7 @@
       "from_node_id": "ref_detect_image",
       "from_port_id": "out",
       "to_node_id": "op_detect",
-      "to_port_id": "image",
+      "to_port_id": "in_image",
       "type": "image"
     },
     {
@@ -2916,7 +2932,7 @@
       "from_port_id": "out_0",
       "to_node_id": "op_draw",
       "to_port_id": "in_detections",
-      "type": "json"
+      "type": "text"
     },
     {
       "id": "e45",
@@ -2932,7 +2948,7 @@
       "from_port_id": "out_0",
       "to_node_id": "op_mask",
       "to_port_id": "in_detections",
-      "type": "json"
+      "type": "text"
     },
     {
       "id": "e47",
@@ -3148,7 +3164,7 @@
       "from_port_id": "out_1",
       "to_node_id": "sub_png_fields",
       "to_port_id": "in",
-      "type": "json"
+      "type": "text"
     }
   ]
 }