Update app.py

app.py

@@ -1,5 +1,5 @@
 # app.py — CHR Compressed-Only Learning via Trading Card PNG (Investor Demo)
-# End-goal (Level 1): dataset -> compressed codes -> 2D "trading card" image
+# End-goal (Level 1): dataset -> compressed codes -> payload -> embedded INSIDE a "real" trading card PNG
 # Training reads ONLY the trading card PNG pixels (no codes.bin used in training)
 
 import os
@@ -120,22 +120,18 @@ In the beginning, people stored knowledge in libraries, then in databases, and n
 Compression isn’t just saving space — it’s choosing what matters.
 A constellation is a pattern you can navigate.
 Entropy is a measure of surprise, and learning is surprise turning into structure.
-
 A system that learns from compressed data never needs the original.
 It doesn’t memorize pixels; it memorizes geometry.
 It doesn’t hoard text; it extracts signals.
 The question isn’t “Can it compress?” but “Can it learn after compressing?”
-
 Investors love seeing systems move.
 They love curves that fall.
 They love maps that cluster.
 They love a demo that feels alive.
-
 This demo builds a codec from your dataset,
 then trains a model exclusively on the codec’s trading card.
 No raw text is used during training.
 Only the trading card exists.
-
 We call the clusters constellations.
 We call the structure harvestable.
 We call the drop in entropy visible proof.
