@hugpy/video-intelligence-ui 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hugpy/video-intelligence-ui",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "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).",
@@ -29,8 +29,6 @@
     "entry.tsx",
     "index.html",
     "assets",
-    "help",
-    "navbar",
     "vite.config.ts",
     "tsconfig.json",
     "LICENSE"

package/src/config.ts

@@ -58,6 +58,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 +201,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 +292,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

@@ -6,6 +6,8 @@
 // mediaBytesUrl() passes these absolute asset URLs straight through and the
 // browser loads the bundled bytes directly. See config.ts.
 import type { MediaRef } from "../video/contract";
+import { takeSet, sectionFor, type SampleSet } from "./sampleSets";
+import { SAMPLES2, type Sample2 } from "./sampleData";
 
 // 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
@@ -481,25 +483,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 +571,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 +839,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 +863,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/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++) {