@hugpy/video-intelligence-ui 0.1.1 → 0.3.1

package/README.md

@@ -0,0 +1,43 @@
+# @hugpy/video-intelligence-ui
+
+Video-intelligence console — sibling arm of `media_intelligence_ui` (Vite +
+Tailwind v4), served at `/video`. Four stations (image crop, audio crop,
+frames/models, generate) over the hugpy job bus.
+
+## Demo media is hosted, not bundled
+
+The canned demo (`?demo=1`) replays recorded job envelopes whose media
+(~36 MB of sample mp4/png) is **not** shipped in this package or its build.
+It loads from a hosted base, default `https://hugpy.ai/demo-media`.
+
+Resolution order (see `src/demo/mediaBase.ts`, resolved once at load):
+
+1. `?mediaBase=` query param (http(s) or path-absolute values only)
+2. `window.__HUGPY_MEDIA_BASE__` — a non-empty string; `index.html` ships a
+   `window.__HUGPY_MEDIA_BASE__ = window.__HUGPY_MEDIA_BASE__ ?? null;`
+   marker that servers/self-hosters may rewrite (replace `null` with a
+   JSON string)
+3. `VITE_HUGPY_DEMO_MEDIA_BASE` (build-time, read in `src/config.ts` — the
+   one module permitted to hold URL literals)
+4. the default `https://hugpy.ai/demo-media`
+
+## Self-hosting the demo media (`hugpy serve`)
+
+The Python server (`abstract_hugpy_dev` / `hugpy`) reads two env vars
+(env or `.env`) and rewrites the marker in the served `index.html`:
+
+- `HUGPY_DEMO_MEDIA_BASE=<url>` — point the demo at any hosted copy of the
+  media tree.
+- `HUGPY_DEMO_MEDIA_DIR=<path>` — serve a local copy of the tree yourself at
+  `/demo-media/` (wins over `HUGPY_DEMO_MEDIA_BASE`). Unset → the route does
+  not exist.
+
+## Canonical media tree
+
+The canonical copy lives at `/var/www/hugpy-media/` on the hugpy.ai VM,
+served by an `location /demo-media/` block in the brochure nginx vhost —
+deliberately OUTSIDE the brochure docroot (`/var/www/hugpy.ai`) so brochure
+rebuilds (`stage.sh` rsync `--delete`) can never wipe it. Its layout mirrors
+the `demoMedia("...")` specifiers: `generate/`, `generate2/`, top-level
+`demo-*` files, and `sampels/` (that dir is intentionally spelled "sampels"
+— do NOT rename it).

package/index.html

@@ -48,6 +48,8 @@
         <p><a style="color:#8ab4ff" href="/">Hugpy — Inference You Own</a></p>
       </main>
     </noscript>
+    <!-- Self-hosters/servers: replace null with your demo-media base URL string. -->
+    <script>window.__HUGPY_MEDIA_BASE__ = window.__HUGPY_MEDIA_BASE__ ?? null;</script>
     <script type="module" src="./entry.tsx"></script>
   </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hugpy/video-intelligence-ui",
-  "version": "0.1.1",
+  "version": "0.3.1",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
   "description": "Video-intelligence console \u2014 sibling arm of media_intelligence_ui (Vite + Tailwind v4), served at /video. Four stations (image crop, audio crop, frames/models, generate) over the hugpy job bus. Dials the same-origin current-hugpy API (/api).",
@@ -28,9 +28,6 @@
     "src",
     "entry.tsx",
     "index.html",
-    "assets",
-    "help",
-    "navbar",
     "vite.config.ts",
     "tsconfig.json",
     "LICENSE"

package/src/config.ts