@@ -267,9 +263,9 @@ def save_codes_and_codec(code_bytes: bytes, codec: Dict, out_dir: str) -> Tuple[
     return bin_path, meta_path
 
 # -----------------------------
-# Trading Card layer (THE NEW PIECE)
+# Trading Card payload (binary blob to hide)
 # -----------------------------
-CARD_MAGIC = b"TCAR"  # Trading Card magic
+CARD_MAGIC = b"TCAR"
 CARD_VER = 1
 
 def _sha256_hex(b: bytes) -> str:
@@ -279,13 +275,6 @@ def _crc32_u32(b: bytes) -> int:
     return zlib.crc32(b) & 0xFFFFFFFF
 
 def pack_trading_card_payload(code_bytes: bytes, codec: Dict, title: str = "CHR Trading Card") -> bytes:
-    """
-    A self-contained binary payload that lives inside the card's pixels.
-
-    Layout:
-      magic(4) | ver(u32) | header_len(u32) | header_json | code_len(u32) | code_bytes
-    Header contains checksums for verification.
-    """
     header = {
         "title": title,
         "codec": {
@@ -305,7 +294,6 @@ def pack_trading_card_payload(code_bytes: bytes, codec: Dict, title: str = "CHR
         "sha256": _sha256_hex(code_bytes),
     }
     header_json = json.dumps(header, ensure_ascii=False).encode("utf-8")
-
     blob = bytearray()
     blob += CARD_MAGIC
     blob += struct.pack("<I", CARD_VER)
@@ -316,9 +304,6 @@ def pack_trading_card_payload(code_bytes: bytes, codec: Dict, title: str = "CHR
     return bytes(blob)
 
 def unpack_trading_card_payload(payload: bytes) -> Tuple[Dict, bytes]:
-    """
-    Returns (header_dict, code_bytes) after validating structure.
-    """
     if len(payload) < 16:
         raise ValueError("Card payload too small.")
     if payload[:4] != CARD_MAGIC:
@@ -338,45 +323,126 @@ def unpack_trading_card_payload(payload: bytes) -> Tuple[Dict, bytes]:
         raise ValueError("Card payload truncated.")
     return header, code_bytes
 
-def bytes_to_data_slab_image(payload: bytes, slab_w: int = 256) -> np.ndarray:
+# -----------------------------
+# NEW: LSB Steganography (payload hidden in pixels)
+# -----------------------------
+STEGO_MAGIC = b"TCV1"  # trading card vault v1
+
+def pack_stego(payload: bytes) -> bytes:
+    crc = _crc32_u32(payload)
+    sha = hashlib.sha256(payload).digest()
+    header = STEGO_MAGIC + struct.pack("<I", len(payload)) + struct.pack("<I", crc) + sha
+    return header + payload
+
+def unpack_stego(packed: bytes) -> bytes:
+    if packed[:4] != STEGO_MAGIC:
+        raise ValueError("Bad stego magic")
+    n = struct.unpack("<I", packed[4:8])[0]
+    crc = struct.unpack("<I", packed[8:12])[0]
+    sha = packed[12:44]
+    data = packed[44:44+n]
+    if len(data) != n:
+        raise ValueError("Truncated stego payload")
+    if _crc32_u32(data) != crc:
+        raise ValueError("Stego CRC mismatch")
+    if hashlib.sha256(data).digest() != sha:
+        raise ValueError("Stego SHA mismatch")
+    return data
+
+def stego_capacity_bytes(H: int, W: int, bits_per_channel: int = 1) -> int:
+    # capacity for packed payload (includes stego header ~44 bytes)
+    return (H * W * 3 * bits_per_channel) // 8
+
+def embed_lsb_rgb(carrier_rgb: np.ndarray, payload_bytes: bytes, bits_per_channel: int = 1) -> np.ndarray:
     """
-    Convert payload bytes into a 2D slab (grayscale) image as uint8.
-    We pad to full rows.
+    Embed payload into carrier RGB using LSBs.
+    Uses a robust header (magic+len+crc+sha).
     """
-    arr = np.frombuffer(payload, dtype=np.uint8)
-    w = int(slab_w)
-    h = int(math.ceil(len(arr) / w))
-    pad = h*w - len(arr)
-    if pad > 0:
-        arr = np.concatenate([arr, np.zeros(pad, dtype=np.uint8)], axis=0)
-    slab = arr.reshape(h, w)
-    return slab
-
-def data_slab_image_to_bytes(slab: np.ndarray, orig_len: int) -> bytes:
-    flat = slab.astype(np.uint8).ravel()
-    return bytes(flat[:orig_len])
+    assert carrier_rgb.dtype == np.uint8 and carrier_rgb.ndim == 3 and carrier_rgb.shape[2] == 3
+    assert bits_per_channel in (1, 2), "Use 1 for best invisibility"
+
+    packed = pack_stego(payload_bytes)
+    bitstream = np.unpackbits(np.frombuffer(packed, dtype=np.uint8))
+
+    H, W, C = carrier_rgb.shape
+    capacity_bits = H * W * C * bits_per_channel
+    if len(bitstream) > capacity_bits:
+        raise RuntimeError(
+            f"Carrier too small: need {len(bitstream)} bits, capacity {capacity_bits} bits. "
+            f"Use larger image or bits_per_channel=2."
+        )
 
-def make_holo_front(U: np.ndarray, K: int, W: int, H: int, seed: int = 0) -> np.ndarray:
+    out = carrier_rgb.copy()
+    flat = out.reshape(-1)
+
+    k = bits_per_channel
+    mask_clear = 0xFF ^ ((1 << k) - 1)
+
+    if k == 1:
+        flat[:len(bitstream)] = (flat[:len(bitstream)] & mask_clear) | bitstream
+    else:
+        pad = (-len(bitstream)) % 2
+        if pad:
+            bitstream = np.concatenate([bitstream, np.zeros(pad, dtype=np.uint8)])
+        symbols = bitstream.reshape(-1, 2)
+        vals = (symbols[:, 0] << 1) | symbols[:, 1]
+        flat[:len(vals)] = (flat[:len(vals)] & mask_clear) | vals
+
+    return out
+
+def extract_lsb_rgb(stego_rgb: np.ndarray, bits_per_channel: int = 1) -> bytes:
     """
-    Create a holographic-looking RGB background from anchors U.
-    Deterministic and fast. This is "sizzle"; it doesn't contain the payload.
+    Extract embedded payload bytes from RGB using LSBs.
     """
+    assert stego_rgb.dtype == np.uint8 and stego_rgb.ndim == 3 and stego_rgb.shape[2] == 3
+    k = bits_per_channel
+    flat = stego_rgb.reshape(-1)
+
+    # Need at least 44-byte stego header first
+    header_bytes = 44
+    header_bits = header_bytes * 8
+
+    def read_bits(nbits: int) -> np.ndarray:
+        if k == 1:
+            vals = (flat[:nbits] & 1).astype(np.uint8)
+            return vals
+        else:
+            nvals = (nbits + 1) // 2
+            vals = (flat[:nvals] & 3).astype(np.uint8)
+            bits = np.zeros(nvals * 2, dtype=np.uint8)
+            bits[0::2] = (vals >> 1) & 1
+            bits[1::2] = vals & 1
+            return bits[:nbits]
+
+    hb = read_bits(header_bits)
+    header = np.packbits(hb).tobytes()
+
+    if header[:4] != STEGO_MAGIC:
+        raise ValueError("Stego magic not found (wrong image or wrong bits_per_channel).")
+
+    n = struct.unpack("<I", header[4:8])[0]
+    total_bytes = 44 + n
+    total_bits = total_bytes * 8
+
+    bits = read_bits(total_bits)
+    packed = np.packbits(bits).tobytes()
+    return unpack_stego(packed)
+
+# -----------------------------
+# Visual "hologram" front (sizzle only)
+# -----------------------------
+def make_holo_front(U: np.ndarray, K: int, W: int, H: int, seed: int = 0) -> np.ndarray:
     rng = np.random.RandomState(int(seed) + 123)
-    # pick a few anchor directions and random frequencies
     d = U.shape[1]
     n = min(K, 16)
     idx = rng.choice(K, size=n, replace=K < n)
-    V = U[idx]  # [n, d]
-    # Create a coordinate grid
+    V = U[idx]
     yy, xx = np.mgrid[0:H, 0:W].astype(np.float32)
     xx = (xx / max(1, W-1) - 0.5) * 2.0
     yy = (yy / max(1, H-1) - 0.5) * 2.0
-
-    # derive frequencies and phases from U
     freqs = rng.uniform(2.0, 10.0, size=n).astype(np.float32)
     phases = rng.uniform(0, 2*np.pi, size=n).astype(np.float32)
 
-    # 3 channels from different mixtures
     out = np.zeros((H, W, 3), dtype=np.float32)
     for c in range(3):
         acc = np.zeros((H, W), dtype=np.float32)
@@ -384,85 +450,57 @@ def make_holo_front(U: np.ndarray, K: int, W: int, H: int, seed: int = 0) -> np.
             a = float(V[i, (c*7) % d])
             b = float(V[i, (c*11 + 3) % d])
             acc += np.cos(freqs[i] * (a*xx + b*yy) + phases[i])
-        # normalize 0..1
         acc = (acc - acc.min()) / (acc.max() - acc.min() + 1e-9)
         out[..., c] = acc
 
-    # add a subtle radial vignette
     rr = np.sqrt(xx*xx + yy*yy)
     vignette = np.clip(1.1 - 0.35*rr, 0.6, 1.1)
     out *= vignette[..., None]
     out = np.clip(out, 0.0, 1.0)
     return (out * 255.0).astype(np.uint8)
 
-def compose_trading_card(front_rgb: np.ndarray, slab_gray: np.ndarray, title: str, subtitle: str) -> np.ndarray:
+def overlay_holo_banner(base_rgb: np.ndarray, holo_rgb: np.ndarray, alpha: float = 0.35) -> np.ndarray:
     """
-    Make a single card image:
-      - top: holo front with title/subtitle overlay
-      - bottom: data slab grid (this is where bytes live)
-    Output: RGB uint8 image.
+    Apply holo overlay to top area of base card for investor wow,
+    WITHOUT being required for decoding (payload is hidden in full image via LSB).
     """
-    Hf, Wf, _ = front_rgb.shape
-    slab_h, slab_w = slab_gray.shape
-
-    # Make slab into RGB
-    slab_rgb = np.stack([slab_gray]*3, axis=-1)
-
-    # Add a separator
-    sep = np.full((8, Wf, 3), 16, dtype=np.uint8)
-
-    # Resize slab to match card width (nearest)
-    if slab_w != Wf:
-        # simple nearest resize
-        slab_img = Image.fromarray(slab_gray, mode="L")
-        slab_img = slab_img.resize((Wf, slab_h), resample=Image.NEAREST)
-        slab_gray2 = np.array(slab_img, dtype=np.uint8)
-        slab_rgb = np.stack([slab_gray2]*3, axis=-1)
-
-    card = np.concatenate([front_rgb, sep, slab_rgb], axis=0)
-
-    # Overlay text on front using PIL (fast and dependency-light)
+    out = base_rgb.copy().astype(np.float32)
+    H, W, _ = out.shape
+    hh = min(holo_rgb.shape[0], H)
+    hw = min(holo_rgb.shape[1], W)
+    holo = holo_rgb[:hh, :hw].astype(np.float32)
+    out[:hh, :hw] = (1 - alpha) * out[:hh, :hw] + alpha * holo
+    return np.clip(out, 0, 255).astype(np.uint8)
+
+def add_text_frame(card_rgb: np.ndarray, title: str, subtitle: str) -> np.ndarray:
     try:
-        pil = Image.fromarray(card, mode="RGB")
+        pil = Image.fromarray(card_rgb, mode="RGB")
         from PIL import ImageDraw, ImageFont
         draw = ImageDraw.Draw(pil)
-        # default font
-        font1 = ImageFont.load_default()
-        font2 = ImageFont.load_default()
+        font = ImageFont.load_default()
+        W, H = pil.size
 
-        # Place title/subtitle
-        draw.rectangle([0, 0, Wf, 26], fill=(0, 0, 0))
-        draw.text((10, 6), title, fill=(255, 255, 255), font=font1)
-        draw.text((10, 34), subtitle, fill=(255, 255, 255), font=font2)
+        # header bar
+        draw.rectangle([0, 0, W, 26], fill=(0, 0, 0))
+        draw.text((10, 6), title[:80], fill=(255, 255, 255), font=font)
+        draw.text((10, 34), subtitle[:120], fill=(255, 255, 255), font=font)
 
-        # Add a "foil" frame
-        draw.rectangle([4, 4, Wf-5, Hf-5], outline=(220, 220, 255), width=2)
+        # frame
+        draw.rectangle([4, 4, W-5, H-5], outline=(220, 220, 255), width=2)
 
-        card = np.array(pil, dtype=np.uint8)
+        return np.array(pil, dtype=np.uint8)
     except Exception:
-        pass
-
-    return card
+        return card_rgb
 
 def save_png(arr: np.ndarray, path: str):
     Image.fromarray(arr).save(path, format="PNG")
 
-def load_png(path: str) -> np.ndarray:
+def load_image_any(path: str) -> np.ndarray:
+    # For carrier: allow jpg/png, convert to RGB
     return np.array(Image.open(path).convert("RGB"), dtype=np.uint8)
 
-def extract_payload_from_card(card_rgb: np.ndarray, slab_top: int, slab_w: int, payload_len: int) -> bytes:
-    """
-    Extract bytes from the slab region (grayscale interpretation).
-    We read from the card's bottom data slab.
-    """
-    slab_rgb = card_rgb[slab_top:, :, :]
-    slab_gray = slab_rgb[..., 0].astype(np.uint8)  # stored grayscale replicated in RGB
-    # slab_gray already width==card width, we assume slab_w==card width
-    slab = slab_gray
-    return data_slab_image_to_bytes(slab, payload_len)
-
 # -----------------------------
-# Visuals (existing + card-specific)
+# Visuals
 # -----------------------------
 def plot_entropy(Hg, Hs, out_path):
     plt.figure(figsize=(6,4))
@@ -532,10 +570,6 @@ def plot_before_after_tracks(before_bytes: List[int], after_bytes: List[int], ou
     plt.close()
 
 def make_card_tilt_gif(card_rgb: np.ndarray, out_path: str, frames: int = 24, fps: int = 12):
-    """
-    Cheap holo tilt effect: shift color channels + brightness gradient over the front region.
-    This is pure sizzle and very fast.
-    """
     H, W, _ = card_rgb.shape
     frames = int(max(8, min(frames, 48)))
     fps = int(max(6, min(fps, 24)))
@@ -547,13 +581,10 @@ def make_card_tilt_gif(card_rgb: np.ndarray, out_path: str, frames: int = 24, fp
         dy = int(2 + 3*np.cos(a))
 
         img = card_rgb.copy().astype(np.int16)
-
-        # apply gentle "tilt" to the top half (front)
-        front_h = int(H * 0.45)
+        front_h = int(H * 0.35)
         yy, xx = np.mgrid[0:front_h, 0:W]
         grad = (0.85 + 0.15*np.sin(a + (xx / max(1, W-1))*2*np.pi)).astype(np.float32)
 
-        # channel shift
         r = np.roll(img[:front_h, :, 0], shift=dx, axis=1)
         g = np.roll(img[:front_h, :, 1], shift=dy, axis=0)
         b = img[:front_h, :, 2]
@@ -568,28 +599,25 @@ def make_card_tilt_gif(card_rgb: np.ndarray, out_path: str, frames: int = 24, fp
     imageio.mimsave(out_path, imgs, fps=fps)
 
 # -----------------------------
-# Training: byte-model reads ONLY the trading card PNG pixels
+# Training: byte-model reads ONLY the trading card PNG pixels (LSB extraction)
 # -----------------------------
 import torch
 import torch.nn as nn
 from torch.utils.data import Dataset, DataLoader
 
-class CardByteDataset(Dataset):
+class CardStegoDataset(Dataset):
     """
-    Produces next-byte prediction windows from the trading card's payload bytes.
-    Importantly, it reads from the CARD PNG (pixels) every time.
+    Produces next-byte prediction windows from bytes extracted from the card PNG via LSB.
     """
-    def __init__(self, card_png_path: str, payload_len: int, slab_top: int, block_size: int = 128):
+    def __init__(self, card_png_path: str, bits_per_channel: int = 1, block_size: int = 128):
         self.card_png_path = card_png_path
-        self.payload_len = int(payload_len)
-        self.slab_top = int(slab_top)
+        self.bits_per_channel = int(bits_per_channel)
         self.block_size = int(block_size)
 
-        card = load_png(card_png_path)
-        slab_rgb = card[self.slab_top:, :, :]
-        slab_gray = slab_rgb[..., 0].astype(np.uint8)
-        flat = slab_gray.ravel()
-        self.bytes = torch.tensor(list(flat[:self.payload_len]), dtype=torch.long)
+        card = load_image_any(card_png_path)
+        payload = extract_lsb_rgb(card, bits_per_channel=self.bits_per_channel)
+        # We train on the whole payload blob (contains card header+codes)
+        self.bytes = torch.tensor(list(payload), dtype=torch.long)
 
     def __len__(self):
         return max(0, len(self.bytes) - self.block_size - 1)
@@ -636,21 +664,19 @@ def sample_bytes(model, start: List[int], steps: int, device: str = "cpu", tempe
         seq.append(nxt)
     return seq
 
-def train_on_card_png(card_png_path: str,
-                      payload_len: int,
-                      slab_top: int,
-                      steps: int = 250,
-                      batch_size: int = 32,
-                      block_size: int = 128,
-                      lr: float = 5e-4,
-                      device: str = "cpu",
-                      log_every: int = 25):
-    ds = CardByteDataset(card_png_path, payload_len=payload_len, slab_top=slab_top, block_size=block_size)
+def train_on_stego_card(card_png_path: str,
+                        bits_per_channel: int = 1,
+                        steps: int = 180,
+                        batch_size: int = 32,
+                        block_size: int = 128,
+                        lr: float = 5e-4,
+                        device: str = "cpu",
+                        log_every: int = 20):
+    ds = CardStegoDataset(card_png_path, bits_per_channel=bits_per_channel, block_size=block_size)
     n_windows = len(ds)
     if n_windows <= 0:
-        raise RuntimeError(f"Card payload too small for block_size={block_size}. Reduce block_size or increase data.")
+        raise RuntimeError(f"Not enough embedded bytes for block_size={block_size}. Reduce block_size or embed more.")
 
-    # avoid drop_last if small
     drop_last = n_windows >= batch_size
     dl = DataLoader(ds, batch_size=batch_size, shuffle=True, drop_last=drop_last)
     it = iter(dl)
@@ -701,10 +727,16 @@ STATE = {
     "codec_path": None,
     "codec": None,
 
-    "card_png_path": None,
-    "card_payload_len": None,
-    "card_slab_top": None,
-    "card_header": None,
+    "payload_bytes": None,       # the true payload to embed (TCAR blob)
+    "payload_len": None,
+
+    "plain_card_png": None,      # original "CHR slab card" (optional preview)
+    "plain_card_gif": None,
+
+    "final_card_png": None,      # carrier-with-embedded-payload (THIS is what we train on)
+    "final_card_gif": None,
+    "final_card_header": None,   # header decoded from embedded payload
+    "stego_bits": 1,
 
     "model": None,
 }
@@ -750,20 +782,16 @@ def ingest_file(file_obj, units_mode: str):
     except Exception as e:
         return f"Error ingesting file: {e}"
 
-def compress_and_make_card(K, iters, beta, slab_bins, tau, seed, radial_bins,
-                           card_width, front_height, title_text):
+def compress_and_make_payload(K, iters, beta, slab_bins, tau, seed, radial_bins, title_text):
     """
-    1) CHR compress
-    2) build codes.bin + codec.json
-    3) build trading card PNG that embeds a full self-contained payload
-    4) verify by extracting payload back from the PNG
+    Compress, create payload bytes (TCAR), and also render a quick "preview" CHR card (slab style).
+    NOTE: The preview is not used for training. Training will use the final embedded carrier card.
     """
     try:
         units = STATE.get("units")
         if not units:
             return "No units loaded. Upload or load demo corpus.", None, None, None, None, None, None
 
-        # --- CHR compression ---
         Z, backend = embed_texts(units, prefer_sentence_transformer=True)
         U, p, Hg, Hs = chr_optimize(
             Z, K=int(K), iters=int(iters), beta=float(beta),
@@ -775,11 +803,10 @@ def compress_and_make_card(K, iters, beta, slab_bins, tau, seed, radial_bins,
 
         edges = make_radial_bins(radials, B=int(radial_bins))
         bins_q = np.array([quantize_radial(float(radials[i]), edges) for i in range(len(units))], dtype=np.int32)
-
         code_bytes = pack_codes_to_bytes(labels, bins_q)
 
-        # --- Save codes.bin + codec.json (for audit/download only) ---
         out_dir = tempfile.mkdtemp()
+
         codec = {
             "backend": backend,
             "K": int(K),
@@ -797,113 +824,191 @@ def compress_and_make_card(K, iters, beta, slab_bins, tau, seed, radial_bins,
         }
         bin_path, codec_path = save_codes_and_codec(code_bytes, codec, out_dir)
 
-        # --- Build trading card payload ---
-        payload = pack_trading_card_payload(code_bytes=code_bytes, codec=codec, title=str(title_text).strip()[:120] or "CHR Trading Card")
-        payload_len = len(payload)
-
-        # --- Render data slab and holo front ---
-        card_w = int(card_width)
-        front_h = int(front_height)
-        slab = bytes_to_data_slab_image(payload, slab_w=card_w)  # grayscale slab holding payload
-        slab_h = slab.shape[0]
-        # front with same width
-        front = make_holo_front(np.array(U, dtype=np.float32), K=int(K), W=card_w, H=front_h, seed=int(seed))
-
-        mhep = compute_mhep(Hg, Hs, K=int(K), bins=int(slab_bins))
-
-        subtitle = f"Units={len(units)}  K={int(K)}  Bytes={payload_len}  CRC32={_crc32_u32(code_bytes):08x}"
-        card_rgb = compose_trading_card(front_rgb=front, slab_gray=slab, title=str(title_text).strip() or "CHR Trading Card", subtitle=subtitle)
-
-        # --- Save PNG ---
-        card_png_path = os.path.join(out_dir, "trading_card.png")
-        save_png(card_rgb, card_png_path)
-
-        # --- Determine slab top for extraction ---
-        sep_h = 8
-        slab_top = front_h + sep_h
-
-        # --- Verify by extracting payload back from PNG ---
-        card_loaded = load_png(card_png_path)
-        extracted = extract_payload_from_card(card_loaded, slab_top=slab_top, slab_w=card_w, payload_len=payload_len)
-        header2, code2 = unpack_trading_card_payload(extracted)
-
-        ok_crc = (_crc32_u32(code2) == int(header2["crc32"]))
-        ok_sha = (_sha256_hex(code2) == str(header2["sha256"]))
-        verified = (ok_crc and ok_sha and len(code2) == len(code_bytes))
-
-        # Save extra visuals
-        ent_plot = os.path.join(out_dir, "entropy.png")
-        map_plot = os.path.join(out_dir, "map.png")
-        plot_entropy(Hg, Hs, ent_plot)
-        plot_constellation_map(Z, U, labels, map_plot)
-
-        tilt_gif = os.path.join(out_dir, "card_tilt.gif")
-        # small tilt gif (fast)
-        make_card_tilt_gif(card_rgb, tilt_gif, frames=18, fps=12)
+        payload = pack_trading_card_payload(
+            code_bytes=code_bytes,
+            codec=codec,
+            title=str(title_text).strip()[:120] or "CHR Trading Card"
+        )
 
         STATE.update({
             "Z": Z, "U": U, "labels": labels, "bins": bins_q,
             "bin_path": bin_path, "codec_path": codec_path, "codec": codec,
-            "card_png_path": card_png_path,
-            "card_payload_len": payload_len,
-            "card_slab_top": slab_top,
-            "card_header": header2,
+            "payload_bytes": payload,
+            "payload_len": int(len(payload)),
+            "final_card_png": None,
+            "final_card_gif": None,
+            "final_card_header": None,
             "model": None
         })
 
+        # Visuals
+        ent_plot = os.path.join(out_dir, "entropy.png")
+        map_plot = os.path.join(out_dir, "map.png")
+        plot_entropy(Hg, Hs, ent_plot)
+        plot_constellation_map(Z, U, labels, map_plot)
+
+        mhep = compute_mhep(Hg, Hs, K=int(K), bins=int(slab_bins))
         report = (
-            f"## Trading Card Generated\n"
+            f"## Payload Ready\n"
             f"- **Embedding backend:** `{backend}`\n"
             f"- **Units:** **{len(units)}**\n"
             f"- **Constellations (K):** **{int(K)}**\n"
             f"- **Radial bins:** **{int(radial_bins)}**\n"
-            f"- **Card width:** **{card_w}px**\n"
-            f"- **Payload bytes inside card:** **{payload_len}**\n"
-            f"- **Code bytes (constellation+radial):** **{len(code_bytes)}**\n"
+            f"- **Code bytes:** **{len(code_bytes)}**\n"
+            f"- **Payload bytes (TCAR):** **{len(payload)}**\n"
             f"- **MHEP score:** **{mhep:.1f}%**\n"
-            f"\n### Integrity\n"
-            f"- CRC32 match: **{str(ok_crc)}**\n"
-            f"- SHA256 match: **{str(ok_sha)}**\n"
-            f"- **Verified:** {'✅ YES' if verified else '❌ NO'}\n"
-            f"\n### Investor-proof constraint\n"
-            f"Training can now read **only** the **PNG trading card pixels**."
+            f"\nNext: upload a **carrier trading card image** and embed this payload inside it."
         )
+        return report, ent_plot, map_plot, bin_path, codec_path, json.dumps({"payload_len": len(payload)}, indent=2), json.dumps(codec, indent=2)
+    except Exception as e:
+        return f"Error: {e}\n\n{traceback.format_exc()}", None, None, None, None, None, None
+
+def embed_payload_into_carrier(carrier_file, card_width, holo_height, holo_alpha, stego_bits, title_text):
+    """
+    Step before training:
+      - Take uploaded carrier image
+      - Resize/crop to a clean card canvas
+      - Embed TCAR payload invisibly via LSB over full image
+      - Overlay holo banner for wow (optional)
+      - Save final PNG and verify by extracting payload back from pixels
+    """
+    try:
+        payload = STATE.get("payload_bytes")
+        codec = STATE.get("codec")
+        U = STATE.get("U")
+        if payload is None or codec is None or U is None:
+            return "No payload exists yet. Run compression first.", None, None, None, None
 
-        header_json = json.dumps(header2, indent=2)
+        b, name = _bytes_from_upload(carrier_file)
+        if not b:
+            return "Upload a carrier image (PNG/JPG).", None, None, None, None
+
+        out_dir = tempfile.mkdtemp()
+        carrier_path = os.path.join(out_dir, f"carrier_{name}")
+        Path(carrier_path).write_bytes(b)
+
+        # Load carrier
+        rgb = load_image_any(carrier_path)
+
+        # Build a consistent card canvas
+        W = int(card_width)
+        # Choose a trading-card-ish height ratio
+        H = int(max(256, round(W * 1.4)))
+        # center crop to ratio then resize
+        pil = Image.fromarray(rgb, mode="RGB")
+        srcW, srcH = pil.size
+        target_ratio = W / H
+        src_ratio = srcW / srcH
+        if src_ratio > target_ratio:
+            # too wide, crop width
+            newW = int(srcH * target_ratio)
+            x0 = (srcW - newW) // 2
+            pil = pil.crop((x0, 0, x0 + newW, srcH))
+        else:
+            # too tall, crop height
+            newH = int(srcW / target_ratio)
+            y0 = (srcH - newH) // 2
+            pil = pil.crop((0, y0, srcW, y0 + newH))
+        pil = pil.resize((W, H), resample=Image.BICUBIC)
+        base = np.array(pil, dtype=np.uint8)
+
+        bits = int(stego_bits)
+        if bits not in (1, 2):
+            bits = 1
+
+        # Capacity check
+        cap = stego_capacity_bytes(H, W, bits_per_channel=bits)
+        packed_need = len(pack_stego(payload))
+        if packed_need > cap:
+            return (
+                f"Carrier too small for payload.\n\n"
+                f"- Carrier canvas: **{W}x{H}**\n"
+                f"- Capacity (@{bits} bit/channel): **~{cap} bytes**\n"
+                f"- Needed (payload+stego header): **{packed_need} bytes**\n\n"
+                f"Fix: increase card_width, use a larger carrier, or set bits_per_channel=2.",
+                None, None, None, None
+            )
+
+        # Embed
+        stego = embed_lsb_rgb(base, payload_bytes=payload, bits_per_channel=bits)
+
+        # Visual holo overlay (optional)
+        hh = int(holo_height)
+        hh = max(64, min(hh, H))
+        alpha = float(holo_alpha)
+        alpha = max(0.0, min(alpha, 0.85))
+        holo = make_holo_front(np.array(U, dtype=np.float32), K=int(codec["K"]), W=W, H=hh, seed=int(codec["seed"]))
+        stego2 = overlay_holo_banner(stego, holo, alpha=alpha)
+
+        # Add title/subtitle (sizzle)
+        subtitle = f"Units={codec.get('units_count')}  K={codec.get('K')}  Payload={len(payload)}B  CRC32={_crc32_u32(payload):08x}"
+        final = add_text_frame(stego2, title=str(title_text).strip() or "Trading Card", subtitle=subtitle)
+
+        # Save final PNG (IMPORTANT: PNG only)
+        final_path = os.path.join(out_dir, "final_trading_card.png")
+        save_png(final, final_path)
+
+        # Verify by extraction (pixels only)
+        extracted_payload = extract_lsb_rgb(load_image_any(final_path), bits_per_channel=bits)
+        header2, code2 = unpack_trading_card_payload(extracted_payload)
+
+        ok_codes_crc = (_crc32_u32(code2) == int(header2["crc32"]))
+        ok_codes_sha = (_sha256_hex(code2) == str(header2["sha256"]))
+        verified = bool(ok_codes_crc and ok_codes_sha)
+
+        # Tilt gif for wow
+        tilt_path = os.path.join(out_dir, "final_card_tilt.gif")
+        make_card_tilt_gif(final, tilt_path, frames=18, fps=12)
+
+        STATE.update({
+            "final_card_png": final_path,
+            "final_card_gif": tilt_path,
+            "final_card_header": header2,
+            "stego_bits": bits,
+            "model": None
+        })
 
-        return report, ent_plot, map_plot, card_png_path, tilt_gif, bin_path, codec_path, header_json
+        report = (
+            f"## Final Trading Card Created (Carrier + Embedded Data)\n"
+            f"- **Carrier canvas:** **{W}x{H}**\n"
+            f"- **Stego bits/channel:** **{bits}**\n"
+            f"- **Capacity:** ~**{cap} bytes**\n"
+            f"- **Needed:** **{packed_need} bytes**\n"
+            f"- **Verified (from pixels):** {'✅ YES' if verified else '❌ NO'}\n"
+            f"\nThis PNG now **contains the real dataset representation inside its pixels**.\n"
+            f"Next: Train — model will extract bytes from **this image only**."
+        )
+        return report, final_path, tilt_path, json.dumps(header2, indent=2), json.dumps({"capacity_bytes": cap, "needed_bytes": packed_need}, indent=2)
     except Exception as e:
-        return f"Error: {e}\n\n{traceback.format_exc()}", None, None, None, None, None, None, None
+        return f"Embed error: {e}\n\n{traceback.format_exc()}", None, None, None, None
 
-def train_from_card(train_steps, batch_size, block_size, lr, log_every,
-                    temperature, rollout_steps, make_gif, gif_stride, gif_fps, gif_max_frames):
+def train_from_final_card(train_steps, batch_size, block_size, lr, log_every,
+                          temperature, rollout_steps):
     """
-    Train byte-level transformer on bytes extracted from the trading card PNG.
+    Train byte-level transformer on bytes extracted from FINAL trading card PNG via LSB.
     Training uses ONLY the PNG pixels.
     """
     try:
-        card_png_path = STATE.get("card_png_path")
-        payload_len = STATE.get("card_payload_len")
-        slab_top = STATE.get("card_slab_top")
-        header = STATE.get("card_header")
+        card_png_path = STATE.get("final_card_png")
+        bits = int(STATE.get("stego_bits", 1))
 
-        if not card_png_path or not os.path.exists(card_png_path) or payload_len is None or slab_top is None:
-            return "No trading card found. Generate a card first.", None, None, None, None
+        if not card_png_path or not os.path.exists(card_png_path):
+            return "No final trading card found. Embed payload onto a carrier card first.", None, None, None, None
 
         device = "cuda" if torch.cuda.is_available() else "cpu"
 
-        # Re-load card and extract payload bytes (PNG pixels only)
-        card_rgb = load_png(card_png_path)
-        extracted = extract_payload_from_card(card_rgb, slab_top=slab_top, slab_w=card_rgb.shape[1], payload_len=int(payload_len))
+        # Extract payload from pixels
+        card_rgb = load_image_any(card_png_path)
+        payload = extract_lsb_rgb(card_rgb, bits_per_channel=bits)
 
-        # Parse payload and verify again (still only from pixels)
-        header2, code_bytes = unpack_trading_card_payload(extracted)
+        # Verify and parse
+        header2, code_bytes = unpack_trading_card_payload(payload)
         ok_crc = (_crc32_u32(code_bytes) == int(header2["crc32"]))
         ok_sha = (_sha256_hex(code_bytes) == str(header2["sha256"]))
         verified = (ok_crc and ok_sha)
 
         # Auto-tune for speed + guarantee it runs
-        L = len(extracted)  # training bytes are the full payload
+        L = len(payload)
         user_block = int(block_size)
         user_bs = int(batch_size)
 
@@ -915,22 +1020,21 @@ def train_from_card(train_steps, batch_size, block_size, lr, log_every,
         tuned_bs = min(user_bs, max(8, n_windows // 4)) if n_windows > 0 else 1
         batch_size = int(max(1, tuned_bs))
 
-        # Start context for sampling: from the payload bytes (not codes.bin)
-        start = list(extracted[:block_size])
+        # Start context for sampling: from the payload bytes
+        start = list(payload[:block_size])
 
-        out_dir = os.path.dirname(card_png_path)
+        out_dir = tempfile.mkdtemp()
 
-        # BEFORE rollout (untrained)
+        # BEFORE rollout
         untrained = TinyByteTransformer(block_size=block_size).to(device)
         before_seq = sample_bytes(untrained, start=start, steps=int(rollout_steps), device=device, temperature=float(temperature))
         before_plot = os.path.join(out_dir, "rollout_before.png")
         plot_rollout_tracks(before_seq[-int(rollout_steps):], before_plot, title="BEFORE training (random)")
 
         # Train
-        model, losses, ppls = train_on_card_png(
+        model, losses, ppls = train_on_stego_card(
             card_png_path=card_png_path,
-            payload_len=int(payload_len),
-            slab_top=int(slab_top),
+            bits_per_channel=bits,
             steps=int(train_steps),
             batch_size=batch_size,
             block_size=block_size,
@@ -952,69 +1056,38 @@ def train_from_card(train_steps, batch_size, block_size, lr, log_every,
         compare_plot = os.path.join(out_dir, "rollout_compare.png")
         plot_before_after_tracks(before_seq[-int(rollout_steps):], after_seq[-int(rollout_steps):], compare_plot)
 
-        # Optional GIF (cap frames)
-        gif_path = None
-        if bool(make_gif):
-            gif_path = os.path.join(out_dir, "rollout.gif")
-            # Make a lightweight GIF using the byte track plot frames (fast)
-            # We'll render a few frames by progressively revealing the curve
-            seq = after_seq[-int(rollout_steps):]
-            stride = max(1, int(gif_stride))
-            fps = max(6, int(gif_fps))
-            max_frames = max(12, int(gif_max_frames))
-
-            frames = []
-            count = 0
-            for t in range(10, len(seq), stride):
-                fig = plt.figure(figsize=(7,3.6))
-                plt.plot(seq[:t], linewidth=2)
-                plt.ylim(-2, 260)
-                plt.title("AFTER training — rollout from trading card pixels")
-                plt.xlabel("Step"); plt.ylabel("Byte value")
-                plt.tight_layout()
-                buf = io.BytesIO()
-                plt.savefig(buf, format="png", dpi=140)
-                plt.close(fig)
-                buf.seek(0)
-                frames.append(imageio.imread(buf))
-                count += 1
-                if count >= max_frames:
-                    break
-            imageio.mimsave(gif_path, frames, fps=fps)
-
         report = (
-            f"## Training Complete (PNG-only)\n"
+            f"## Training Complete (Card Pixels Only)\n"
             f"- **Device:** `{device}`\n"
             f"- **Integrity (from pixels):** {'✅ Verified' if verified else '❌ Not verified'}\n"
-            f"- **Payload bytes used for training:** **{L}**\n"
+            f"- **Payload bytes trained on:** **{L}**\n"
             f"- **Auto block_size:** **{block_size}** (requested {user_block})\n"
             f"- **Auto batch_size:** **{batch_size}** (requested {user_bs})\n"
             f"- **Steps:** **{int(train_steps)}** (logged every {int(log_every)})\n"
             f"- **Final logged loss:** **{losses[-1]:.4f}**\n"
             f"- **Final logged perplexity:** **{ppls[-1]:.2f}**\n"
-            f"\n### What investors should notice\n"
-            f"Perplexity falls while training from **a single trading card image**."
+            f"\n### Investor-proof statement\n"
+            f"The model learned from **a single trading card image** that contains the dataset **inside its pixels**."
         )
 
         metrics = {"loss": losses, "ppl": ppls}
-        return report, train_plot, compare_plot, gif_path, json.dumps(metrics, indent=2)
+        return report, train_plot, compare_plot, before_plot, after_plot, json.dumps(metrics, indent=2)
     except Exception as e:
-        return f"Training error: {e}\n\n{traceback.format_exc()}", None, None, None, None
+        return f"Training error: {e}\n\n{traceback.format_exc()}", None, None, None, None, None
 
 # -----------------------------
 # Gradio UI
 # -----------------------------
 INTRO = """
-# Trading Card Learning (Level 1)
+# Trading Card Learning (Level 1 — Investor Demo)
 **Pipeline:**
 1) Compress dataset → **constellation/radial codes**
-2) Pack codes into a **single PNG trading card**
-3) Train a tiny model using **only the PNG pixels**
-
-This is the “data becomes a trading card” end goal.
+2) Pack codes into a payload (TCAR)
+3) Upload a **real trading card image** (carrier) → embed payload **inside pixels** (LSB stego)
+4) Train a tiny model using **only the final card image pixels**
 """
 
-with gr.Blocks(title="Trading Card Learning (CHR)") as demo:
+with gr.Blocks(title="Trading Card Learning (CHR + Stego)") as demo:
     gr.Markdown(INTRO)
 
     with gr.Tab("1) Ingest"):
@@ -1028,71 +1101,89 @@ with gr.Blocks(title="Trading Card Learning (CHR)") as demo:
         ingest_btn.click(ingest_file, inputs=[file_in, units_mode], outputs=[ingest_status])
         demo_btn.click(load_demo, inputs=[units_mode], outputs=[ingest_status])
 
-    with gr.Tab("2) Compress → Trading Card"):
+    with gr.Tab("2) Compress → Payload"):
         with gr.Row():
             K = gr.Slider(2, 48, value=16, step=1, label="K (constellations)")
-            iters = gr.Slider(5, 120, value=35, step=1, label="CHR iterations")
+            iters = gr.Slider(5, 120, value=30, step=1, label="CHR iterations")
             beta = gr.Slider(2, 30, value=16, step=1, label="beta (assignment sharpness)")
         with gr.Row():
             slab_bins = gr.Slider(3, 16, value=8, step=1, label="slab bins (entropy measure)")
             tau = gr.Slider(1, 20, value=5, step=1, label="tau (slab softness)")
             radial_bins = gr.Slider(8, 256, value=64, step=8, label="radial bins (compression alphabet)")
             seed = gr.Slider(0, 9999, value=42, step=1, label="seed")
-        with gr.Row():
-            card_width = gr.Slider(128, 512, value=256, step=32, label="Card width (pixels)")
-            front_height = gr.Slider(96, 320, value=160, step=16, label="Front (holo) height (pixels)")
-            title_text = gr.Textbox(value="CHR Trading Card", label="Card title")
+        title_text = gr.Textbox(value="CHR Trading Card", label="Card title")
+        compress_btn = gr.Button("Create payload (ready to embed)", variant="primary")
 
-        compress_btn = gr.Button("Generate Trading Card PNG", variant="primary")
         compress_report = gr.Markdown("")
         with gr.Row():
             ent_img = gr.Image(label="Entropy during compression", type="filepath")
             map_img = gr.Image(label="Constellation map (PCA)", type="filepath")
-        with gr.Row():
-            card_img = gr.Image(label="Trading Card PNG (contains the data)", type="filepath")
-            card_tilt = gr.Image(label="Holo tilt (GIF)", type="filepath")
         with gr.Row():
             codes_bin = gr.File(label="codes.bin (audit only)")
             codec_json = gr.File(label="codec.json (audit only)")
-        card_header = gr.Code(label="Trading card header (from pixels)", language="json")
+        payload_info = gr.Code(label="Payload info", language="json")
+        codec_dump = gr.Code(label="Codec (debug)", language="json")
 
         compress_btn.click(
-            compress_and_make_card,
-            inputs=[K, iters, beta, slab_bins, tau, seed, radial_bins, card_width, front_height, title_text],
-            outputs=[compress_report, ent_img, map_img, card_img, card_tilt, codes_bin, codec_json, card_header]
+            compress_and_make_payload,
+            inputs=[K, iters, beta, slab_bins, tau, seed, radial_bins, title_text],
+            outputs=[compress_report, ent_img, map_img, codes_bin, codec_json, payload_info, codec_dump]
+        )
+
+    with gr.Tab("3) Embed on Carrier Trading Card"):
+        gr.Markdown(
+            "Upload a **carrier trading card image** (PNG/JPG). "
+            "We will embed the payload **inside the image pixels** (LSB stego), then add a holo banner for wow."
+        )
+        with gr.Row():
+            carrier_img = gr.File(label="Carrier trading card image (PNG/JPG)", file_types=[".png", ".jpg", ".jpeg"])
+            card_width = gr.Slider(256, 1024, value=512, step=64, label="Card width (bigger = more capacity)")
+        with gr.Row():
+            holo_height = gr.Slider(64, 420, value=180, step=10, label="Hologram banner height")
+            holo_alpha = gr.Slider(0.0, 0.85, value=0.35, step=0.05, label="Holo overlay strength")
+            stego_bits = gr.Radio([1, 2], value=1, label="Stego bits/channel (1=stealth, 2=more capacity)")
+        embed_btn = gr.Button("Embed payload into carrier + generate final PNG", variant="primary")
+
+        embed_report = gr.Markdown("")
+        with gr.Row():
+            final_card = gr.Image(label="Final Trading Card (PNG — contains the data inside pixels)", type="filepath")
+            final_gif = gr.Image(label="Tilt GIF (wow)", type="filepath")
+        header_json = gr.Code(label="Decoded header (from pixels)", language="json")
+        cap_json = gr.Code(label="Capacity check", language="json")
+
+        embed_btn.click(
+            embed_payload_into_carrier,
+            inputs=[carrier_img, card_width, holo_height, holo_alpha, stego_bits, title_text],
+            outputs=[embed_report, final_card, final_gif, header_json, cap_json]
         )
 
-    with gr.Tab("3) Train from Trading Card"):
+    with gr.Tab("4) Train from Final Trading Card"):
+        gr.Markdown("Training extracts bytes from the **final card image pixels** (LSB) and learns on those bytes.")
         with gr.Row():
-            train_steps = gr.Slider(50, 2000, value=250, step=50, label="training steps (fast demo default)")
+            train_steps = gr.Slider(50, 1200, value=180, step=30, label="training steps (fast demo default)")
             batch_size = gr.Slider(4, 128, value=32, step=4, label="batch size")
             block_size = gr.Slider(32, 256, value=128, step=16, label="sequence length (bytes)")
         with gr.Row():
             lr = gr.Number(value=5e-4, label="learning rate")
-            log_every = gr.Slider(10, 200, value=25, step=5, label="log every (steps)")
+            log_every = gr.Slider(10, 200, value=20, step=5, label="log every (steps)")
             temperature = gr.Slider(0.5, 2.0, value=1.0, step=0.05, label="rollout temperature")
             rollout_steps = gr.Slider(40, 400, value=120, step=20, label="rollout steps (bytes)")
-        with gr.Row():
-            make_gif = gr.Checkbox(value=False, label="Generate rollout GIF (adds time)")
-            gif_stride = gr.Slider(1, 12, value=5, step=1, label="GIF stride (higher = faster)")
-            gif_fps = gr.Slider(6, 24, value=12, step=1, label="GIF FPS")
-            gif_max_frames = gr.Slider(12, 120, value=40, step=4, label="GIF max frames (cap)")
 
-        train_btn = gr.Button("Train from PNG pixels + generate visuals", variant="primary")
+        train_btn = gr.Button("Train from final card pixels + generate visuals", variant="primary")
         train_report = gr.Markdown("")
         with gr.Row():
             train_img = gr.Image(label="Loss + perplexity", type="filepath")
             compare_img = gr.Image(label="BEFORE vs AFTER rollout", type="filepath")
-        gif_out = gr.Image(label="Rollout GIF (optional)", type="filepath")
+        with gr.Row():
+            before_img = gr.Image(label="BEFORE rollout track", type="filepath")
+            after_img = gr.Image(label="AFTER rollout track", type="filepath")
         metrics_json = gr.Code(label="Metrics (JSON)", language="json")
 
         train_btn.click(
-            train_from_card,
-            inputs=[train_steps, batch_size, block_size, lr, log_every, temperature, rollout_steps,
-                    make_gif, gif_stride, gif_fps, gif_max_frames],
-            outputs=[train_report, train_img, compare_img, gif_out, metrics_json]
+            train_from_final_card,
+            inputs=[train_steps, batch_size, block_size, lr, log_every, temperature, rollout_steps],
+            outputs=[train_report, train_img, compare_img, before_img, after_img, metrics_json]
         )
 
 if __name__ == "__main__":
-    # Disable SSR for stability / fewer asyncio warnings in Spaces
     demo.launch(ssr_mode=False)