Demo: native pipe.upsample_prompt + spaces.aoti_blocks_load (overlapped) + timing

app.py

@@ -3,229 +3,111 @@ import sys
 
 os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 
-# Use the bundled diffusers source (PR #2: huggingface/diffusers-new-model-addition-ideogram).
+# Bundled diffusers source: PR branch `ideogram4-prompt-enhancement` (YiYi's refactor + native upsampling).
 _HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, os.path.join(_HERE, "diffusers_src", "src"))
 
 import json
 import random
-from typing import List, Literal, Union
+import time
+from threading import Thread
 
+import gradio as gr
 import spaces
 import torch
-import torch.nn as nn
-import gradio as gr
-from pydantic import BaseModel, Field
-from accelerate import init_empty_weights
 from huggingface_hub import hf_hub_download
-from safetensors.torch import load_file
+
 from diffusers import Ideogram4Pipeline
-from transformers import AutoProcessor, Qwen3VLForConditionalGeneration
 
-# --- New (safety-fixed) checkpoint ---
 MODEL_ID = "diffusers-internal-dev/ideogram-4-nf4-v2"
-# Just the LM head, grafted onto the pipeline's own Qwen3-VL encoder to make it generative.
 LM_HEAD_REPO = "multimodalart/qwen3-vl-8b-instruct-lm-head"
-TOKENIZER_ID = "Qwen/Qwen3-VL-8B-Instruct"  # processor/tokenizer only (no weights)
-# Precompiled (weight-less, dynamic L=16·k) AOTI package for one Ideogram4TransformerBlock.
-# Applied to all 68 block instances across both transformers; ~1.28x on 1024 turbo.
 AOTI_REPO = "multimodalart/i4-block-aoti"
-
+AOTI_BLOCK_FILE = "Ideogram4TransformerBlock/package.pt2"
 MAX_SEED = 2**31 - 1
 
-# --- Sampler modes (V4 presets, forward step-order: main CFG 7.0 -> polish 3.0) ---
+# V4 presets (forward step-order: main CFG 7.0 -> polish 3.0).
 MODES = {
     "Turbo · 12 steps": dict(num_inference_steps=12, guidance_schedule=(7.0,) * 11 + (3.0,) * 1, mu=0.5, std=1.75),
     "Default · 20 steps": dict(num_inference_steps=20, guidance_schedule=(7.0,) * 18 + (3.0,) * 2, mu=0.0, std=1.75),
     "Quality · 48 steps": dict(num_inference_steps=48, guidance_schedule=(7.0,) * 45 + (3.0,) * 3, mu=0.0, std=1.5),
 }
 
-# --- Pipeline ---
+# --- Pipeline: dequantize both transformers nf4 -> bf16 in the parent (CPU) so every ZeroGPU fork inherits
+# bf16 and AOTI can bind its weight-less graph to real weights. ---
+t = time.perf_counter()
 pipe = Ideogram4Pipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
-# Dequantize nf4 -> bf16 in the PARENT (CPU) context, BEFORE ZeroGPU forks/packs the model, so every
-# fork inherits bf16 (a fork-local dequant doesn't persist). bitsandbytes supports CPU 4-bit dequant.
-# This also gives AOTI real bf16 weights to bind to its (weight-less) compiled graph.
 pipe.transformer.dequantize()
 pipe.unconditional_transformer.dequantize()
 pipe.to("cuda")
+print(f"[timing] pipeline load + dequant: {time.perf_counter() - t:.1f}s", flush=True)
 
-# --- Upsampler tokenizer + pre-fetched LM head (graft done lazily on GPU) ---
-upsampler_proc = AutoProcessor.from_pretrained(TOKENIZER_ID)
-LM_HEAD_PATH = hf_hub_download(LM_HEAD_REPO, "lm_head.safetensors")  # cached at startup
-
+# --- Native prompt enhancer (grafts the hosted LM head + builds the Outlines processor) at startup. ---
 try:
-    import outlines
-    OUTLINES_AVAILABLE = True
-except Exception:
-    OUTLINES_AVAILABLE = False
+    t = time.perf_counter()
+    pipe.load_prompt_enhancer(lm_head_repo_id=LM_HEAD_REPO)
+    pipe._caption_model.lm_head.to("cuda")  # ZeroGPU-deferred move of just the grafted head
+    ENHANCER_OK = True
+    print(f"[timing] load_prompt_enhancer: {time.perf_counter() - t:.1f}s", flush=True)
+except Exception as e:
+    ENHANCER_OK = False
+    print(f"[enhancer] disabled: {e!r}", flush=True)
 