@@ -39,6 +39,14 @@ export const hugpyConfig = {
   apiBase,
   /** Public hugpy site — CTA target. Override with VITE_HUGPY_SITE_URL. */
   siteUrl: stripTrailingSlash(read("VITE_HUGPY_SITE_URL") ?? "https://hugpy.ai"),
+  /**
+   * Hosted demo media tree (canned-demo samples live OUT of the bundle).
+   * Build-time override: VITE_HUGPY_DEMO_MEDIA_BASE. Runtime overrides
+   * (?mediaBase= / window.__HUGPY_MEDIA_BASE__) are layered in demo/mediaBase.ts.
+   */
+  demoMediaBase: stripTrailingSlash(
+    read("VITE_HUGPY_DEMO_MEDIA_BASE") ?? "https://hugpy.ai/demo-media",
+  ),
   /** Multipart file upload endpoint. */
   uploadUrl: read("VITE_HUGPY_UPLOAD_URL") ?? `${apiBase}/uploads`,
   /**
@@ -58,6 +66,23 @@ export const hugpyConfig = {
    */
   videoExtractUrl:
     read("VITE_HUGPY_VIDEO_EXTRACT_URL") ?? `${apiBase}/video/identity-profiles/video-extract`,
+  /**
+   * k94 — ONE PATH identity creation (Identities tab, "Create identity"):
+   *   from-video:  POST { source:<MediaRef, kind:"video">, name, mesh_params? }
+   *                → 202 { job_id, name, slug, kind:"identity_from_video" }
+   *                ONE chained char360 + Hunyuan3D job; on done ONE profile per
+   *                detected character (slug, slug-2, …) with crops + canonical + GLB.
+   *   from-images: POST { sources:[<MediaRef, kind:"image">…], name, mesh_params? }
+   *                → 202 { job_id, recon_id, slug, profile, kind:"identity_mesh_build" }
+   *                create profile + the one-click full build chained server-side.
+   * Both jobs are polled on `videoJobUrl` (GET /video/jobs/<id>): `progress`
+   * carries stage / progress / log_tail; `result.identities` (from-video) lists
+   * what was minted. Declared here (the one URL-literal module).
+   */
+  identityFromVideoUrl:
+    read("VITE_HUGPY_IDENTITY_FROM_VIDEO_URL") ?? `${apiBase}/video/identity-profiles/from-video`,
+  identityFromImagesUrl:
+    read("VITE_HUGPY_IDENTITY_FROM_IMAGES_URL") ?? `${apiBase}/video/identity-profiles/from-images`,
   /** Enqueue a crop job (spatial and/or temporal axis) on the job bus. */
   cropEnqueueUrl: read("VITE_HUGPY_CROP_ENQUEUE_URL") ?? `${apiBase}/video/jobs/crop`,
   /** Enqueue a frame-extract job (Frames & Models station) — one job → many frames. */
@@ -184,6 +209,18 @@ export const hugpyConfig = {
    * Processes surface never derives the path inline.
    */
   mediaJobsUrl: read("VITE_HUGPY_MEDIA_JOBS_URL") ?? `${apiBase}/video/jobs`,
+  /**
+   * LIVE tok/s telemetry for the generate workbench's Toks panel. Two endpoints,
+   * both same-origin `/api`, polled together every 2s by `useToks`:
+   *   • `toksRecentUrl`  GET → { entries:[{ ts, worker_id, worker_name, model_key,
+   *     tok_s, ttft_s, completion_tokens, config_key, ok }] } newest-first — the
+   *     live tail + the per-worker strip's source (avg computed from this window).
+   *   • `toksReportUrl`  GET → { groups:[{ worker_name, model_key, config_key, n,
+   *     mean_tok_s, p50_tok_s, p95_tok_s }] } sorted best mean first — the
+   *     best-config leaderboard. Declared here so the panel never derives the path.
+   */
+  toksRecentUrl: read("VITE_HUGPY_TOKS_RECENT_URL") ?? `${apiBase}/llm/toks/recent`,
+  toksReportUrl: read("VITE_HUGPY_TOKS_REPORT_URL") ?? `${apiBase}/llm/toks/report`,
   /**
    * Curated STUDIO clip presets for the Studio Clips station — GET → { presets: [{
    * id, name, description, capability:"i2v"|"t2v", width, height, fps, vram_budget_gb,
@@ -263,6 +300,13 @@ export const hugpyConfig = {
    */
   promptAssistUrl:
     read("VITE_HUGPY_PROMPT_ASSIST_URL") ?? `${apiBase}/video/prompt/assist`,
+  /**
+   * CINEMA PRODUCER (k120 slice 1): premise → full structured plan → per-segment
+   * {prompt, negative, seconds, joint}. The composer's 🎬 Produce action POSTs
+   * here and populates its segment rows from the reply.
+   */
+  producerPlanUrl:
+    read("VITE_HUGPY_PRODUCER_PLAN_URL") ?? `${apiBase}/video/producer/plan`,
   /**
    * STUDIO-ASSIST LIVE LOG (operator directive, 2026-07-31) — a stored record per
    * prompt-generate attempt: the UNTRUNCATED model reply, what was stripped

package/src/demo/demoFetch.ts

@@ -12,7 +12,7 @@
 import { hugpyConfig } from "../config";
 import * as fx from "./fixtures";
 import type { JobKind } from "./fixtures";
-import { nextGeneratedPrompt, enhancePrompt } from "./promptAssist";
+import { samplePromptFor, enhancePrompt } from "./promptAssist";
 
 // ── request introspection (same helpers as the media arm) ───────────────────
 function pathOf(input: RequestInfo | URL): string {
@@ -127,15 +127,24 @@ async function route(
   const kind = JOB_ROUTES[path];
   if (kind && method === "POST") {
     let sourceKind: string | null = null;
+    let submitted = "";
     try {
       const body = JSON.parse((await readBody(input, init)) || "{}") as {
         source?: { kind?: string };
+        parts?: Array<{ kind?: string; text?: string | null }>;
+        goals?: Array<{ prompt?: string | null }>;
+        prompt?: string;
       };
       sourceKind = body?.source?.kind ?? null;
+      submitted = [
+        ...(body?.parts ?? []).map((p) => (p?.kind === "text" ? p?.text ?? "" : "")),
+        ...(body?.goals ?? []).map((g) => g?.prompt ?? ""),
+        body?.prompt ?? "",
+      ].join(" ");
     } catch {
       /* body optional */
     }
-    return jsonResponse({ job_id: fx.enqueueJob(kind, sourceKind) });
+    return jsonResponse({ job_id: fx.enqueueJob(kind, sourceKind, submitted) });
   }
 
   // Job cancel (before poll — its path is a superset).
