Upload folder using huggingface_hub

.claude/skills/huggingface-gradio/SKILL.md

@@ -0,0 +1,298 @@
+---
+name: huggingface-gradio
+description: Build Gradio web UIs and demos in Python. Use when creating or editing Gradio apps, components, event listeners, layouts, or chatbots.
+---
+
+# Gradio
+
+Gradio is a Python library for building interactive web UIs and ML demos. This skill covers the core API, patterns, and examples.
+
+## Guides
+
+Detailed guides on specific topics (read these when relevant):
+
+- [Quickstart](https://www.gradio.app/guides/quickstart)
+- [The Interface Class](https://www.gradio.app/guides/the-interface-class)
+- [Blocks and Event Listeners](https://www.gradio.app/guides/blocks-and-event-listeners)
+- [Controlling Layout](https://www.gradio.app/guides/controlling-layout)
+- [More Blocks Features](https://www.gradio.app/guides/more-blocks-features)
+- [Custom CSS and JS](https://www.gradio.app/guides/custom-CSS-and-JS)
+- [Streaming Outputs](https://www.gradio.app/guides/streaming-outputs)
+- [Streaming Inputs](https://www.gradio.app/guides/streaming-inputs)
+- [Sharing Your App](https://www.gradio.app/guides/sharing-your-app)
+- [Custom HTML Components](https://www.gradio.app/guides/custom-HTML-components)
+- [Getting Started with the Python Client](https://www.gradio.app/guides/getting-started-with-the-python-client)
+- [Getting Started with the JS Client](https://www.gradio.app/guides/getting-started-with-the-js-client)
+
+## Core Patterns
+
+**Interface** (high-level): wraps a function with input/output components.
+
+```python
+import gradio as gr
+
+def greet(name):
+    return f"Hello {name}!"
+
+gr.Interface(fn=greet, inputs="text", outputs="text").launch()
+```
+
+**Blocks** (low-level): flexible layout with explicit event wiring.
+
+```python
+import gradio as gr
+
+with gr.Blocks() as demo:
+    name = gr.Textbox(label="Name")
+    output = gr.Textbox(label="Greeting")
+    btn = gr.Button("Greet")
+    btn.click(fn=lambda n: f"Hello {n}!", inputs=name, outputs=output)
+
+demo.launch()
+```
+
+**ChatInterface**: high-level wrapper for chatbot UIs.
+
+```python
+import gradio as gr
+
+def respond(message, history):
+    return f"You said: {message}"
+
+gr.ChatInterface(fn=respond).launch()
+```
+
+## Key Component Signatures
+
+### `Textbox(value: str | I18nData | Callable | None = None, type: Literal['text', 'password', 'email'] = "text", lines: int = 1, max_lines: int | None = None, placeholder: str | I18nData | None = None, label: str | I18nData | None = None, info: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, autofocus: bool = False, autoscroll: bool = True, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", text_align: Literal['left', 'right'] | None = None, rtl: bool = False, buttons: list[Literal['copy'] | Button] | None = None, max_length: int | None = None, submit_btn: str | bool | None = False, stop_btn: str | bool | None = False, html_attributes: InputHTMLAttributes | None = None)`
+Creates a textarea for user to enter string input or display string output..
+
+### `Number(value: float | Callable | None = None, label: str | I18nData | None = None, placeholder: str | I18nData | None = None, info: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", buttons: list[Button] | None = None, precision: int | None = None, minimum: float | None = None, maximum: float | None = None, step: float = 1)`
+Creates a numeric field for user to enter numbers as input or display numeric output..
+
+### `Slider(minimum: float = 0, maximum: float = 100, value: float | Callable | None = None, step: float | None = None, precision: int | None = None, label: str | I18nData | None = None, info: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", randomize: bool = False, buttons: list[Literal['reset']] | None = None)`
+Creates a slider that ranges from {minimum} to {maximum} with a step size of {step}..
+
+### `Checkbox(value: bool | Callable = False, label: str | I18nData | None = None, info: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", buttons: list[Button] | None = None)`
+Creates a checkbox that can be set to `True` or `False`.
+
+### `Dropdown(choices: Sequence[str | int | float | tuple[str, str | int | float]] | None = None, value: str | int | float | Sequence[str | int | float] | Callable | DefaultValue | None = DefaultValue(), type: Literal['value', 'index'] = "value", multiselect: bool | None = None, allow_custom_value: bool = False, max_choices: int | None = None, filterable: bool = True, label: str | I18nData | None = None, info: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", buttons: list[Button] | None = None)`
+Creates a dropdown of choices from which a single entry or multiple entries can be selected (as an input component) or displayed (as an output component)..
+
+### `Radio(choices: Sequence[str | int | float | tuple[str, str | int | float]] | None = None, value: str | int | float | Callable | None = None, type: Literal['value', 'index'] = "value", label: str | I18nData | None = None, info: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", rtl: bool = False, buttons: list[Button] | None = None)`
+Creates a set of (string or numeric type) radio buttons of which only one can be selected..
+
+### `Image(value: str | PIL.Image.Image | np.ndarray | Callable | None = None, format: str = "webp", height: int | str | None = None, width: int | str | None = None, image_mode: Literal['1', 'L', 'P', 'RGB', 'RGBA', 'CMYK', 'YCbCr', 'LAB', 'HSV', 'I', 'F'] | None = "RGB", sources: list[Literal['upload', 'webcam', 'clipboard']] | Literal['upload', 'webcam', 'clipboard'] | None = None, type: Literal['numpy', 'pil', 'filepath'] = "numpy", label: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, buttons: list[Literal['download', 'share', 'fullscreen'] | Button] | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, streaming: bool = False, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", webcam_options: WebcamOptions | None = None, placeholder: str | None = None, watermark: WatermarkOptions | None = None)`
+Creates an image component that can be used to upload images (as an input) or display images (as an output)..
+
+### `Audio(value: str | Path | tuple[int, np.ndarray] | Callable | None = None, sources: list[Literal['upload', 'microphone']] | Literal['upload', 'microphone'] | None = None, type: Literal['numpy', 'filepath'] = "numpy", label: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, streaming: bool = False, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", format: Literal['wav', 'mp3'] | None = None, autoplay: bool = False, editable: bool = True, buttons: list[Literal['download', 'share'] | Button] | None = None, waveform_options: WaveformOptions | dict | None = None, loop: bool = False, recording: bool = False, subtitles: str | Path | list[dict[str, Any]] | None = None, playback_position: float = 0)`
+Creates an audio component that can be used to upload/record audio (as an input) or display audio (as an output)..
+
+### `Video(value: str | Path | Callable | None = None, format: str | None = None, sources: list[Literal['upload', 'webcam']] | Literal['upload', 'webcam'] | None = None, height: int | str | None = None, width: int | str | None = None, label: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", webcam_options: WebcamOptions | None = None, include_audio: bool | None = None, autoplay: bool = False, buttons: list[Literal['download', 'share'] | Button] | None = None, loop: bool = False, streaming: bool = False, watermark: WatermarkOptions | None = None, subtitles: str | Path | list[dict[str, Any]] | None = None, playback_position: float = 0)`
+Creates a video component that can be used to upload/record videos (as an input) or display videos (as an output).
+
+### `File(value: str | list[str] | Callable | None = None, file_count: Literal['single', 'multiple', 'directory'] = "single", file_types: list[str] | None = None, type: Literal['filepath', 'binary'] = "filepath", label: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, height: int | str | float | None = None, interactive: bool | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", allow_reordering: bool = False, buttons: list[Button] | None = None)`
+Creates a file component that allows uploading one or more generic files (when used as an input) or displaying generic files or URLs for download (as output).
+
+### `Chatbot(value: list[MessageDict | Message] | Callable | None = None, label: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, container: bool = True, scale: int | None = None, min_width: int = 160, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, autoscroll: bool = True, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", height: int | str | None = 400, resizable: bool = False, max_height: int | str | None = None, min_height: int | str | None = None, editable: Literal['user', 'all'] | None = None, latex_delimiters: list[dict[str, str | bool]] | None = None, rtl: bool = False, buttons: list[Literal['share', 'copy', 'copy_all'] | Button] | None = None, watermark: str | None = None, avatar_images: tuple[str | Path | None, str | Path | None] | None = None, sanitize_html: bool = True, render_markdown: bool = True, feedback_options: list[str] | tuple[str, ...] | None = ('Like', 'Dislike'), feedback_value: Sequence[str | None] | None = None, line_breaks: bool = True, layout: Literal['panel', 'bubble'] | None = None, placeholder: str | None = None, examples: list[ExampleMessage] | None = None, allow_file_downloads: <class 'inspect._empty'> = True, group_consecutive_messages: bool = True, allow_tags: list[str] | bool = True, reasoning_tags: list[tuple[str, str]] | None = None, like_user_message: bool = False)`
+Creates a chatbot that displays user-submitted messages and responses.
+
+### `Button(value: str | I18nData | Callable = "Run", every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, variant: Literal['primary', 'secondary', 'stop', 'huggingface'] = "secondary", size: Literal['sm', 'md', 'lg'] = "lg", icon: str | Path | None = None, link: str | None = None, link_target: Literal['_self', '_blank', '_parent', '_top'] = "_self", visible: bool | Literal['hidden'] = True, interactive: bool = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", scale: int | None = None, min_width: int | None = None)`
+Creates a button that can be assigned arbitrary .click() events.
+
+### `Markdown(value: str | I18nData | Callable | None = None, label: str | I18nData | None = None, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool | None = None, rtl: bool = False, latex_delimiters: list[dict[str, str | bool]] | None = None, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", sanitize_html: bool = True, line_breaks: bool = False, header_links: bool = False, height: int | str | None = None, max_height: int | str | None = None, min_height: int | str | None = None, buttons: list[Literal['copy']] | None = None, container: bool = False, padding: bool = False)`
+Used to render arbitrary Markdown output.
+
+### `HTML(value: Any | Callable | None = None, label: str | I18nData | None = None, html_template: str = "${value}", css_template: str = "", js_on_load: str | None = "element.addEventListener('click', function() { trigger('click') });", apply_default_css: bool = True, every: Timer | float | None = None, inputs: Component | Sequence[Component] | set[Component] | None = None, show_label: bool = False, visible: bool | Literal['hidden'] = True, elem_id: str | None = None, elem_classes: list[str] | str | None = None, render: bool = True, key: int | str | tuple[int | str, ...] | None = None, preserved_by_key: list[str] | str | None = "value", min_height: int | None = None, max_height: int | None = None, container: bool = False, padding: bool = False, autoscroll: bool = False, buttons: list[Button] | None = None, server_functions: list[Callable] | None = None, props: Any)`
+Creates a component with arbitrary HTML.
+
+
+## Custom HTML Components
+
+If a task requires significant customization of an existing component or a component that doesn't exist in Gradio, you can create one with `gr.HTML`. It supports `html_template` (with `${}` JS expressions and `{{}}` Handlebars syntax), `css_template` for scoped styles, and `js_on_load` for interactivity — where `props.value` updates the component value and `trigger('event_name')` fires Gradio events. For reuse, subclass `gr.HTML` and define `api_info()` for API/MCP support. See the [full guide](https://www.gradio.app/guides/custom-HTML-components).
+
+Here's an example that shows how to create and use these kinds of components:
+
+```python
+import gradio as gr
+
+class StarRating(gr.HTML):
+    def __init__(self, label, value=0, **kwargs):
+        html_template = """
+        <h2>${label} rating:</h2>
+        ${Array.from({length: 5}, (_, i) => `<img class='${i < value ? '' : 'faded'}' src='https://upload.wikimedia.org/wikipedia/commons/d/df/Award-star-gold-3d.svg'>`).join('')}
+        """
+        css_template = """
+            img { height: 50px; display: inline-block; cursor: pointer; }
+            .faded { filter: grayscale(100%); opacity: 0.3; }
+        """
+        js_on_load = """
+            const imgs = element.querySelectorAll('img');
+            imgs.forEach((img, index) => {
+                img.addEventListener('click', () => {
+                    props.value = index + 1;
+                });
+            });
+        """
+        super().__init__(value=value, label=label, html_template=html_template, css_template=css_template, js_on_load=js_on_load, **kwargs)
+
+    def api_info(self):
+        return {"type": "integer", "minimum": 0, "maximum": 5}
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Restaurant Review")
+    food_rating = StarRating(label="Food", value=3)
+    service_rating = StarRating(label="Service", value=3)
+    ambience_rating = StarRating(label="Ambience", value=3)
+    average_btn = gr.Button("Calculate Average Rating")
+    rating_output = StarRating(label="Average", value=3)
+    def calculate_average(food, service, ambience):
+        return round((food + service + ambience) / 3)
+    average_btn.click(
+        fn=calculate_average,
+        inputs=[food_rating, service_rating, ambience_rating],
+        outputs=rating_output
+    )
+
+demo.launch()
+```
+
+## Event Listeners
+
+All event listeners share the same signature:
+
+```python
+component.event_name(
+    fn: Callable | None | Literal["decorator"] = "decorator",
+    inputs: Component | Sequence[Component] | set[Component] | None = None,
+    outputs: Component | Sequence[Component] | set[Component] | None = None,
+    api_name: str | None = None,
+    api_description: str | None | Literal[False] = None,
+    scroll_to_output: bool = False,
+    show_progress: Literal["full", "minimal", "hidden"] = "full",
+    show_progress_on: Component | Sequence[Component] | None = None,
+    queue: bool = True,
+    batch: bool = False,
+    max_batch_size: int = 4,
+    preprocess: bool = True,
+    postprocess: bool = True,
+    cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+    trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+    js: str | Literal[True] | None = None,
+    concurrency_limit: int | None | Literal["default"] = "default",
+    concurrency_id: str | None = None,
+    api_visibility: Literal["public", "private", "undocumented"] = "public",
+    time_limit: int | None = None,
+    stream_every: float = 0.5,
+    key: int | str | tuple[int | str, ...] | None = None,
+    validator: Callable | None = None,
+) -> Dependency
+```
+
+Supported events per component:
+
+- **AnnotatedImage**: select
+- **Audio**: stream, change, clear, play, pause, stop, pause, start_recording, pause_recording, stop_recording, upload, input
+- **BarPlot**: select, double_click
+- **BrowserState**: change
+- **Button**: click
+- **Chatbot**: change, select, like, retry, undo, example_select, option_select, clear, copy, edit
+- **Checkbox**: change, input, select
+- **CheckboxGroup**: change, input, select
+- **ClearButton**: click
+- **Code**: change, input, focus, blur
+- **ColorPicker**: change, input, submit, focus, blur
+- **Dataframe**: change, input, select, edit
+- **Dataset**: click, select
+- **DateTime**: change, submit
+- **DeepLinkButton**: click
+- **Dialogue**: change, input, submit
+- **DownloadButton**: click
+- **Dropdown**: change, input, select, focus, blur, key_up
+- **DuplicateButton**: click
+- **File**: change, select, clear, upload, delete, download
+- **FileExplorer**: change, input, select
+- **Gallery**: select, upload, change, delete, preview_close, preview_open
+- **HTML**: change, input, click, double_click, submit, stop, edit, clear, play, pause, end, start_recording, pause_recording, stop_recording, focus, blur, upload, release, select, stream, like, example_select, option_select, load, key_up, apply, delete, tick, undo, retry, expand, collapse, download, copy
+- **HighlightedText**: change, select
+- **Image**: clear, change, stream, select, upload, input
+- **ImageEditor**: clear, change, input, select, upload, apply
+- **ImageSlider**: clear, change, stream, select, upload, input
+- **JSON**: change
+- **Label**: change, select
+- **LinePlot**: select, double_click
+- **LoginButton**: click
+- **Markdown**: change, copy
+- **Model3D**: change, upload, edit, clear
+- **MultimodalTextbox**: change, input, select, submit, focus, blur, stop
+- **Navbar**: change
+- **Number**: change, input, submit, focus, blur
+- **ParamViewer**: change, upload
+- **Plot**: change
+- **Radio**: select, change, input
+- **ScatterPlot**: select, double_click
+- **SimpleImage**: clear, change, upload
+- **Slider**: change, input, release
+- **State**: change
+- **Textbox**: change, input, select, submit, focus, blur, stop, copy
+- **Timer**: tick
+- **UploadButton**: click, upload
+- **Video**: change, clear, start_recording, stop_recording, stop, play, pause, end, upload, input
+
+## Prediction CLI
+
+The `gradio` CLI includes `info` and `predict` commands for interacting with Gradio apps programmatically. These are especially useful for coding agents that need to use Spaces in their workflows.
+
+### `gradio info` — Discover endpoints and parameters
+
+```bash
+gradio info <space_id_or_url>
+```
+
+Returns a JSON payload describing all endpoints, their parameters (with types and defaults), and return values.
+
+```bash
+gradio info gradio/calculator
+# {
+#   "/predict": {
+#     "parameters": [
+#       {"name": "num1", "required": true, "default": null, "type": {"type": "number"}},
+#       {"name": "operation", "required": true, "default": null, "type": {"enum": ["add", "subtract", "multiply", "divide"], "type": "string"}},
+#       {"name": "num2", "required": true, "default": null, "type": {"type": "number"}}
+#     ],
+#     "returns": [{"name": "output", "type": {"type": "number"}}],
+#     "description": ""
+#   }
+# }
+```
+
+File-type parameters show `"type": "filepath"` with instructions to include `"meta": {"_type": "gradio.FileData"}` — this signals the file will be uploaded to the remote server.
+
+### `gradio predict` — Send predictions
+
+```bash
+gradio predict <space_id_or_url> <endpoint> <json_payload>
+```
+
+Returns a JSON object with named output keys.
+
+```bash
+# Simple numeric prediction
+gradio predict gradio/calculator /predict '{"num1": 5, "operation": "multiply", "num2": 3}'
+# {"output": 15}
+
+# Image generation
+gradio predict black-forest-labs/FLUX.2-dev /infer '{"prompt": "A majestic dragon"}'
+# {"Result": "/tmp/gradio/.../image.webp", "Seed": 1117868604}
+
+# File upload (must include meta key)
+gradio predict gradio/image_mod /predict '{"image": {"path": "/path/to/image.png", "meta": {"_type": "gradio.FileData"}}}'
+# {"output": "/tmp/gradio/.../output.png"}
+```
+
+Both commands accept `--token` for accessing private Spaces.
+
+## Additional Reference
+
+- [End-to-End Examples](examples.md) — complete working apps

.claude/skills/huggingface-gradio/examples.md

@@ -0,0 +1,613 @@
+# Gradio End-to-End Examples
+
+Complete working Gradio apps for reference.
+
+## Blocks Essay Simple
+
+```python
+import gradio as gr
+
+def change_textbox(choice):
+    if choice == "short":
+        return gr.Textbox(lines=2, visible=True)
+    elif choice == "long":
+        return gr.Textbox(lines=8, visible=True, value="Lorem ipsum dolor sit amet")
+    else:
+        return gr.Textbox(visible=False)
+
+with gr.Blocks() as demo:
+    radio = gr.Radio(
+        ["short", "long", "none"], label="What kind of essay would you like to write?"
+    )
+    text = gr.Textbox(lines=2, interactive=True, buttons=["copy"])
+    radio.change(fn=change_textbox, inputs=radio, outputs=text)
+
+demo.launch()
+```
+
+## Blocks Flipper
+
+```python
+import numpy as np
+import gradio as gr
+
+def flip_text(x):
+    return x[::-1]
+
+def flip_image(x):
+    return np.fliplr(x)
+
+with gr.Blocks() as demo:
+    gr.Markdown("Flip text or image files using this demo.")
+    with gr.Tab("Flip Text"):
+        text_input = gr.Textbox()
+        text_output = gr.Textbox()
+        text_button = gr.Button("Flip")
+    with gr.Tab("Flip Image"):
+        with gr.Row():
+            image_input = gr.Image()
+            image_output = gr.Image()
+        image_button = gr.Button("Flip")
+
+    with gr.Accordion("Open for More!", open=False):
+        gr.Markdown("Look at me...")
+        temp_slider = gr.Slider(
+            0, 1,
+            value=0.1,
+            step=0.1,
+            interactive=True,
+            label="Slide me",
+        )
+
+    text_button.click(flip_text, inputs=text_input, outputs=text_output)
+    image_button.click(flip_image, inputs=image_input, outputs=image_output)
+
+demo.launch()
+```
+
+## Blocks Form
+
+```python
+import gradio as gr
+
+with gr.Blocks() as demo:
+    name_box = gr.Textbox(label="Name")
+    age_box = gr.Number(label="Age", minimum=0, maximum=100)
+    symptoms_box = gr.CheckboxGroup(["Cough", "Fever", "Runny Nose"])
+    submit_btn = gr.Button("Submit")
+
+    with gr.Column(visible=False) as output_col:
+        diagnosis_box = gr.Textbox(label="Diagnosis")
+        patient_summary_box = gr.Textbox(label="Patient Summary")
+
+    def submit(name, age, symptoms):
+        return {
+            submit_btn: gr.Button(visible=False),
+            output_col: gr.Column(visible=True),
+            diagnosis_box: "covid" if "Cough" in symptoms else "flu",
+            patient_summary_box: f"{name}, {age} y/o",
+        }
+
+    submit_btn.click(
+        submit,
+        [name_box, age_box, symptoms_box],
+        [submit_btn, diagnosis_box, patient_summary_box, output_col],
+    )
+
+demo.launch()
+```
+
+## Blocks Hello
+
+```python
+import gradio as gr
+
+def welcome(name):
+    return f"Welcome to Gradio, {name}!"
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+    """
+    # Hello World!
+    Start typing below to see the output.
+    """)
+    inp = gr.Textbox(placeholder="What is your name?")
+    out = gr.Textbox()
+    inp.change(welcome, inp, out)
+
+demo.launch()
+```
+
+## Blocks Layout
+
+```python
+import gradio as gr
+
+demo = gr.Blocks()
+
+with demo:
+    with gr.Row():
+        gr.Image(interactive=True, scale=2)
+        gr.Image()
+    with gr.Row():
+        gr.Textbox(label="Text")
+        gr.Number(label="Count", scale=2)
+        gr.Radio(choices=["One", "Two"])
+    with gr.Row():
+        gr.Button("500", scale=0, min_width=500)
+        gr.Button("A", scale=0)
+        gr.Button("grow")
+    with gr.Row():
+        gr.Textbox()
+        gr.Textbox()
+        gr.Button()
+    with gr.Row():
+        with gr.Row():
+            with gr.Column():
+                gr.Textbox(label="Text")
+                gr.Number(label="Count")
+                gr.Radio(choices=["One", "Two"])
+            gr.Image()
+            with gr.Column():
+                gr.Image(interactive=True)
+                gr.Image()
+    gr.Image()
+    gr.Textbox(label="Text")
+    gr.Number(label="Count")
+    gr.Radio(choices=["One", "Two"])
+
+demo.launch()
+```
+
+## Calculator
+
+```python
+import gradio as gr
+
+def calculator(num1, operation, num2):
+    if operation == "add":
+        return num1 + num2
+    elif operation == "subtract":
+        return num1 - num2
+    elif operation == "multiply":
+        return num1 * num2
+    elif operation == "divide":
+        if num2 == 0:
+            raise gr.Error("Cannot divide by zero!")
+        return num1 / num2
+
+demo = gr.Interface(
+    calculator,
+    [
+        "number",
+        gr.Radio(["add", "subtract", "multiply", "divide"]),
+        "number"
+    ],
+    "number",
+    examples=[
+        [45, "add", 3],
+        [3.14, "divide", 2],
+        [144, "multiply", 2.5],
+        [0, "subtract", 1.2],
+    ],
+    title="Toy Calculator",
+    description="Here's a sample toy calculator.",
+    api_name="predict"
+)
+
+demo.launch()
+```
+
+## Chatbot Simple
+
+```python
+import gradio as gr
+import random
+import time
+
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox()
+    clear = gr.ClearButton([msg, chatbot])
+
+    def respond(message, chat_history):
+        bot_message = random.choice(["How are you?", "Today is a great day", "I'm very hungry"])
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": bot_message})
+        time.sleep(2)
+        return "", chat_history
+
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
+
+demo.launch()
+```
+
+## Chatbot Streaming
+
+```python
+import gradio as gr
+import random
+import time
+
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox()
+    clear = gr.Button("Clear")
+
+    def user(user_message, history: list):
+        return "", history + [{"role": "user", "content": user_message}]
+
+    def bot(history: list):
+        bot_message = random.choice(["How are you?", "I love you", "I'm very hungry"])
+        history.append({"role": "assistant", "content": ""})
+        for character in bot_message:
+            history[-1]['content'] += character
+            time.sleep(0.05)
+            yield history
+
+    msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, chatbot, chatbot
+    )
+    clear.click(lambda: None, None, chatbot, queue=False)
+
+demo.launch()
+```
+
+## Custom Css
+
+```python
+import gradio as gr
+
+with gr.Blocks() as demo:
+    with gr.Column(elem_classes="cool-col"):
+        gr.Markdown("### Gradio Demo with Custom CSS", elem_classes="darktest")
+        gr.Markdown(
+            elem_classes="markdown",
+            value="Resize the browser window to see the CSS media query in action.",
+        )
+
+if __name__ == "__main__":
+    demo.launch(css_paths=["demo/custom_css/custom_css.css"])
+```
+
+## Fake Diffusion
+
+```python
+import gradio as gr
+import numpy as np
+import time
+
+def fake_diffusion(steps):
+    rng = np.random.default_rng()
+    for i in range(steps):
+        time.sleep(1)
+        image = rng.random(size=(600, 600, 3))
+        yield image
+    image = np.ones((1000,1000,3), np.uint8)
+    image[:] = [255, 124, 0]
+    yield image
+
+demo = gr.Interface(fake_diffusion,
+                    inputs=gr.Slider(1, 10, 3, step=1),
+                    outputs="image",
+                    api_name="predict")
+
+demo.launch()
+```
+
+## Hello World
+
+```python
+import gradio as gr
+
+
+def greet(name):
+    return "Hello " + name + "!"
+
+
+demo = gr.Interface(fn=greet, inputs="textbox", outputs="textbox", api_name="predict")
+
+demo.launch()
+```
+
+## Image Editor
+
+```python
+import gradio as gr
+import time
+
+
+def sleep(im):
+    time.sleep(5)
+    return [im["background"], im["layers"][0], im["layers"][1], im["composite"]]
+
+
+def predict(im):
+    return im["composite"]
+
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        im = gr.ImageEditor(
+            type="numpy",
+        )
+        im_preview = gr.Image()
+    n_upload = gr.Number(0, label="Number of upload events", step=1)
+    n_change = gr.Number(0, label="Number of change events", step=1)
+    n_input = gr.Number(0, label="Number of input events", step=1)
+
+    im.upload(lambda x: x + 1, outputs=n_upload, inputs=n_upload)
+    im.change(lambda x: x + 1, outputs=n_change, inputs=n_change)
+    im.input(lambda x: x + 1, outputs=n_input, inputs=n_input)
+    im.change(predict, outputs=im_preview, inputs=im, show_progress="hidden")
+
+demo.launch()
+```
+
+## On Listener Decorator
+
+```python
+import gradio as gr
+
+with gr.Blocks() as demo:
+    name = gr.Textbox(label="Name")
+    output = gr.Textbox(label="Output Box")
+    greet_btn = gr.Button("Greet")
+
+    @gr.on(triggers=[name.submit, greet_btn.click], inputs=name, outputs=output)
+    def greet(name):
+        return "Hello " + name + "!"
+
+demo.launch()
+```
+
+## Render Merge
+
+```python
+import gradio as gr
+import time
+
+with gr.Blocks() as demo:
+    text_count = gr.Slider(1, 5, value=1, step=1, label="Textbox Count")
+
+    @gr.render(inputs=text_count)
+    def render_count(count):
+        boxes = []
+        for i in range(count):
+            box = gr.Textbox(label=f"Box {i}")
+            boxes.append(box)
+
+        def merge(*args):
+            time.sleep(0.2)  # simulate a delay
+            return " ".join(args)
+
+        merge_btn.click(merge, boxes, output)
+
+        def clear():
+            time.sleep(0.2)  # simulate a delay
+            return [" "] * count
+
+        clear_btn.click(clear, None, boxes)
+
+        def countup():
+            time.sleep(0.2)  # simulate a delay
+            return list(range(count))
+
+        count_btn.click(countup, None, boxes, queue=False)
+
+    with gr.Row():
+        merge_btn = gr.Button("Merge")
+        clear_btn = gr.Button("Clear")
+        count_btn = gr.Button("Count")
+
+    output = gr.Textbox()
+
+demo.launch()
+```
+
+## Reverse Audio 2
+
+```python
+import gradio as gr
+import numpy as np
+
+def reverse_audio(audio):
+    sr, data = audio
+    return (sr, np.flipud(data))
+
+demo = gr.Interface(fn=reverse_audio,
+                    inputs="microphone",
+                    outputs="audio", api_name="predict")
+
+demo.launch()
+```
+
+## Sepia Filter
+
+```python
+import numpy as np
+import gradio as gr
+
+def sepia(input_img):
+    sepia_filter = np.array([
+        [0.393, 0.769, 0.189],
+        [0.349, 0.686, 0.168],
+        [0.272, 0.534, 0.131]
+    ])
+    sepia_img = input_img.dot(sepia_filter.T)
+    sepia_img /= sepia_img.max()
+    return sepia_img
+
+demo = gr.Interface(sepia, gr.Image(), "image", api_name="predict")
+demo.launch()
+```
+
+## Sort Records
+
+```python
+import gradio as gr
+
+def sort_records(records):
+    return records.sort("Quantity")
+
+demo = gr.Interface(
+    sort_records,
+    gr.Dataframe(
+        headers=["Item", "Quantity"],
+        datatype=["str", "number"],  
+        row_count=3,
+        column_count=2,
+        column_limits=(2, 2),
+        type="polars"
+    ),
+    "dataframe",
+    description="Sort by Quantity"
+)
+
+demo.launch()
+```
+
+## Streaming Simple
+
+```python
+import gradio as gr
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            input_img = gr.Image(label="Input", sources="webcam")
+        with gr.Column():
+            output_img = gr.Image(label="Output")
+        input_img.stream(lambda s: s, input_img, output_img, time_limit=15, stream_every=0.1, concurrency_limit=30)
+
+if __name__ == "__main__":
+
+    demo.launch()
+```
+
+## Tabbed Interface Lite
+
+```python
+import gradio as gr
+
+hello_world = gr.Interface(lambda name: "Hello " + name, "text", "text", api_name="predict")
+bye_world = gr.Interface(lambda name: "Bye " + name, "text", "text", api_name="predict")
+chat = gr.ChatInterface(lambda *args: "Hello " + args[0], api_name="chat")
+
+demo = gr.TabbedInterface([hello_world, bye_world, chat], ["Hello World", "Bye World", "Chat"])
+
+demo.launch()
+```
+
+## Tax Calculator
+
+```python
+import gradio as gr
+
+def tax_calculator(income, marital_status, assets):
+    tax_brackets = [(10, 0), (25, 8), (60, 12), (120, 20), (250, 30)]
+    total_deductible = sum(cost for cost, deductible in zip(assets["Cost"], assets["Deductible"]) if deductible)
+    taxable_income = income - total_deductible
+
+    total_tax = 0
+    for bracket, rate in tax_brackets:
+        if taxable_income > bracket:
+            total_tax += (taxable_income - bracket) * rate / 100
+
+    if marital_status == "Married":
+        total_tax *= 0.75
+    elif marital_status == "Divorced":
+        total_tax *= 0.8
+
+    return round(total_tax)
+
+demo = gr.Interface(
+    tax_calculator,
+    [
+        "number",
+        gr.Radio(["Single", "Married", "Divorced"]),
+        gr.Dataframe(
+            headers=["Item", "Cost", "Deductible"],
+            datatype=["str", "number", "bool"],  
+            label="Assets Purchased this Year",
+        ),
+    ],
+    gr.Number(label="Tax due"),
+    examples=[
+        [10000, "Married", [["Suit", 5000, True], ["Laptop (for work)", 800, False], ["Car", 1800, True]]],
+        [80000, "Single", [["Suit", 800, True], ["Watch", 1800, True], ["Food", 800, True]]],
+    ],
+    live=True,
+    api_name="predict"
+)
+
+demo.launch()
+```
+
+## Timer Simple
+
+```python
+import gradio as gr
+import random
+import time
+
+with gr.Blocks() as demo:
+  timer = gr.Timer(1)
+  timestamp = gr.Number(label="Time")
+  timer.tick(lambda: round(time.time()), outputs=timestamp, api_name="timestamp")
+
+  number = gr.Number(lambda: random.randint(1, 10), every=timer, label="Random Number")
+  with gr.Row():
+    gr.Button("Start").click(lambda: gr.Timer(active=True), None, timer)
+    gr.Button("Stop").click(lambda: gr.Timer(active=False), None, timer)
+    gr.Button("Go Fast").click(lambda: 0.2, None, timer)
+
+if __name__ == "__main__":
+  demo.launch()
+```
+
+## Variable Outputs
+
+```python
+import gradio as gr
+
+max_textboxes = 10
+
+def variable_outputs(k):
+    k = int(k)
+    return [gr.Textbox(visible=True)]*k + [gr.Textbox(visible=False)]*(max_textboxes-k)
+
+with gr.Blocks() as demo:
+    s = gr.Slider(1, max_textboxes, value=max_textboxes, step=1, label="How many textboxes to show:")
+    textboxes = []
+    for i in range(max_textboxes):
+        t = gr.Textbox(f"Textbox {i}")
+        textboxes.append(t)
+
+    s.change(variable_outputs, s, textboxes)
+
+if __name__ == "__main__":
+   demo.launch()
+```
+
+## Video Identity
+
+```python
+import gradio as gr
+from gradio.media import get_video
+
+def video_identity(video):
+    return video
+
+# get_video() returns file paths to sample media included with Gradio
+demo = gr.Interface(video_identity,
+                    gr.Video(),
+                    "playable_video",
+                    examples=[
+                        get_video("world.mp4")
+                    ],
+                    cache_examples=True,
+                    api_name="predict",)
+
+demo.launch()
+```

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/voice_caught_0.wav filter=lfs diff=lfs merge=lfs -text
+assets/voice_caught_1.wav filter=lfs diff=lfs merge=lfs -text
+assets/voice_caught_2.wav filter=lfs diff=lfs merge=lfs -text
+assets/voice_escaped_0.wav filter=lfs diff=lfs merge=lfs -text
+assets/voice_escaped_1.wav filter=lfs diff=lfs merge=lfs -text
+assets/voice_escaped_2.wav filter=lfs diff=lfs merge=lfs -text

app.py

@@ -5,8 +5,8 @@ Game loop: case intro -> timed glimpse -> testimony -> sketch reveal -> lineup
 grow the lineup; from INSPECTOR the culprit changes one feature before the
 lineup ("he's been to a barber since").
 
-UI architecture: a single state-driven @gr.render stage (Gradio 6 native).
-No Column-visibility toggling — empirically fragile in Gradio 6.
+UI architecture: a single state-driven @gr.render stage. Column-visibility
+toggling desyncs in Gradio 6 once demo.load touches it (see FIELD_NOTES.md).
 """
 from __future__ import annotations
 
@@ -46,16 +46,7 @@ def svg_uri(svg: str) -> str:
     return "data:image/svg+xml;base64," + base64.b64encode(svg.encode()).decode()
 
 
-def face_png(spec: FaceSpec, width: int = 300) -> "Image.Image":
-    """Rasterize a face for components that need real images (gr.Gallery)."""
-    import io
-
-    import cairosvg
-    from PIL import Image
-
-    png = cairosvg.svg2png(bytestring=render_face_svg(spec, width=width).encode(),
-                           output_width=width)
-    return Image.open(io.BytesIO(png)).convert("RGB")
+from game.render import face_image as face_png  # gr.Gallery needs PIL, not data-URIs
 
 
 def glimpse_html(case: Case) -> str:
@@ -151,21 +142,32 @@ def next_case(s: dict) -> dict:
     s["case_no"] = min(s["case_no"] + 1, len(RANKS))
     s["case"] = make_case(s["case_no"])
     s["screen"] = "intro"
+    for stale in ("described", "lineup", "culprit_idx", "picked", "correct"):
+        s.pop(stale, None)
     return s
 
 
 # ------------------------------------------------------------------ UI
 CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Special+Elite&display=swap');
 :root { --paper:#f4efe4; --ink:#2b2a28; --red:#a33327; --tape:#c9a227; }
-.gradio-container { background:#191713 !important; font-family:'Courier New',monospace !important; }
+.gradio-container { background:#191713 !important; font-family:'Courier New',monospace !important;
+  background-image: radial-gradient(ellipse at 50% -10%, rgba(201,162,39,0.07) 0%, transparent 55%) !important; }
 #ew-root { max-width: 900px; margin: 0 auto; }
-.ew-header { text-align:center; color:var(--paper); letter-spacing:6px; font-size:30px; padding:10px 0 0; }
+.ew-header { text-align:center; color:var(--paper); letter-spacing:7px; font-size:34px; padding:12px 0 0;
+  font-family:'Special Elite','Courier New',monospace; text-shadow: 0 2px 0 rgba(0,0,0,.6); }
 .ew-sub { text-align:center; color:#8d8678; font-size:12px; letter-spacing:2px; margin-bottom:8px; }
 .ew-rank { font-family:monospace; color:var(--tape); text-align:center; letter-spacing:2px; font-size:13px; }
 .ew-card { background:var(--paper) !important; border-radius:4px; padding:22px 26px !important; color:var(--ink);
            box-shadow: 0 10px 40px rgba(0,0,0,.5); }
 .ew-card * { color: var(--ink); }
 .ew-glimpse { position:relative; width:320px; margin:0 auto; }
+.ew-glimpse::before { content:'● REC'; position:absolute; top:8px; left:10px; z-index:3;
+  color:#e03b2f; font-size:12px; letter-spacing:2px; animation: ew-blink 1.1s step-end infinite; }
+.ew-glimpse::after { content:''; position:absolute; inset:0 0 13px 0; z-index:2; pointer-events:none;
+  box-shadow: inset 0 0 60px rgba(0,0,0,.55);
+  background: repeating-linear-gradient(0deg, transparent 0 3px, rgba(0,0,0,0.06) 3px 4px); }
+@keyframes ew-blink { 50% { opacity: 0; } }
 .ew-glimpse img { width:100%; filter: blur(0); }
 @keyframes ew-blurout { to { filter: blur(30px) contrast(0.4); } }
 .ew-static { position:absolute; inset:0 0 13px 0; display:flex; align-items:center; justify-content:center;
@@ -182,7 +184,10 @@ CSS = """
 .ew-hit td { color:#1d6b2f !important; } .ew-miss td { color:var(--red) !important; } .ew-silent td { color:#8d8678 !important; }
 .ew-verdict { text-align:center; }
 .ew-stamp { display:inline-block; border:4px solid var(--red); color:var(--red); padding:6px 22px;
-  font-size:26px; letter-spacing:4px; transform:rotate(-6deg); margin:6px 0 10px; }
+  font-size:26px; letter-spacing:4px; transform:rotate(-6deg) scale(1); margin:6px 0 10px;
+  font-family:'Special Elite','Courier New',monospace;
+  animation: ew-stamp-in .28s cubic-bezier(.2,2.2,.5,1) both; }
+@keyframes ew-stamp-in { from { opacity:0; transform: rotate(-6deg) scale(2.4); } }
 .ew-good .ew-stamp { border-color:#1d6b2f; color:#1d6b2f; }
 .ew-quote { font-style:italic; margin-bottom:12px; }
 .ew-pair { display:flex; gap:18px; justify-content:center; }
@@ -249,10 +254,13 @@ with gr.Blocks(title="EYEWITNESS") as demo:
                                 gr.Markdown(f"**⚠ {case.disguise_line}**")
                         with gr.Column(scale=2):
                             gr.Markdown("### THE LINEUP — click the culprit")
+                            n = len(s["lineup"])
+                            rows = -(-n // 4)  # ceil
                             gal = gr.Gallery(
                                 value=[(face_png(f, width=240), f"Nº {i + 1}")
                                        for i, f in enumerate(s["lineup"])],
-                                columns=4, height=320, allow_preview=False, label="")
+                                columns=4, rows=rows, height=rows * 330,
+                                allow_preview=False, label="")
 
                             def _pick(st: dict, evt: gr.SelectData):
                                 return pick_suspect(st, evt.index)

assets/case_bank.json

@@ -0,0 +1,97 @@
+[
+ {
+  "name": "the <Pets> <Animal-Pet-Sharing-Comedy-Interview>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1001
+ },
+ {
+  "name": "The <CYBER SECURITY <CYBERG AGENCY> <SECURITY PATTERNS> <COM",
+  "blurb": "In this fast-paced, high-stakes game, you'll tackle complex cybersecurity challenges using a range of specialized techniques, tools, and resources. Whether it's",
+  "seed": 1007
+ },
+ {
+  "name": "The <Food> <Cooking> <Cooking>",
+  "blurb": "The kitchen is full of delicious, mouth-watering recipes.",
+  "seed": 1008
+ },
+ {
+  "name": "the <Artistic> <Job/Heist/Affair/Caper>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1013
+ },
+ {
+  "name": "the weather weather crime",
+  "blurb": "I was looking at this weather forecast and noticed that it was turning pretty rainy today. The game would be a simple one: I was trying to figure out if it was ",
+  "seed": 1014
+ },
+ {
+  "name": "the tech crime game",
+  "blurb": "A smart detective with a keen eye for the latest tech gadgets.",
+  "seed": 1015
+ },
+ {
+  "name": "The <Animal> <Animal> <Animal> <Animal> <Animal> <Animal> <A",
+  "blurb": "A humorous, family-friendly game about an animal detective who solves crimes, fights villains, and helps pets.",
+  "seed": 1017
+ },
+ {
+  "name": "The <Sword, Armor, Crown, Glove, Bow, Locket, Sword of Valor",
+  "blurb": "<one sentence, third person>",
+  "seed": 1019
+ },
+ {
+  "name": "the <sports> <Game> <Heist/Affair/Caper>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1020
+ },
+ {
+  "name": "the <Mime <Art> <Comic Detective> <Funny>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1021
+ },
+ {
+  "name": "the <Technology> <Job/Heist/Affair/Caper>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1023
+ },
+ {
+  "name": "the <transportation> <Job/Heist/Affair/Caper>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1027
+ },
+ {
+  "name": "the <Scent> <Crime/Affair/Caper>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1029
+ },
+ {
+  "name": "The Weather Game",
+  "blurb": "A hilarious game where you use weather reports to solve crimes.",
+  "seed": 1030
+ },
+ {
+  "name": "The <Music> <Job/Heist/Affair/Caper>",
+  "blurb": "In this game of musical crime, you'll navigate a world where genres collide and you'll uncover musical secrets hidden around corners. You'll need to use your mu",
+  "seed": 1034
+ },
+ {
+  "name": "the <FUNKY, FUNNY, FAMILY-FRIEND OFTEN-HOSTS, CO-CREATORS, A",
+  "blurb": "A hilarious, insightful, and action-packed game that turns ordinary players into the world's greatest comedy detective.",
+  "seed": 1036
+ },
+ {
+  "name": "the weather",
+  "blurb": "A comedic game where you use the current weather to solve crimes or catch runaway family members.",
+  "seed": 1038
+ },
+ {
+  "name": "the <Technology> <Job/Heist/Affair/Caper>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1039
+ },
+ {
+  "name": "the <Song> <Genre>",
+  "blurb": "<one sentence, third person>",
+  "seed": 1042
+ }
+]

assets/voice_caught_0.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ec4439f2344afbca9a284d72824ee89e114019a037aebe5e095270ceec02940
+size 291884

assets/voice_caught_1.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab9a952dda5c13ecd50d8e597d3a6382c1f72c6e2a84d13bbf9cb73713326718
+size 307244

assets/voice_caught_2.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb465e4774aef4879739c4eb0a35205242a81eb012eb3179118d0922cddefcff
+size 476204

assets/voice_escaped_0.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4762a0218d27de14e25bd7f5442b7fa6fdff55af5a3133e4d0daa226dd18b936
+size 353324

assets/voice_escaped_1.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97edae68d8513e9dec0b3b45ba85605c1b68428b20f0a258f9e1d04f19b286d6
+size 245804

assets/voice_escaped_2.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffbf5a76501545eb3de222712bc461acc4eaedda0f17475dffd254c2905b988c
+size 291884

game/face.py

@@ -281,11 +281,3 @@ def render_face_svg(spec: FaceSpec, width: int = 300, paper: bool = True, seed_j
     return svg
 
 
-def render_unknown_svg(width: int = 300) -> str:
-    """Placeholder silhouette for un-described attributes / mystery faces."""
-    return f'''<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 300 360" width="{width}">
-<rect width="300" height="360" fill="{PAPER}"/>
-<path d="M118,250 L114,300 C112,318 100,322 84,330 L216,330 C200,322 188,318 186,300 L182,250 M150,68 C108,68 84,104 84,160 C84,216 112,262 150,262 C188,262 216,216 216,160 C216,104 192,68 150,68"
- fill="#d8d0bd" stroke="#9a9284" stroke-width="3" stroke-dasharray="7 6"/>
-<text x="150" y="180" text-anchor="middle" font-family="monospace" font-size="64" fill="#9a9284">?</text>
-</svg>'''

game/lineup.py

@@ -1,4 +1,4 @@
-"""Lineup builder — the signature mechanic.
+"""Lineup builder.
 
 Distractors are derived from the PLAYER'S OWN testimony errors:
 - Attributes you got WRONG become shared between culprit and distractors

game/model.py

@@ -20,7 +20,7 @@ from .parser import parse_testimony as _tier_a
 
 import os
 
-# Swapped to our published fine-tune once training completes (Well-Tuned badge).
+# Overridable so the Space can point at the published fine-tune.
 MODEL_ID = os.environ.get("EYEWITNESS_MODEL_ID", "openbmb/MiniCPM5-1B")
 
 try:  # ZeroGPU decorator when running in a HF Space
@@ -96,7 +96,9 @@ JSON:"""
 @_gpu
 def _generate(testimony: str) -> str:
     model, tok = _load()
-    prompt = PROMPT.format(schema=_schema_block(), testimony=testimony.replace('"', "'"))
+    # json.dumps gives fully-escaped quoting; bare replace() left injectable quotes
+    safe = json.dumps(testimony, ensure_ascii=False)[1:-1]
+    prompt = PROMPT.format(schema=_schema_block(), testimony=safe)
     messages = [{"role": "user", "content": prompt}]
     text = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
     enc = tok(text, return_tensors="pt").to(model.device)
@@ -123,5 +125,8 @@ def parse_testimony_model(testimony: str) -> dict[str, str | None]:
         v = data.get(attr)
         if isinstance(v, str):
             v = v.strip().lower().replace(" ", "_")
-        out[attr] = v if v in VOCAB[attr] else base.get(attr)
+        # Tier A is literal-match (high precision): where it spoke, it wins.
+        # The model fills the silence (messy/indirect phrasings) — this also
+        # caps model hallucinations to attributes Tier A had no opinion on.
+        out[attr] = base.get(attr) or (v if v in VOCAB[attr] else None)
     return out

game/poster.py

@@ -5,12 +5,10 @@ downloads and dares friends with. Pure PIL — zero GPU, zero model.
 """
 from __future__ import annotations
 
-import io
-
-import cairosvg
 from PIL import Image, ImageDraw, ImageFont
 
-from .face import FaceSpec, render_face_svg
+from .face import FaceSpec
+from .render import face_image as _face_img
 
 PAPER = (244, 239, 228)
 INK = (43, 42, 40)
@@ -19,12 +17,6 @@ GREEN = (29, 107, 47)
 TAPE = (201, 162, 39)
 
 
-def _face_img(spec: FaceSpec, width: int) -> Image.Image:
-    png = cairosvg.svg2png(bytestring=render_face_svg(spec, width=width).encode(),
-                           output_width=width)
-    return Image.open(io.BytesIO(png)).convert("RGB")
-
-
 def _font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont:
     candidates = [
         "/usr/share/fonts/TTF/DejaVuSansMono-Bold.ttf" if bold else "/usr/share/fonts/TTF/DejaVuSansMono.ttf",

game/render.py

@@ -0,0 +1,15 @@
+"""Shared SVG→PIL rasterization for components that need real images."""
+from __future__ import annotations
+
+import io
+
+import cairosvg
+from PIL import Image
+
+from .face import FaceSpec, render_face_svg
+
+
+def face_image(spec: FaceSpec, width: int = 300) -> Image.Image:
+    png = cairosvg.svg2png(bytestring=render_face_svg(spec, width=width).encode(),
+                           output_width=width)
+    return Image.open(io.BytesIO(png)).convert("RGB")

modal_factory.py

@@ -52,16 +52,16 @@ def build_case_bank(n_cases: int = 48) -> list[dict]:
                            filename="MiniCPM5-1B-Q4_K_M.gguf")
     llm = Llama(model_path=gguf, n_ctx=2048, verbose=False)
 
-    prompt_tpl = (
+    prompt_head = (
         "Write ONE short, funny, family-friendly petty-crime headline and a one-sentence "
         "description for a comedy detective game. Format strictly as JSON: "
         '{"name": "the <Something> <Job/Heist/Affair/Caper>", "blurb": "<one sentence, third person>"}'
-        "\nTheme hint: {hint}\nJSON:"
+        "\nTheme hint: "
     )
     hints = ["food", "animals", "music", "transport", "sports", "art", "weather", "technology"]
     bank = []
     for i in range(n_cases):
-        out = llm(prompt_tpl.format(hint=hints[i % len(hints)]),
+        out = llm(prompt_head + hints[i % len(hints)] + "\nJSON:",
                   max_tokens=120, temperature=0.9, stop=["\n\n"])
         text = out["choices"][0]["text"]
         try:
@@ -77,26 +77,50 @@ def build_case_bank(n_cases: int = 48) -> list[dict]:
 
 @app.function(image=voice_image, gpu="A10G", timeout=1800)
 def build_voice_bank() -> dict[str, list[bytes]]:
-    """Pre-render the culprit's verdict lines with VoxCPM2 (smug, theatrical)."""
+    """Pre-render the culprit's verdict lines with VoxCPM2.
+
+    Voice consistency trick: render an anchor line with the default voice once,
+    then self-clone it (prompt_wav + its transcript) for every other line so the
+    culprit keeps ONE voice across the whole bank."""
     import io
 
     import soundfile as sf
     from voxcpm import VoxCPM
 
     tts = VoxCPM.from_pretrained("openbmb/VoxCPM2")
+
+    sr = tts.tts_model.sample_rate  # 48 kHz; a wrong rate here slows the anchor
+    # and garbles every line cloned from it
+    anchor_text = "Okay, okay. It was me. Take me in."
+    anchor = tts.generate(text=anchor_text)
+    anchor_path = "/tmp/anchor.wav"
+    sf.write(anchor_path, anchor, sr)
+
+    def render(line: str):
+        if line == anchor_text:
+            return anchor
+        return tts.generate(text=line, prompt_wav_path=anchor_path, prompt_text=anchor_text)
+
     rendered: dict[str, list[bytes]] = {"caught": [], "escaped": []}
     for kind, lines in VERDICT_LINES.items():
         for line in lines:
-            wav = tts.generate(
-                text=line,
-                prompt_text="(smug, nasal, theatrical, slightly out of breath)",
-            )
+            wav = render(line)
             buf = io.BytesIO()
-            sf.write(buf, wav, 16000, format="WAV")
+            sf.write(buf, wav, sr, format="WAV")
             rendered[kind].append(buf.getvalue())
     return rendered
 
 
+@app.local_entrypoint()
+def voices_only():
+    voices = build_voice_bank.remote()
+    for kind, blobs in voices.items():
+        for i, blob in enumerate(blobs):
+            with open(f"assets/voice_{kind}_{i}.wav", "wb") as f:
+                f.write(blob)
+    print("voice bank complete -> assets/")
+
+
 @app.local_entrypoint()
 def main():
     bank = build_case_bank.remote(48)
@@ -108,3 +132,29 @@ def main():
             with open(f"assets/voice_{kind}_{i}.wav", "wb") as f:
                 f.write(blob)
     print("factory complete -> assets/")
+
+
+@app.function(image=voice_image, gpu="A10G", timeout=600)
+def probe_voice() -> dict:
+    """Diagnose VoxCPM output: true sample rate, array shape, attrs."""
+    import numpy as np
+    from voxcpm import VoxCPM
+
+    tts = VoxCPM.from_pretrained("openbmb/VoxCPM2")
+    wav = tts.generate(text="Okay, okay. It was me. Take me in.")
+    info = {
+        "shape": list(np.asarray(wav).shape),
+        "dtype": str(np.asarray(wav).dtype),
+        "attrs": [a for a in dir(tts) if "rate" in a.lower() or "sr" == a.lower()],
+    }
+    for a in info["attrs"]:
+        try:
+            info[f"val_{a}"] = str(getattr(tts, a))[:120]
+        except Exception:
+            pass
+    return info
+
+
+@app.local_entrypoint()
+def probe():
+    print(probe_voice.remote())

train/gen_dataset.py

@@ -105,6 +105,13 @@ FILLERS_ES = ["creo", "me parece", "juraria que", "no se,", "o sea", "si no recu
 CONNECT = [", ", ", and ", ". ", ", y ", " — ", "... "]
 
 
+# keep in lockstep with game/parser.py SYNONYMS — drift here means the model
+# trains on phrasings the live app never produces, and vice versa
+assert set(PHRASES) == set(VOCAB), "PHRASES attributes drifted from VOCAB"
+for _attr, _values in PHRASES.items():
+    assert set(_values) <= set(VOCAB[_attr]) | {"none"}, f"PHRASES[{_attr}] has values outside VOCAB"
+
+
 def spec_to_testimony(spec: FaceSpec, rng: random.Random) -> tuple[str, dict]:
     """Pick 3-7 attributes, phrase them noisily, return (text, partial truth dict)."""
     attrs = [a for a in VOCAB if PHRASES[a].get(getattr(spec, a))]