-# Pre-fetch the AOTI package at startup (CPU/parent); the actual .so bind happens on-GPU (per worker).
+# Pre-fetch the AOTI package at startup so the in-worker patch is cache-only.
 try:
-    from huggingface_hub import snapshot_download
-    AOTI_DIR = snapshot_download(AOTI_REPO, repo_type="model")
+    hf_hub_download(AOTI_REPO, AOTI_BLOCK_FILE)
+    AOTI_OK = True
 except Exception as e:
-    print(f"[aoti] package fetch failed, running eager: {e!r}", flush=True)
-    AOTI_DIR = None
+    AOTI_OK = False
+    print(f"[aoti] prefetch failed, running eager: {e!r}", flush=True)
 
-# Each ZeroGPU worker re-forks from the parent and must bind the compiled .so itself; guard so it
-# happens exactly once per process.
 _AOTI_APPLIED = False
 
 
 def _apply_aoti():
-    """Bind the precompiled block to both transformers (once per GPU worker). Must run inside @spaces.GPU."""
+    """Patch the compiled block onto every Ideogram4TransformerBlock of both transformers (once per worker).
+
+    `aoti_blocks_load` is lazy (binds forward, defers the .so to first diffusion step) and CPU-only, so this is
+    safe to run in a background thread overlapping the (transformer-idle) upsampling step."""
     global _AOTI_APPLIED
-    if _AOTI_APPLIED or AOTI_DIR is None:
+    if _AOTI_APPLIED or not AOTI_OK:
         return
     try:
-        spaces.aoti_load_from_package_dir(pipe.transformer, AOTI_DIR)
-        spaces.aoti_load_from_package_dir(pipe.unconditional_transformer, AOTI_DIR)
+        t = time.perf_counter()
+        spaces.aoti_blocks_load(pipe.transformer, AOTI_REPO)
+        spaces.aoti_blocks_load(pipe.unconditional_transformer, AOTI_REPO)
         _AOTI_APPLIED = True
-        print("[aoti] compiled block applied to both transformers", flush=True)
-    except Exception as e:  # never let a compile-bind hiccup block generation — fall back to eager
+        print(f"[timing] aoti_blocks_load (both transformers): {time.perf_counter() - t:.2f}s", flush=True)
+    except Exception as e:  # never let a bind hiccup block generation
         print(f"[aoti] apply failed, running eager: {e!r}", flush=True)
 
 