@@ -181,7 +190,7 @@ async function route(
     } catch {
       /* body optional — defaults stand */
     }
-    const prompt = mode === "detail" ? enhancePrompt(draft) : nextGeneratedPrompt();
+    const prompt = mode === "detail" ? enhancePrompt(draft) : samplePromptFor(kind);
     return jsonResponse({ prompt, model: "demo-showroom-llm", kind });
   }
 
@@ -252,6 +261,39 @@ async function route(
     return jsonResponse({ error: "operator authentication required" }, 401);
   }
 
+  // STUDIO CLIP enqueue (Clip tab, POST /video/studio/i2v → {job_id}) and
+  // CINEMA enqueue (StudioMovieComposer, POST /video/studio/movie → {job_id}).
+  // Both poll the generic GET /video/jobs/<id> above, so the whole render
+  // lifecycle is canned: queued → running (staged progress) → done with
+  // bundled clips (cinema: segments + assembled movie LAST, the contract the
+  // composer plays back).
+  if ((path === "/video/studio/i2v" || path === "/video/studio/movie") && method === "POST") {
+    let submitted = "";
+    try {
+      const body = JSON.parse((await readBody(input, init)) || "{}") as {
+        prompt?: string;
+        goals?: Array<{ prompt?: string | null }>;
+      };
+      submitted = [body?.prompt ?? "", ...(body?.goals ?? []).map((g) => g?.prompt ?? "")].join(" ");
+    } catch { /* body optional */ }
+    const k = path.endsWith("i2v") ? "studio_i2v" : "generate_studio_movie";
+    return jsonResponse({ job_id: fx.enqueueJob(k as JobKind, null, submitted) });
+  }
+  // Cinema session pause/resume + clip archive/unarchive — acknowledge; the
+  // canned session store is empty so there is nothing durable to mutate.
+  const studioAct = path.match(
+    /^\/video\/studio\/(?:movie\/[^/]+\/(pause|resume)|clip\/[^/]+\/(archive|unarchive))$/,
+  );
+  if (studioAct && method === "POST") {
+    return jsonResponse({ ok: true });
+  }
+  // Studio tester sweep — operator-gated on the real backend; the brochure
+  // principal is not an operator, so the honest answer is 401 (same shape as
+  // the video-share keys above).
+  if (path === "/video/studio/tester" && method === "POST") {
+    return jsonResponse({ error: "operator authentication required" }, 401);
+  }
+
   // Curated presets for the Generate-station dropdown + the per-id pre-warm.
   if (path === "/video/presets" && method === "GET") {
     return jsonResponse(fx.PRESETS);
@@ -275,15 +317,92 @@ async function route(
     return jsonResponse(found ?? { error: { code: "unknown_preset" } }, found ? 200 : 404);
   }
 
+  // Assist LOG surfaces (audit 2026-08-13b): models dropdown + log fetch.
+  // The SSE stream itself is handled by the FakeEventSource below (EventSource
+  // BYPASSES window.fetch — unshimmed it hit the demo host's nginx 404 and
+  // auto-reconnected forever: the reported "gets stuck" loop).
+  if (path === "/video/prompt/assist/models" && method === "GET") {
+    return jsonResponse({ models: [{ id: "demo-showroom-llm", label: "demo-showroom-llm" }] });
+  }
+  if (path === "/video/prompt/assist/log" && method === "GET") {
+    return jsonResponse({ lines: [] });
+  }
+  if (path === "/video/prompt/intent" && method === "POST") {
+    return jsonResponse({ ok: false }, 200);
+  }
+  if (path === "/video/render/presets" && method === "GET") {
+    return jsonResponse({ presets: [] });
+  }
+  const chatCancel = path.match(/^\/llm\/chat\/cancel\/[^/]+$/);
+  if (chatCancel && method === "POST") {
+    return jsonResponse({ ok: true });
+  }
+  // Identity flows are operator/member-gated on the real backend — honest 401
+  // (the SharePanel/keys pattern) keeps those affordances hidden in the demo.
+  if (path.startsWith("/video/identity-profiles/") && method === "POST") {
+    return jsonResponse({ error: "operator authentication required" }, 401);
+  }
+  // Single cinema-session probe (resume path) — the showroom has no durable
+  // movie dirs, so an unknown id is the honest answer.
+  const movieOne = path.match(/^\/video\/studio\/movie\/[^/]+$/);
+  if (movieOne && method === "GET") {
+    return jsonResponse({ ok: false, error: "unknown movie" }, 404);
+  }
+
+  // BACKSTOP (2026-08-13): anything addressed to the API base that no route
+  // above canned must FAIL FAST AND HONESTLY — never fall through to the real
+  // fetch. On the demo host nginx hard-404s /api, so a fall-through shows a
+  // spinner that dies slowly ("renders a while, then fails" — the exact
+  // reported symptom class). A crisp canned 501 lets every surface fail-soft
+  // immediately instead. Bundled assets / HMR never carry the API prefix, so
+  // the pass-through below still serves them.
+  if (pathname !== path || path.startsWith("/video/") || path.startsWith("/v1/")) {
+    return jsonResponse(
+      { error: "showroom: this surface is not canned in the demo" },
+      501,
+    );
+  }
+
   return null; // not a hugpy call — pass through (bundled assets, HMR, …)
 }
 
 // ── install / uninstall ──────────────────────────────────────────────────────
 let _realFetch: typeof window.fetch | null = null;
