add Mememage Decode All node for multi-bar composites

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: sememtac

README.md

@@ -203,6 +203,14 @@ reference decoder's password box) reveals them. Needs the crypto library:
   look the record up (e.g. Load Record). To check whether an image *matches* its
   record, use **Mememage Verify** — that's the verification node.
 
+**Mememage Decode All** — `IMAGE → identifiers[], content_hashes[], count, image`
+- Reads **every** bar in a composite (a collage/contact sheet assembled from several
+  barred images carries one bar each). `identifiers` and `content_hashes` are **list**
+  outputs — wire either into **Load Record** or **Verify** and that node runs **once per
+  bar** automatically (ComfyUI list-expansion), no loop node. `count` is how many were
+  found (0 for a bare image), handy to gate on. For the ordinary one-image-one-bar case
+  use **Mememage Decode** instead — this is the forensic reader.
+
 **Mememage Reserve ID** — `→ identifier`
 - A stable identifier **pointer** for iterating one piece. The **🎲 new slot** button
   mints a fresh `<prefix>-<16 hex>` (saved with the workflow); wire the output into

nodes.py

@@ -780,6 +780,49 @@ def run(self, image):
         return (bar.identifier, bar.content_hash, image)
 
 
+class MememageDecodeAll:
+    """Read EVERY Mememage bar in an image — for composites that carry more than one.
+
+    The plain **Mememage Decode** reads the single bottom bar (the common case: one
+    image, one record). This reads them all: an image assembled from several barred
+    pictures (a collage, a contact sheet, a paste-up) carries a bar per source, at
+    whatever height each sits. A forensic reader — "what provenanced images are in
+    here" — closer in spirit to the validator's Observatory than to the mint pipeline.
+
+    `identifiers` and `content_hashes` are LIST outputs (bottom-most bar first, index-
+    aligned), so wiring either into Load Record / Verify makes that node **run once
+    per bar automatically** — no loop node. `count` is the plain number found (0 when
+    the image has no bar), handy to gate on. The image passes through unchanged.
+
+    A false positive would have to beat the magic bytes, CRC-16, and Reed-Solomon at
+    once, so bar-ish noise is dropped, not misread. Reads the first image of a batch,
+    same as Decode.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"image": ("IMAGE",)}}
+
+    RETURN_TYPES = ("STRING", "STRING", "INT", "IMAGE")
+    RETURN_NAMES = ("identifiers", "content_hashes", "count", "image")
+    OUTPUT_IS_LIST = (True, True, False, False)        # ids + hashes fan out; count + image are scalar
+    FUNCTION = "run"
+    CATEGORY = "Mememage"
+    DESCRIPTION = ("Read every Mememage bar in an image (for composites). identifiers + "
+                   "content_hashes are lists that fan out to Load Record / Verify; count is "
+                   "how many were found.")
+
+    def run(self, image):
+        import mememage
+        np, torch, Image = _deps()
+        pil = _tensor_to_pil(image[0], np, Image)
+
+        bars = mememage.decode(pil, all_bars=True)     # list of Bar, bottom-most first
+        identifiers = [b.identifier for b in bars]
+        content_hashes = [b.content_hash for b in bars]
+        return (identifiers, content_hashes, len(bars), image)
+
+
 class MememageReserveId:
     """A reserved identifier — a stable pointer you keep pointing at new versions.
 
@@ -1476,6 +1519,7 @@ async def _mememage_pick_file(request):
     "MememageField": MememageField,
     "MememageFieldList": MememageFieldList,
     "MememageDecode": MememageDecode,
+    "MememageDecodeAll": MememageDecodeAll,
     "MememageLoadRecord": MememageLoadRecord,
     "MememageFindRecord": MememageFindRecord,
     "MememageFetchRecord": MememageFetchRecord,
@@ -1493,6 +1537,7 @@ async def _mememage_pick_file(request):
     "MememageField": "Mememage Field",
     "MememageFieldList": "Mememage Fields",          # friendly name — "the node your fields go into"
     "MememageDecode": "Mememage Decode",
+    "MememageDecodeAll": "Mememage Decode All",
     "MememageLoadRecord": "Mememage Load Record",
     "MememageFindRecord": "Mememage Find Record",
     "MememageFetchRecord": "Mememage Fetch Record",

test_nodes.py

@@ -384,6 +384,47 @@ def test_encode_then_decode(self):
         _, matched, _, _ = nodes.MememageVerify().run(image=barred, record=record)
         self.assertTrue(matched)
 
+    def test_decode_all_finds_every_bar(self):
+        import torch
+        from mememage.bar import embed_into
+        from PIL import Image
+        np, _t, _I = nodes._deps()
+
+        # a genuine 2-bar composite: bar one, push it up by appending rows, stamp a
+        # second at the new bottom (mirrors core's own multi-bar test construction)
+        one = embed_into(Image.new("RGB", (480, 300), (90, 90, 90)),
+                         "mememage-aa8194d91f1da238", "47f11bad5dcc9ad2")
+        w, h = one.size
+        moved = Image.new("RGB", (w, h + 40), (70, 70, 70)); moved.paste(one, (0, 0))
+        two = embed_into(moved, "mememage-deadbeefcafe1234", "0011223344556677")
+
+        tensor = torch.from_numpy(nodes._pil_to_array(two, np))[None, ...]
+        ids, hashes, count, img_out = nodes.MememageDecodeAll().run(tensor)
+        self.assertEqual(count, 2)
+        self.assertEqual(len(ids), 2)
+        self.assertEqual(set(ids), {"mememage-aa8194d91f1da238", "mememage-deadbeefcafe1234"})
+        self.assertEqual(len(hashes), 2)
+        self.assertEqual(img_out.shape, tensor.shape)          # image chains onward
+
+    def test_decode_all_empty_image_is_zero_not_crash(self):
+        import torch
+        img = torch.full((1, 128, 128, 3), 0.5)                # no bar
+        ids, hashes, count, img_out = nodes.MememageDecodeAll().run(img)
+        self.assertEqual(count, 0)
+        self.assertEqual(ids, [])
+        self.assertEqual(hashes, [])
+        self.assertEqual(img_out.shape, img.shape)
+
+    def test_decode_all_single_bar_returns_one(self):
+        import torch
+        img = torch.full((1, 512, 768, 3), 0.5)
+        barred, identifier, _ = nodes.MememageEncode().run(
+            img, fields_json='{"by": "catmemes"}', embed_workflow=False)
+        ids, hashes, count, _out = nodes.MememageDecodeAll().run(barred)
+        self.assertEqual(count, 1)
+        self.assertEqual(ids, [identifier])
+        self.assertEqual(len(hashes), 1)
+
     def test_record_core_fields_first_and_still_verifies(self):
         import torch
         img = torch.full((1, 512, 512, 3), 0.5)