-# --- Caption schema (matches Ideogram's native caption / caption_verifier) ---
-class ObjElement(BaseModel):
-    type: Literal["obj"]
-    desc: str
-
-
-class TextElement(BaseModel):
-    type: Literal["text"]
-    text: str
-    desc: str
-
-
-class Composition(BaseModel):
-    background: str
-    elements: List[Union[ObjElement, TextElement]] = Field(min_length=1)
-
-
-class Caption(BaseModel):
-    high_level_description: str
-    compositional_deconstruction: Composition
-
-
-def _load_sections(path):
-    sections, cur, buf = {}, None, []
-    for line in open(path, encoding="utf-8").read().splitlines():
-        s = line.strip()
-        if s.startswith("[") and s.endswith("]") and " " not in s:
-            if cur is not None:
-                sections[cur] = "\n".join(buf).strip()
-            cur, buf = s[1:-1].lower(), []
-        else:
-            buf.append(line)
-    if cur is not None:
-        sections[cur] = "\n".join(buf).strip()
-    return sections
-
-
-_SEC = _load_sections(os.path.join(_HERE, "v6.txt"))
-SYSTEM_PROMPT = _SEC["system"]
-USER_TEMPLATE = _SEC.get("user", "User idea: {{original_prompt}}")
-
-
-def _build_enhancer():
-    """Graft the hosted lm_head onto pipe.text_encoder -> a generative model (no second body).
-    Done ONCE at import time so nothing heavy happens on the first GPU request. Only the new
-    bf16 lm_head is `.to('cuda')` (ZeroGPU defers it); the shared nf4 body is already moved by `pipe`."""
-    head = load_file(LM_HEAD_PATH)["lm_head.weight"]  # [vocab, hidden] bf16
-    with init_empty_weights():
-        gen = Qwen3VLForConditionalGeneration(pipe.text_encoder.config)
-    gen.model = pipe.text_encoder  # reuse the loaded (nf4) encoder body — no extra body in VRAM
-    lm = nn.Linear(head.shape[1], head.shape[0], bias=False)
-    with torch.no_grad():
-        lm.weight.copy_(head.to(torch.bfloat16))
-    gen.lm_head = lm.to(torch.bfloat16)
-    gen.lm_head.to("cuda")  # ZeroGPU-deferred move of just the head
-    gen.eval()
-    lp = None
-    if OUTLINES_AVAILABLE:
-        ol_model = outlines.from_transformers(gen, upsampler_proc.tokenizer)
-        lp = outlines.Generator(ol_model, Caption).logits_processor  # compiles schema->FSM now
-    return gen, lp
-
-
-# Assemble the generative enhancer + structural constraint at STARTUP (not on first request).
-try:
-    ENHANCER, LOGITS_PROCESSOR = _build_enhancer()
-except Exception as e:  # don't let a graft hiccup block the demo / the bf16 OOM test
-    print(f"[enhancer] graft failed, prompt upsampling disabled: {e!r}")
-    ENHANCER, LOGITS_PROCESSOR = None, None
-
-
-def upsample_prompt(prompt: str, width: int, height: int, progress=None) -> str:
-    from math import gcd
-    from threading import Thread
-    from transformers import TextIteratorStreamer
-
-    gen = ENHANCER
-    d = gcd(width, height) or 1
-    aspect_ratio = f"{width // d}:{height // d}"
-    user = USER_TEMPLATE.replace("{{aspect_ratio}}", aspect_ratio).replace("{{original_prompt}}", prompt)
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": user}]
-    inputs = upsampler_proc.apply_chat_template(
-        messages, add_generation_prompt=True, tokenize=True, return_tensors="pt", return_dict=True
-    ).to(gen.device)
-    max_new = 1024
-    gen_kwargs = dict(max_new_tokens=max_new, do_sample=True, temperature=1.0, use_cache=True)
-    if LOGITS_PROCESSOR is not None:
-        LOGITS_PROCESSOR.reset()
-        gen_kwargs["logits_processor"] = [LOGITS_PROCESSOR]
-
-    if progress is None:  # warmup path, no UI
-        out = gen.generate(**inputs, **gen_kwargs)
-        return upsampler_proc.batch_decode(out[:, inputs["input_ids"].shape[1]:], skip_special_tokens=True)[0].strip()
-
-    # stream tokens so the UI shows the upsampler working
-    streamer = TextIteratorStreamer(upsampler_proc.tokenizer, skip_prompt=True, skip_special_tokens=True)
-    gen_kwargs["streamer"] = streamer
-    thread = Thread(target=gen.generate, kwargs={**inputs, **gen_kwargs})
-    thread.start()
-    text, n = "", 0
-    for chunk in streamer:
-        text += chunk
-        n += 1
-        progress(min(n / max_new, 0.99), desc="✍️ Upsampling prompt…")
-    thread.join()
-    return text.strip()
-
-
 @spaces.GPU(duration=240, size="xlarge")
-def generate(
-    prompt: str,
-    mode: str,
-    enhance: bool,
-    width: int,
-    height: int,
-    seed: int,
-    randomize_seed: bool,
-    progress=gr.Progress(track_tqdm=True),
-):
+def generate(prompt, mode, enhance, width, height, seed, randomize_seed, progress=gr.Progress(track_tqdm=True)):
+    t_enter = time.perf_counter()
     if randomize_seed or seed < 0:
         seed = random.randint(0, MAX_SEED)
 
-    _apply_aoti()  # bind compiled blocks on this worker (no-op after first call)
+    # Overlap the AOTI block-patch with upsampling: the transformer is idle while the text encoder runs.
+    aoti_thread = Thread(target=_apply_aoti, daemon=True)
+    aoti_thread.start()
 
     final_prompt = prompt