+let _realES: typeof window.EventSource | null = null;
+
+// EventSource does NOT route through window.fetch, so the canned transport
+// must shim it separately: a silent, open stream for the assist log (no
+// events, no reconnect churn), pass-through for anything else.
+class FakeEventSource {
+  url: string;
+  readyState = 0;
+  onopen: ((e: Event) => void) | null = null;
+  onmessage: ((e: MessageEvent) => void) | null = null;
+  onerror: ((e: Event) => void) | null = null;
+  constructor(url: string | URL) {
+    this.url = String(url);
+    setTimeout(() => {
+      this.readyState = 1;
+      this.onopen?.(new Event("open"));
+    }, 50);
+  }
+  addEventListener(type: string, fn: (e: Event) => void): void {
+    if (type === "open") this.onopen = fn as (e: Event) => void;
+  }
+  removeEventListener(): void {}
+  close(): void { this.readyState = 2; }
+}
 
 export function installDemoTransport(): void {
   if (_realFetch) return; // already installed
   _realFetch = window.fetch.bind(window);
+  _realES = window.EventSource;
+  window.EventSource = function (url: string | URL, init?: EventSourceInit) {
+    if (String(url).includes("/prompt/assist/log/stream")) {
+      return new FakeEventSource(url) as unknown as EventSource;
+    }
+    return new _realES!(url, init);
+  } as unknown as typeof window.EventSource;
   window.fetch = async (
     input: RequestInfo | URL,
     init?: RequestInit,
@@ -302,4 +421,8 @@ export function uninstallDemoTransport(): void {
   if (!_realFetch) return;
   window.fetch = _realFetch;
   _realFetch = null;
+  if (_realES) {
+    window.EventSource = _realES;
+    _realES = null;
+  }
 }

package/src/demo/fixtures.ts

@@ -1,33 +1,37 @@
 // Canned fixtures for the video-intelligence demo (?demo=1).
 //
-// Every MediaRef here points its `uri` at a Vite-BUNDLED asset URL rather than a
+// Every MediaRef here points its `uri` at a HOSTED demo-media URL rather than a
 // server store key. That matters because <img>/<video> element loads do NOT go
 // through window.fetch (the shim can't intercept them) — so in canned mode
-// mediaBytesUrl() passes these absolute asset URLs straight through and the
-// browser loads the bundled bytes directly. See config.ts.
+// mediaBytesUrl() passes these absolute URLs straight through and the browser
+// loads the hosted bytes directly. See config.ts and demo/mediaBase.ts.
 import type { MediaRef } from "../video/contract";
-
-// Real sample media dropped by the operator under assets/sampels/ (note: the dir
-// is intentionally spelled "sampels" — do NOT rename it). Imported in place as
-// Vite asset URLs (relative from src/demo/), which resolve to bundled hashed URLs.
-import demoClipUrl from "../../assets/sampels/scenes/woman.mp4";
-import demoCropUrl from "../../assets/sampels/scenes/man.mp4";
-import demoAudioUrl from "./assets/demo-audio.mp3"; // no audio sample provided — kept
-import frame1 from "../../assets/sampels/images/forrest/frame_00000.png";
-import frame2 from "../../assets/sampels/images/forrest/frame_00001.png";
-import frame3 from "../../assets/sampels/images/forrest/frame_00002.png";
-import frame4 from "../../assets/sampels/images/forrest/frame_00003.png";
-import frame5 from "../../assets/sampels/images/forrest/frame_00004.png";
-import frame6 from "../../assets/sampels/images/forrest/frame_00005.png";
-import gen1 from "../../assets/sampels/images/shenzo/frame_00000.png";
-import gen2 from "../../assets/sampels/images/bycycle/frame_00000.png";
+import { takeSet, sectionFor, type SampleSet } from "./sampleSets";
+import { SAMPLES2, type Sample2 } from "./sampleData";
+
+// Real sample media dropped by the operator — the sampels/ tree now lives at
+// the HOSTED media base (default https://hugpy.ai/demo-media/sampels/; canonical
+// copy /var/www/hugpy-media/ on the hugpy.ai VM). Note: the dir is intentionally
+// spelled "sampels" — do NOT rename it in the hosted tree.
+import { demoMedia } from "./mediaBase";
+const demoClipUrl = demoMedia("sampels/scenes/woman.mp4");
+const demoCropUrl = demoMedia("sampels/scenes/man.mp4");
+const demoAudioUrl = demoMedia("demo-audio.mp3"); // no audio sample provided — kept
+const frame1 = demoMedia("sampels/images/forrest/frame_00000.png");
+const frame2 = demoMedia("sampels/images/forrest/frame_00001.png");
+const frame3 = demoMedia("sampels/images/forrest/frame_00002.png");
+const frame4 = demoMedia("sampels/images/forrest/frame_00003.png");
+const frame5 = demoMedia("sampels/images/forrest/frame_00004.png");
+const frame6 = demoMedia("sampels/images/forrest/frame_00005.png");
+const gen1 = demoMedia("sampels/images/shenzo/frame_00000.png");
+const gen2 = demoMedia("sampels/images/bycycle/frame_00000.png");
 // The forrest scene's assembled clip (single .mp4 in that folder — hashed name).
-import forrestSceneUrl from "../../assets/sampels/images/forrest/ff23090611b844a6b85c224f388bd542.mp4";
+const forrestSceneUrl = demoMedia("sampels/images/forrest/ff23090611b844a6b85c224f388bd542.mp4");
 // The real 2-segment "keeper-matrix" sailboat movie (see movie.json for numbers).
-import movieUrl from "../../assets/sampels/studio_movies/keeper-matrix/movie.mp4";
-import movieSeg0Url from "../../assets/sampels/studio_movies/keeper-matrix/segment_00/64854c6a21d47ce10b23e884e12de448b25bfb0a375d33238dd0bec8056c076d/clip.mp4";
-import movieSeg1Url from "../../assets/sampels/studio_movies/keeper-matrix/segment_01/cc926b44a42b90d7d291a4e50e3859458306c207a17c718086a3466e4049d6c6/clip.mp4";
-import movieSeg1BranchUrl from "../../assets/sampels/studio_movies/keeper-matrix/segment_01/branch.png";
+const movieUrl = demoMedia("sampels/studio_movies/keeper-matrix/movie.mp4");
+const movieSeg0Url = demoMedia("sampels/studio_movies/keeper-matrix/segment_00/64854c6a21d47ce10b23e884e12de448b25bfb0a375d33238dd0bec8056c076d/clip.mp4");
+const movieSeg1Url = demoMedia("sampels/studio_movies/keeper-matrix/segment_01/cc926b44a42b90d7d291a4e50e3859458306c207a17c718086a3466e4049d6c6/clip.mp4");
+const movieSeg1BranchUrl = demoMedia("sampels/studio_movies/keeper-matrix/segment_01/branch.png");
 
 // ── the worked example: one ingested clip + derived assets ──────────────────
 
@@ -481,25 +485,77 @@ export type JobKind =
   | "audio_extract"
   | "generate_image"
   | "generate_scene"
-  | "generate_movie";
+  | "generate_movie"
+  | "studio_i2v"
+  | "generate_studio_movie";
 
 interface CannedJob {
   kind: JobKind;
   enqueuedAt: number;
   sourceKind: string | null; // MediaRef.kind of the request source, when sent
+  // Pre-rendered SAMPLE SET picked at enqueue (generate kinds only) — stored
+  // on the job so every poll answers with the SAME render, and so the ✨-armed
+  // prompt⇄media pairing survives the queued→running→done lifecycle.
+  sample?: SampleSet;
+  // 2026-08-13b: RECORDED-ENVELOPE sample (sampleData.ts) — matched against
+  // the SUBMITTED prompt at enqueue, so prompt⇄render consistency is
+  // structural, not cursor-based. When set, jobStatus replays this envelope
+  // verbatim on done (production's own wire shape — drift-proof).
+  replay?: Sample2;
 }
 
 const jobs = new Map<string, CannedJob>();
 let seq = 0;
 
-export function enqueueJob(kind: JobKind, sourceKind: string | null): string {
+const norm = (t: string) => t.toLowerCase().replace(/[^a-z0-9 ]+/g, "").replace(/\s+/g, " ").trim();
+
+const SECTION2: Record<string, string> = {
+  generate_image: "scene", generate_scene: "scene", generate_movie: "movie",
+  studio_i2v: "clip", generate_studio_movie: "cinema",
+};
+
+const rr2: Record<string, number> = {};
+
+/** Pick the recorded sample whose prompt matches the submitted text; else
+ *  round-robin within the job's section. Matching is normalized substring in
+ *  BOTH directions, so an assist-provided prompt (verbatim) and a lightly
+ *  edited one both land on their render. */
+function pickReplay(kind: JobKind, submitted: string): Sample2 | undefined {
+  const section = SECTION2[kind];
+  if (!section) return undefined;
+  const pool = SAMPLES2.filter((x) => x.kind === section);
+  if (!pool.length) return undefined;
+  const t = norm(submitted);
+  if (t.length > 8) {
+    for (const x of pool) {
+      for (const pr of x.prompts) {
+        const n = norm(pr || "");
+        if (n && (n.includes(t) || t.includes(n))) return x;
+      }
+    }
+  }
+  const i = (rr2[section] = ((rr2[section] ?? -1) + 1) % pool.length);
+  return pool[i];
+}
+
+export function enqueueJob(kind: JobKind, sourceKind: string | null,
+                           submittedPrompt = ""): string {
   seq += 1;
   const id = `demo-job-${kind}-${seq}`;
-  jobs.set(id, { kind, enqueuedAt: Date.now(), sourceKind });
+  const job: CannedJob = { kind, enqueuedAt: Date.now(), sourceKind };
+  // The demo never touches a GPU (operator ruling): generate kinds replay a
+  // RECORDED production envelope chosen by the submitted prompt, with the
+  // legacy curated sets as fallback for anything unmatched.
+  if (kind.startsWith("generate") || kind === "studio_i2v") {
+    job.replay = pickReplay(kind, submittedPrompt);
+    if (!job.replay) job.sample = takeSet(sectionFor(kind));
+  }
+  jobs.set(id, job);
   return id;
 }
 
 function outputsFor(job: CannedJob): MediaRef[] {
+  if (job.sample) return job.sample.outputs;
   switch (job.kind) {
     case "crop":
       // image crop → a still; video crop → the cropped clip
@@ -517,6 +573,13 @@ function outputsFor(job: CannedJob): MediaRef[] {
       // Per-segment clips (as segment "frames") + the assembled movie.mp4 LAST
       // (movie contract). The real keeper-matrix movie has 2 segments.
       return [demoMovieSeg0Clip, demoMovieSeg1Clip, demoMovieClip];
+    case "studio_i2v":
+      // A studio CLIP render: one clip out (the same bundled scene clip).
+      return [demoSceneClip];
+    case "generate_studio_movie":
+      // CINEMA: segment clips + the assembled movie LAST — same contract as
+      // generate_movie, which is exactly how the composer reads it.
+      return [demoMovieSeg0Clip, demoMovieSeg1Clip, demoMovieClip];
   }
 }
 
@@ -778,7 +841,8 @@ export function jobStatus(id: string): {
   }
   const age = Date.now() - job.enqueuedAt;
   const isGen = job.kind.startsWith("generate");
-  const isMovie = job.kind === "generate_movie";
+  const isMovie =
+    job.kind === "generate_movie" || job.kind === "generate_studio_movie";
   // A movie is many segments — give it a longer believable run than a scene/image.
   const runFor = isMovie ? 5200 : isGen ? 3500 : 1800;
   // Unclaimed window: the job is enqueued but no worker has picked it up yet. The
@@ -801,6 +865,12 @@ export function jobStatus(id: string): {
           : null,
     };
   }
+  if (job.replay) {
+    const result = JSON.parse(
+      JSON.stringify(job.replay.result).replace(/@@JOB@@/g, id),
+    ) as Record<string, unknown>;
+    return { job_id: id, status: "done", result };
+  }
   return {
     job_id: id,
     status: "done",

package/src/demo/mediaBase.ts

@@ -0,0 +1,62 @@
+// Demo media base — where the canned-demo sample tree is served from.
+//
+// The demo media (~36M of mp4/png samples) is NOT bundled; it lives at a
+// hosted base (default https://hugpy.ai/demo-media, see config.ts — the ONE
+// module permitted to hold URL literals). Resolved ONCE at module load, same
+// as demo/mode.ts. Precedence:
+//   1. ?mediaBase= query param (http(s) or path-absolute only)
+//   2. window.__HUGPY_MEDIA_BASE__ (non-empty string — servers/self-hosters
+//      set this by rewriting the index.html marker; see index.html)
+//   3. VITE_HUGPY_DEMO_MEDIA_BASE (build-time, read in config.ts)
+//   4. the config.ts default.
+
+import { hugpyConfig } from "../config";
+
+declare global {
+  interface Window {
+    __HUGPY_MEDIA_BASE__?: string | null;
+  }
+}
+
+function stripTrailingSlash(url: string): string {
+  return url.replace(/\/+$/, "");
+}
+
+/** Accept only http(s) URLs or path-absolute ("/...") bases. */
+function acceptable(raw: string): boolean {
+  return /^(https?:\/\/|\/)/i.test(raw);
+}
+
+function resolve(): string {
+  // 1. ?mediaBase= — same query-param precedent as demo/mode.ts (?demo=).
+  try {
+    const params = new URLSearchParams(
+      typeof window !== "undefined" ? window.location.search : "",
+    );
+    const raw = (params.get("mediaBase") || "").trim();
+    if (raw && acceptable(raw)) return stripTrailingSlash(raw);
+  } catch {
+    /* fall through */
+  }
+
+  // 2. window.__HUGPY_MEDIA_BASE__ — server-injected (index.html marker).
+  try {
+    const injected =
+      typeof window !== "undefined" ? window.__HUGPY_MEDIA_BASE__ : null;
+    if (typeof injected === "string" && injected.trim()) {
+      return stripTrailingSlash(injected.trim());
+    }
+  } catch {
+    /* fall through */
+  }
+
+  // 3./4. Build-time env override or the config default (both in config.ts).
+  return hugpyConfig.demoMediaBase;
+}
+
+const base = resolve();
+
+/** Absolute URL for a demo media file, e.g. demoMedia("generate2/s0.png"). */
+export function demoMedia(relPath: string): string {
+  return `${base}/${relPath}`;
+}

package/src/demo/promptAssist.ts

@@ -153,6 +153,31 @@ let _lastGenerated: string | null = null;
  * same one twice in a row" a hard guarantee (bounded retry, then a forced tail
  * descriptor so it always terminates even in the degenerate single-bank case).
  */
+import { assistPrompt, sectionFor } from "./sampleSets";
+import { SAMPLES2 } from "./sampleData";
+
+const s2cursor: Record<string, number> = {};
+
+/**
+ * 2026-08-13 (operator ruling): ✨ generate hands out the REAL prompts that
+ * produced the bundled sample renders for the requesting section, and ARMS
+ * that sample so the next generate renders exactly that media (sampleSets.ts).
+ * The fragment-bank composer below stays as the implementation detail of
+ * `enhancePrompt` only.
+ */
+export function samplePromptFor(kind: string): string {
+  // Prefer the RECORDED samples (sampleData.ts): the prompt handed out is one
+  // that provably produced a bundled render, and enqueue-side matching
+  // (fixtures.pickReplay) then replays exactly that envelope.
+  const section = sectionFor(kind === "image" ? "scene" : kind);
+  const pool = SAMPLES2.filter((x) => x.kind === section && x.prompts.length);
+  if (pool.length) {
+    const i = (s2cursor[section] = ((s2cursor[section] ?? -1) + 1) % pool.length);
+    return pool[i].prompts.join("\n\n");
+  }
+  return assistPrompt(sectionFor(kind));
+}
+
 export function nextGeneratedPrompt(): string {
   let candidate = composePrompt();
   for (let tries = 0; tries < 8 && candidate === _lastGenerated; tries++) {