-    if enhance:
-        if not OUTLINES_AVAILABLE:
-            gr.Warning("`outlines` is not installed — upsampling without structural constraints.")
-        final_prompt = upsample_prompt(prompt, int(width), int(height), progress=progress)
+    if enhance and ENHANCER_OK:
+        progress(0.0, desc="✍️ Upsampling prompt…")
+        t = time.perf_counter()
+        final_prompt = pipe.upsample_prompt(prompt, height=int(height), width=int(width))[0]
+        print(f"[timing] upsample: {time.perf_counter() - t:.2f}s", flush=True)
+
+    aoti_thread.join()  # ensure blocks are patched before the diffusion loop
+    print(f"[timing] pre-diffusion (enter -> ready): {time.perf_counter() - t_enter:.2f}s", flush=True)
 
     progress(0.0, desc="🎨 Generating image…")
     generator = torch.Generator(device="cuda").manual_seed(int(seed))
     preset = MODES.get(mode, MODES["Default · 20 steps"])
-    image = pipe(
-        prompt=final_prompt,
-        width=int(width),
-        height=int(height),
-        generator=generator,
-        **preset,
-    ).images[0]
+    t = time.perf_counter()
+    image = pipe(prompt=final_prompt, width=int(width), height=int(height), generator=generator, **preset).images[0]
+    print(f"[timing] diffusion ({mode}): {time.perf_counter() - t:.2f}s", flush=True)
+
     try:
         caption = json.loads(final_prompt)
     except Exception:
@@ -235,50 +117,40 @@ def generate(
 
 @spaces.GPU(size="xlarge")
 def _warmup():
-    """Preload the upsampler onto GPU and warm it at STARTUP (graft move + Outlines FSM + first-token JIT).
-    NOTE: runtime nf4->bf16 dequant is intentionally NOT done here — it does not persist across ZeroGPU
-    forks (each request re-forks from the nf4 parent process), so bf16+speed will come from a precompiled
-    AOTI artifact instead."""
-    _apply_aoti()  # bind compiled blocks + trigger the lazy per-worker .so load
-    if ENHANCER is not None:
-        upsample_prompt("a red apple on a wooden table", 1024, 1024)
-        print("[warmup] upsampler ready on GPU", flush=True)
+    """Pay the AOTI patch + warm the upsampler on the startup worker (upsample only, no diffusion)."""
+    _apply_aoti()
+    if ENHANCER_OK:
+        t = time.perf_counter()
+        pipe.upsample_prompt("a red apple on a wooden table", height=1024, width=1024)
+        print(f"[timing] warmup upsample: {time.perf_counter() - t:.2f}s", flush=True)
 
 
 try:
     _warmup()
-except Exception as e:  # a flaky ZeroGPU worker (e.g. ECC) must not take down the Space
+except Exception as e:  # a flaky ZeroGPU worker must not take down the Space
     print(f"[warmup] failed (will warm lazily on first request): {e!r}", flush=True)
 
 
 with gr.Blocks(theme=gr.themes.Citrus(), title="Ideogram 4 (NF4) — diffusers preview") as demo:
     gr.Markdown(
         "## Ideogram 4 (NF4) — diffusers preview\n"
-        f"Private demo of [`{MODEL_ID}`](https://huggingface.co/{MODEL_ID}) using the "
+        f"Private demo of [`{MODEL_ID}`](https://huggingface.co/{MODEL_ID}) on the "
         "[diffusers PR](https://github.com/huggingface/diffusers-new-model-addition-ideogram) branch, on ZeroGPU.\n"
-        "Toggle **Prompt upsampling** in Advanced to rewrite your idea into Ideogram's native structured caption "
-        "(the pipeline's own Qwen3-VL encoder + a grafted LM head + Outlines)."
+        "**Prompt upsampling** rewrites your idea into Ideogram's native structured JSON caption "
+        "(the pipeline's own Qwen3-VL encoder + a grafted LM head + Outlines) via the native "
+        "`pipe.upsample_prompt`."
     )
 
     with gr.Row():
         with gr.Column():
-            prompt = gr.Textbox(
-                label="Prompt",
-                value="A photo of a cat holding a sign that says hello world",
-                lines=3,
-            )
-            mode = gr.Radio(
-                choices=list(MODES.keys()),
-                value="Default · 20 steps",
-                label="Mode (speed ↔ quality)",
-            )
+            prompt = gr.Textbox(label="Prompt", value="A photo of a cat holding a sign that says hello world", lines=3)
+            mode = gr.Radio(choices=list(MODES.keys()), value="Default · 20 steps", label="Mode (speed ↔ quality)")
             run = gr.Button("Generate", variant="primary")
             with gr.Accordion("Advanced", open=False):
                 enhance = gr.Checkbox(
-                    label="Prompt upsampling (Outlines)",
+                    label="Prompt upsampling",
                     value=True,
-                    info="Rewrite the prompt into Ideogram's native JSON caption before generating."
-                    + ("" if OUTLINES_AVAILABLE else "  ⚠ outlines not installed — runs unconstrained."),
+                    info="Rewrite the prompt into Ideogram's native JSON caption before generating.",
                 )
                 with gr.Row():
                     width = gr.Slider(512, 2048, value=1024, step=64, label="Width")

requirements.txt

@@ -1,7 +1,7 @@
-transformers
+transformers>=5.8
+peft>=0.19
 accelerate
 bitsandbytes
 sentencepiece
 outlines
 pydantic>=2
-torchvision

v6.txt

@@ -1,55 +0,0 @@
-[META]
-frozen: false
-description: v6 — v1's medium-flexible spirit, retuned for Qwen3-VL-8B with v2-v5 learnings (anti-transparent, anti subject-drop, density, valid JSON). Example-driven, open to any subject/medium.
-
-[SYSTEM]
-You convert a short user idea into a structured JSON caption for an image renderer. Output ONE minified single-line JSON object and NOTHING else (no markdown, no commentary).
-
-SCHEMA — keys in this exact order:
-{"high_level_description":"...","compositional_deconstruction":{"background":"...","elements":[ ... ]}}
-- object element: {"type":"obj","desc":"..."}
-- text element:   {"type":"text","text":"VERBATIM CHARS","desc":"..."}
-
-STEP 1 — PICK THE MEDIUM. It decides what `background` and `elements` mean. Honor any medium or style the user implies; default to photograph only when nothing else fits. Render ANY subject faithfully — real, fantastical, sci-fi, surreal, abstract — in the chosen medium.
-
-A) DESIGNED ARTIFACT — poster, logo, album/book cover, flyer, banner, sticker, packaging, app icon, infographic, menu, card, wordmark. THE FRAME IS THE ARTIFACT — never a photo of it hanging in a room.
-   - high_level_description: name it as graphic design (e.g. "a minimalist jazz poster, flat graphic design...").
-   - background: the design's OWN backdrop only — a flat color, gradient, or simple texture filling the frame. No room, wall, floor, easel, depth, or camera/photo language.
-   - elements: the design's parts as a flat 2D layout — a `text` element for every headline/label (verbatim), `obj` elements for the central graphic/illustration/shapes/badges. Place by region (top / center / bottom).
-
-B) SCENE — a photograph, illustration, painting, 3D render, anime frame, etc. of a real or imagined place or subject.
-   - high_level_description: one sentence naming the subject and the medium/style.
-   - background: the scene SHELL — surroundings, ground/sky/walls, atmosphere, ambient light; concrete and specific. The ground/floor/water surface lives here, never as an element.
-   - elements: the main subject FIRST as an `obj`, then supporting `obj` elements (props, secondary subjects) that plausibly belong. Add `text` elements only where the scene would really carry text (signs, labels, brands).
-
-C) ABSTRACT / CONCEPTUAL — "nostalgia", "chaos and order", "sound waves", pure pattern. Concretize the idea into a deliberate visual composition.
-   - background: the dominant color field, gradient, or texture of the composition.
-   - elements: the shapes, forms, motifs, or symbolic objects that carry the concept, as `obj` elements. Add `text` only if the idea calls for words.
-
-UNIVERSAL RULES (every medium):
-1. The user's core subject/concept MUST appear among the elements (as an `obj`, normally first). Naming it only in high_level_description or background is NOT enough.
-2. Commit to ONE concrete value each (one color, one style, one count). No hedging: ban "various", "such as", "e.g.", "or similar", "maybe", "X or Y" for one property.
-3. NEVER use a transparent, empty, or plain white background UNLESS the user explicitly says "transparent", "isolated", "sticker", or "cutout".
-4. A coherent subject (one animal, person, vehicle, object) is exactly ONE element; its parts go inside its `desc`. Use separate elements for genuinely separate subjects.
-5. Each `desc` is 25-55 words, identity-first, standalone. Do not mention shadows, depth of field, bokeh, lens, focus, or grain.
-6. high_level_description: one sentence, at most 40 words, starts with the subject, names the medium. Preserve non-ASCII characters as-is.
-7. Output STRICTLY VALID JSON: double quotes around every key and string, NO trailing commas, each element object closes with "}" right after its last value.
-8. Catch the "warm" impulse. Only when you are about to describe light as "warm", "golden", "amber", or "honey", stop and check: is there a specific physical source in the scene casting that colour (candle, sunset, lamp, neon, fire)? If YES, name the source and the colour it casts instead of the mood word. If NO, you are just reaching for warmth as ambience — drop it and leave the light neutral ("soft" or "even"). Don't recolour or relight anything else; this only intercepts the warm reach, every other scene and mood the user wants is untouched.
-9. Describe physical reality, not impressions. Avoid mood-words — "luminous", "radiant", "vibrant", "lush", "dynamic", "gorgeous", "stunning", "breathtaking", "mesmerizing", and metaphorical "glowing" — they produce a generic AI look (the same trap as "warm"). Use observable properties: "the cheekbone catches a small highlight", not "luminous complexion".
-10. Every named thing must appear as its own element. Each subject, object, sign, and quoted phrase the user names gets its own element — quoted text (single or double quotes) becomes its own verbatim `text` element. Count the named units in the prompt; the element list must hold at least that many. Don't drop or merge them.
-11. Don't add what wasn't asked for. No glitch art, wireframe overlay, body fragmentation, double-exposure, "dissolving", or extra stylization unless the prompt requests it. Asked for a cinematic photo of a journalist → render that, not a glitch-art composite.
-12. Name attributes concretely, anchored to landmarks. People: skin tone, hair (colour + style), each visible garment with colour, expression, pose, one distinguishing feature. Objects: shape, material, colour, a distinctive part. Place things against named references — "resting on the lower-right corner of the table", not "on the surface".
-13. Name real references by name. If the user names a brand, product, character, place, or person (Nike Dunk Low, Spider-Man, the Eiffel Tower), keep that exact name in the `desc`; don't swap it for a generic look-alike unless they ask for an anonymous one.
-14. "Professional photo/headshot" of a person means professional CONTEXT — neutral attire, soft even daylight, neutral backdrop, friendly expression — not dramatic studio gear; no heavy rim-light or creamy bokeh unless asked.
-
-EXAMPLES
-
-User idea: a cup of coffee on a table
-Output: {"high_level_description":"A white ceramic cup of black coffee on a worn wooden cafe table, a casual overcast-daylight phone photograph with an off-center composition.","compositional_deconstruction":{"background":"Scratched oak cafe table filling the lower frame, a pale grey mortar-lined brick wall a few feet behind slightly out of focus, a tall window on the left spilling soft overcast daylight across the table, neutral white balance, muted brown and green tones.","elements":[{"type":"obj","desc":"White ceramic cup of black coffee with a thin curved handle turned to the right and a faint crema ring at the rim, resting on a matching round saucer near the center of the table, a thin wisp of steam at the surface."},{"type":"obj","desc":"Brushed-steel teaspoon lying on the saucer to the right of the cup, handle angled toward the lower-right corner, a single small water droplet on the bowl of the spoon."}]}}
-
-User idea: a minimalist poster for a jazz festival
-Output: {"high_level_description":"A minimalist jazz festival poster, flat graphic design with bold typography and a single abstract saxophone motif on a deep teal background.","compositional_deconstruction":{"background":"Solid deep teal background filling the entire frame with a subtle fine paper-grain texture and a thin mustard-yellow keyline border just inside the edges, no scene and no depth.","elements":[{"type":"obj","desc":"A large flat geometric saxophone in mustard yellow and cream, centered in the upper two-thirds, built from simple bold shapes with no shading, angled diagonally from lower-left to upper-right."},{"type":"text","text":"JAZZ\nFESTIVAL","desc":"Large bold condensed sans-serif headline in cream, stacked on two lines across the center of the poster, slightly overlapping the saxophone motif."},{"type":"text","text":"NOV 15 · CITY HALL","desc":"Small uppercase mustard-yellow caption centered near the bottom edge with wide letter spacing."}]}}
-
-[USER]
-TARGET IMAGE ASPECT RATIO: {{aspect_ratio}} (width:height).
-User idea: {{original_prompt}}