@hugpy/video-intelligence-ui 0.1.0

package/src/stations/useGenerateRowJobs.ts

@@ -0,0 +1,184 @@
+// The image TESTER's enqueue surface: N prompt rows -> N generate jobs, each
+// with its OWN settings, tracked independently so they can be compared side by
+// side.
+//
+// This is the multi-job sibling of useGenerateJob (ONE prompt -> ONE job). It
+// rides the same session-wide jobTracker, so a tester run keeps going (and lands
+// in the library) after the station unmounts or the page reloads — but it books
+// its jobs under a DISTINCT station key.
+//
+// That station key matters. useGenerateJob resolves "my job" as the NEWEST
+// record with station === "generate", so if tester rows were filed under the
+// same key, every row would hijack the base composer's result tile and the last
+// row to enqueue would masquerade as the single-prompt run. Filing tester jobs
+// under "generate-tester" keeps the two surfaces from ever reading each other's
+// records.
+import { useCallback, useMemo, useState } from "react";
+import { request, okValue, errorOf, describeAppError } from "../transport/client";
+import { hugpyConfig } from "../config";
+import {
+  enqueueResultSchema,
+  promptSummary,
+  isMovieProgress,
+  type GenerateImageRequest,
+  type JobStatus,
+  type MediaRef,
+  type JobProgress,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  dismissTerminal,
+  isJobActive,
+} from "../video/jobTracker";
+
+/** Live state of ONE tester row's job. */
+export interface RowJobState {
+  jobId: string | null;
+  status: JobStatus;
+  output: MediaRef | null;
+  error: string | null;
+  running: boolean;
+  progress: JobProgress | null;
+}
+
+export interface GenerateRowJobsApi {
+  /** Row id -> that row's job state. Rows never run are absent. */
+  byRow: Record<string, RowJobState>;
+  /** True while ANY row is enqueuing or polling. */
+  anyRunning: boolean;
+  /** Enqueue one job per row. Replaces the previous tester run. */
+  runRows: (rows: { rowId: string; req: GenerateImageRequest }[]) => void;
+  /** Forget this tester's finished jobs. */
+  reset: () => void;
+}
+
+const STATION = "generate-tester";
+
+const IDLE: RowJobState = {
+  jobId: null,
+  status: null,
+  output: null,
+  error: null,
+  running: false,
+  progress: null,
+};
+
+export function useGenerateRowJobs(): GenerateRowJobsApi {
+  const records = useJobTracker();
+  // rowId -> jobId for the CURRENT run. Rebuilt on every runRows so a re-run
+  // never shows a stale row's previous image beside a fresh one.
+  const [jobByRow, setJobByRow] = useState<Record<string, string>>({});
+  // rowId -> enqueue-time failure (never reached a job_id, so the tracker has
+  // nothing to report for it).
+  const [enqueueErrors, setEnqueueErrors] = useState<Record<string, string>>({});
+  const [enqueuing, setEnqueuing] = useState<Record<string, boolean>>({});
+
+  const byRow = useMemo<Record<string, RowJobState>>(() => {
+    const mine = new Map(
+      records
+        .filter((r) => r.station === STATION && r.kind === "generate_image")
+        .map((r) => [r.jobId, r] as const),
+    );
+    const out: Record<string, RowJobState> = {};
+    const rowIds = new Set([
+      ...Object.keys(jobByRow),
+      ...Object.keys(enqueueErrors),
+      ...Object.keys(enqueuing),
+    ]);
+    for (const rowId of rowIds) {
+      const enqErr = enqueueErrors[rowId];
+      if (enqErr) {
+        out[rowId] = { ...IDLE, status: "failed", error: enqErr };
+        continue;
+      }
+      const jobId = jobByRow[rowId];
+      const rec = jobId ? mine.get(jobId) : undefined;
+      if (!rec) {
+        // Enqueued but no job_id yet (or the tracker dropped it): running only
+        // while the POST is genuinely in flight, so a lost record reads idle
+        // rather than spinning forever.
+        out[rowId] = { ...IDLE, running: !!enqueuing[rowId] };
+        continue;
+      }
+      out[rowId] = {
+        jobId: rec.jobId,
+        status: rec.status,
+        output: rec.outputs[0] ?? null,
+        error:
+          rec.error ??
+          (rec.expired ? "This job is no longer tracked by the server." : null),
+        running: isJobActive(rec),
+        // generate_image only ever carries flat progress — narrow off the
+        // tracker's union so a movie blob can never land here.
+        progress:
+          rec.progress && !isMovieProgress(rec.progress) ? rec.progress : null,
+      };
+    }
+    return out;
+  }, [records, jobByRow, enqueueErrors, enqueuing]);
+
+  const anyRunning = useMemo(
+    () => Object.keys(byRow).some((rowId) => byRow[rowId].running),
+    [byRow],
+  );
+
+  const reset = useCallback(() => {
+    setJobByRow({});
+    setEnqueueErrors({});
+    setEnqueuing({});
+    dismissTerminal(STATION);
+  }, []);
+
+  const runRows = useCallback(
+    (rows: { rowId: string; req: GenerateImageRequest }[]) => {
+      if (rows.length === 0) return;
+      // Clear the previous run up front so no row shows a stale result while the
+      // new one enqueues.
+      setJobByRow({});
+      setEnqueueErrors({});
+      setEnqueuing(Object.fromEntries(rows.map((r) => [r.rowId, true])));
+
+      for (const { rowId, req } of rows) {
+        const enqueuedAt = Date.now();
+        void request<unknown>(hugpyConfig.generateEnqueueUrl, {
+          method: "POST",
+          body: JSON.stringify(req),
+          headers: { "Content-Type": "application/json" },
+          meta: { specKey: STATION, operation: "generate_image.enqueue" },
+        }).then((r) => {
+          setEnqueuing((prev) => ({ ...prev, [rowId]: false }));
+          if (!r.ok) {
+            setEnqueueErrors((prev) => ({
+              ...prev,
+              [rowId]: describeAppError(errorOf(r)),
+            }));
+            return;
+          }
+          const parsed = enqueueResultSchema.safeParse(okValue(r));
+          if (!parsed.success) {
+            setEnqueueErrors((prev) => ({
+              ...prev,
+              [rowId]: "Malformed enqueue response.",
+            }));
+            return;
+          }
+          const jobId = parsed.data.job_id;
+          trackJob({
+            jobId,
+            kind: "generate_image",
+            station: STATION,
+            label: "tester row",
+            enqueuedAt,
+            prompt: promptSummary(req.parts),
+            model: req.model_id,
+          });
+          setJobByRow((prev) => ({ ...prev, [rowId]: jobId }));
+        });
+      }
+    },
+    [],
+  );
+
+  return { byRow, anyRunning, runRows, reset };
+}

package/src/stations/useGenerateSceneJob.ts

@@ -0,0 +1,156 @@
+// The Generate station's SCENE enqueue surface — Scene mode's sibling to
+// useGenerateJob. ONE ordered multimodal prompt → ONE generate_scene job → N
+// consecutive image frames + (optionally) one assembled mp4 clip. Cloned from
+// useGenerateJob: this hook owns request-body construction and POSTs it through
+// request<T>() + config URLs; the moment it has a job_id it hands the job to
+// jobTracker.trackJob and stops owning any polling or job state. Polling, the
+// n_frames-scaled scene poll cap (generateScenePollCapMs, plumbed via
+// trackJob.nFrames → capFor), the terminal parse, and the centralized library
+// push (frames + the clip, origin "generate") all live in jobTracker — so a scene
+// kicked off here keeps running (and lands in the library) even after the user
+// switches sub-tabs (which unmounts this station) or reloads the page.
+//
+// The ONLY shape difference from useGenerateJob is the output: Scene mode reads
+// the FULL result.outputs array (N image refs, then the clip last), so this hook
+// exposes `outputs: MediaRef[]` instead of a single `output`.
+import { useCallback, useMemo, useRef, useState } from "react";
+import { request, okValue, errorOf, describeAppError } from "../transport/client";
+import { hugpyConfig } from "../config";
+import {
+  enqueueResultSchema,
+  promptSummary,
+  isMovieProgress,
+  type GenerateSceneRequest,
+  type JobStatus,
+  type MediaRef,
+  type JobProgress,
+  type JobProject,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  dismissTerminal,
+  isJobActive,
+} from "../video/jobTracker";
+
+export interface GenerateSceneJobApi {
+  /** Server job id once enqueued, else null. */
+  jobId: string | null;
+  /** Latest polled status (null = idle or enqueued-but-not-yet-claimed). */
+  status: JobStatus;
+  /** ALL produced MediaRefs (N image frames, then the clip last if assembled). */
+  outputs: MediaRef[];
+  /** Human message on failure (enqueue error or job error). */
+  error: string | null;
+  /** Poll cap reached while non-terminal — NOT a failure. */
+  capped: boolean;
+  /** True while enqueuing or polling a non-terminal job. */
+  running: boolean;
+  /** Live per-run progress while running (done/total, stage, step, frames-so-far); null otherwise. */
+  progress: JobProgress | null;
+  /** Auto-archive project this scene was saved into (populated on done); null otherwise. */
+  project: JobProject | null;
+  /** Enqueue ONE generate_scene job and begin polling. Replaces any prior run. */
+  run: (req: GenerateSceneRequest) => void;
+  /** Re-anchor the poll clock and resume polling a capped job. Clears `capped`. */
+  resume: () => void;
+  /** Forget this station's finished job (called when the composer is cleared). */
+  reset: () => void;
+}
+
+const STATION = "generate";
+
+export function useGenerateSceneJob(): GenerateSceneJobApi {
+  const records = useJobTracker();
+  const [currentJobId, setCurrentJobId] = useState<string | null>(null);
+  const [enqueuing, setEnqueuing] = useState<boolean>(false);
+  const [enqueueError, setEnqueueError] = useState<string | null>(null);
+
+  const record = useMemo(() => {
+    const mine = records.filter(
+      (r) => r.station === STATION && r.kind === "generate_scene",
+    );
+    if (currentJobId) return mine.find((r) => r.jobId === currentJobId) ?? null;
+    if (enqueuing) return null;
+    return mine.slice().sort((a, b) => b.enqueuedAt - a.enqueuedAt)[0] ?? null;
+  }, [records, currentJobId, enqueuing]);
+
+  const jobIdRef = useRef<string | null>(record?.jobId ?? null);
+  jobIdRef.current = record?.jobId ?? null;
+
+  const reset = useCallback(() => {
+    setCurrentJobId(null);
+    setEnqueuing(false);
+    setEnqueueError(null);
+    dismissTerminal(STATION);
+  }, []);
+
+  const resume = useCallback(() => {
+    const id = jobIdRef.current;
+    if (id) resumeJob(id);
+  }, []);
+
+  const run = useCallback((req: GenerateSceneRequest) => {
+    setCurrentJobId(null);
+    setEnqueueError(null);
+    setEnqueuing(true);
+    const enqueuedAt = Date.now();
+
+    void request<unknown>(hugpyConfig.generateSceneEnqueueUrl, {
+      method: "POST",
+      body: JSON.stringify(req),
+      headers: { "Content-Type": "application/json" },
+      meta: { specKey: STATION, operation: "generate_scene.enqueue" },
+    }).then((r) => {
+      setEnqueuing(false);
+      if (!r.ok) {
+        setEnqueueError(describeAppError(errorOf(r)));
+        return;
+      }
+      const parsed = enqueueResultSchema.safeParse(okValue(r));
+      if (!parsed.success) {
+        setEnqueueError("Malformed enqueue response.");
+        return;
+      }
+      const jobId = parsed.data.job_id;
+      trackJob({
+        jobId,
+        kind: "generate_scene",
+        station: STATION,
+        label: "generate scene",
+        enqueuedAt,
+        nFrames: req.n_frames,
+        chain: req.chain,
+        prompt: promptSummary(req.parts),
+        model: req.model_id,
+      });
+      setCurrentJobId(jobId);
+    });
+  }, []);
+
+  const status: JobStatus = enqueueError ? "failed" : record?.status ?? null;
+  const error =
+    enqueueError ??
+    record?.error ??
+    (record?.expired ? "This job is no longer tracked by the server." : null);
+
+  // A generate_scene record only ever carries flat progress; narrow off the tracker's
+  // union (never a nested movie blob for this kind).
+  const progress: JobProgress | null =
+    record?.progress && !isMovieProgress(record.progress) ? record.progress : null;
+
+  return {
+    jobId: record?.jobId ?? null,
+    status,
+    outputs: record?.outputs ?? [],
+    error,
+    capped: record?.capped ?? false,
+    running: enqueuing || (record != null && isJobActive(record)),
+    progress,
+    project: record?.project ?? null,
+    run,
+    resume,
+    reset,
+  };
+}

package/src/stations/useGenerateSceneRowJobs.ts

@@ -0,0 +1,282 @@
+// The Scene composer's PER-PART enqueue surface: N independent scene prompts ->
+// N generate_scene jobs, each with its OWN settings, tracked independently so
+// each prompt component produces and renders its own output ("2 prompts = 2
+// outputs"). Rides the session-wide jobTracker (so a fan-out survives an unmount
+// / reload) under a DISTINCT station key.
+//
+// SEQUENTIAL (operator 2026-08-10): the jobs run ONE AT A TIME — a component's
+// generation must fully finish before the next starts. On a single GPU that both
+// matches "test all models" reality (no concurrency benefit for big models) and
+// avoids the VRAM contention / polite-load refusals that a simultaneous fan-out
+// hit (a 17 GB model can't load while N others are mid-load). Not-yet-started
+// rows show as "queued"; each output appears as its model completes.
+import { useCallback, useMemo, useRef, useState } from "react";
+import { request, okValue, errorOf, describeAppError } from "../transport/client";
+import { hugpyConfig } from "../config";
+import {
+  enqueueResultSchema,
+  promptSummary,
+  isMovieProgress,
+  type GenerateSceneRequest,
+  type JobStatus,
+  type MediaRef,
+  type JobProgress,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  dismissTerminal,
+  isJobActive,
+  type TrackedJob,
+} from "../video/jobTracker";
+
+/** Live state of ONE scene part's job. */
+export interface SceneRowJobState {
+  jobId: string | null;
+  status: JobStatus;
+  /** ALL produced MediaRefs (N image frames, then the clip last if assembled). */
+  outputs: MediaRef[];
+  error: string | null;
+  running: boolean;
+  /** Waiting its turn in the sequential queue (not yet submitted). */
+  queued: boolean;
+  /** Poll cap reached while non-terminal — NOT a failure; resume() re-anchors it. */
+  capped: boolean;
+  progress: JobProgress | null;
+}
+
+export interface GenerateSceneRowJobsApi {
+  /** Part id -> that part's job state. Parts never run are absent. */
+  byRow: Record<string, SceneRowJobState>;
+  /** True while ANY part is queued, enqueuing, or polling. */
+  anyRunning: boolean;
+  /** Enqueue one scene job per part — SEQUENTIALLY. Replaces the previous fan-out. */
+  runRows: (rows: { rowId: string; req: GenerateSceneRequest }[]) => void;
+  /** Re-anchor the poll clock and resume polling a capped part's job. */
+  resume: (rowId: string) => void;
+  /** Forget this surface's finished jobs and stop any in-flight sequence. */
+  reset: () => void;
+}
+
+const STATION = "generate-scene-parts";
+const WAIT_CAP_MS = 20 * 60 * 1000; // don't let one wedged job stall the whole sweep
+
+const IDLE: SceneRowJobState = {
+  jobId: null,
+  status: null,
+  outputs: [],
+  error: null,
+  running: false,
+  queued: false,
+  capped: false,
+  progress: null,
+};
+
+const sleep = (ms: number) => new Promise<void>((res) => setTimeout(res, ms));
+
+export function useGenerateSceneRowJobs(): GenerateSceneRowJobsApi {
+  const records = useJobTracker();
+  // Latest tracker records, readable inside the async sequential loop (no stale
+  // closure) so it can wait for a job to go terminal using the tracker's own poll.
+  const recordsRef = useRef(records);
+  recordsRef.current = records;
+
+  const [jobByRow, setJobByRow] = useState<Record<string, string>>({});
+  const [enqueueErrors, setEnqueueErrors] = useState<Record<string, string>>({});
+  const [enqueuing, setEnqueuing] = useState<Record<string, boolean>>({});
+  const [queued, setQueued] = useState<Record<string, boolean>>({});
+  // Bumped on each runRows / reset so a superseded sequence stops itself.
+  const runSeq = useRef(0);
+
+  const byRow = useMemo<Record<string, SceneRowJobState>>(() => {
+    const mineByJob = new Map(
+      records
+        .filter((r) => r.station === STATION && r.kind === "generate_scene")
+        .map((r) => [r.jobId, r] as const),
+    );
+    const newestByRowKey = new Map<string, TrackedJob>();
+    for (const r of records) {
+      if (r.station !== STATION || r.kind !== "generate_scene" || !r.rowKey) continue;
+      const prev = newestByRowKey.get(r.rowKey);
+      if (!prev || r.enqueuedAt >= prev.enqueuedAt) newestByRowKey.set(r.rowKey, r);
+    }
+    const out: Record<string, SceneRowJobState> = {};
+    const rowIds = new Set([
+      ...newestByRowKey.keys(),
+      ...Object.keys(jobByRow),
+      ...Object.keys(enqueueErrors),
+      ...Object.keys(enqueuing),
+      ...Object.keys(queued),
+    ]);
+    for (const rowId of rowIds) {
+      const enqErr = enqueueErrors[rowId];
+      if (enqErr) {
+        out[rowId] = { ...IDLE, status: "failed", error: enqErr };
+        continue;
+      }
+      // Waiting its turn (sequential queue) and not yet submitted.
+      if (queued[rowId] && !jobByRow[rowId]) {
+        out[rowId] = { ...IDLE, queued: true, status: "queued" };
+        continue;
+      }
+      // Enqueue window: submitted, no job_id yet — show running, keep Run disabled.
+      if (enqueuing[rowId] && !jobByRow[rowId]) {
+        out[rowId] = { ...IDLE, running: true };
+        continue;
+      }
+      const jobId = jobByRow[rowId];
+      const rec =
+        (jobId ? mineByJob.get(jobId) : undefined) ?? newestByRowKey.get(rowId);
+      if (!rec) {
+        out[rowId] = { ...IDLE, running: !!enqueuing[rowId] };
+        continue;
+      }
+      out[rowId] = {
+        jobId: rec.jobId,
+        status: rec.status,
+        outputs: rec.outputs ?? [],
+        error:
+          rec.error ??
+          (rec.expired ? "This job is no longer tracked by the server." : null),
+        running: isJobActive(rec),
+        queued: false,
+        capped: rec.capped ?? false,
+        progress:
+          rec.progress && !isMovieProgress(rec.progress) ? rec.progress : null,
+      };
+    }
+    return out;
+  }, [records, jobByRow, enqueueErrors, enqueuing, queued]);
+
+  const resume = useCallback(
+    (rowId: string) => {
+      const jobId = byRow[rowId]?.jobId;
+      if (jobId) resumeJob(jobId);
+    },
+    [byRow],
+  );
+
+  const anyRunning = useMemo(
+    () =>
+      Object.values(byRow).some(
+        (s: SceneRowJobState) => s.running || s.queued,
+      ) || Object.keys(enqueuing).length > 0,
+    [byRow, enqueuing],
+  );
+
+  const reset = useCallback(() => {
+    runSeq.current += 1; // stop any in-flight sequence
+    setJobByRow({});
+    setEnqueueErrors({});
+    setEnqueuing({});
+    setQueued({});
+    dismissTerminal(STATION);
+  }, []);
+
+  const runRows = useCallback(
+    (rows: { rowId: string; req: GenerateSceneRequest }[]) => {
+      if (rows.length === 0) return;
+      const myRun = ++runSeq.current;
+      setJobByRow({});
+      setEnqueueErrors({});
+      setEnqueuing({});
+      // Everything starts queued; each row leaves the queue when its turn comes.
+      setQueued(Object.fromEntries(rows.map((r) => [r.rowId, true])));
+
+      const waitTerminal = async (jobId: string) => {
+        const start = Date.now();
+        while (Date.now() - start < WAIT_CAP_MS) {
+          if (runSeq.current !== myRun) return; // superseded by a newer run/reset
+          const rec = recordsRef.current.find(
+            (r) => r.station === STATION && r.jobId === jobId,
+          );
+          if (
+            rec &&
+            (rec.status === "done" ||
+              rec.status === "failed" ||
+              rec.expired ||
+              rec.capped)
+          )
+            return;
+          await sleep(1200);
+        }
+      };
+
+      void (async () => {
+        for (const { rowId, req } of rows) {
+          if (runSeq.current !== myRun) return;
+          // This row's turn: leave the queue, mark enqueuing.
+          setQueued((prev) => {
+            const n = { ...prev };
+            delete n[rowId];
+            return n;
+          });
+          setEnqueuing((prev) => ({ ...prev, [rowId]: true }));
+          const enqueuedAt = Date.now();
+          let jobId: string | null = null;
+          try {
+            const r = await request<unknown>(hugpyConfig.generateSceneEnqueueUrl, {
+              method: "POST",
+              body: JSON.stringify(req),
+              headers: { "Content-Type": "application/json" },
+              meta: { specKey: STATION, operation: "generate_scene.enqueue" },
+            });
+            setEnqueuing((prev) => {
+              const n = { ...prev };
+              delete n[rowId];
+              return n;
+            });
+            if (!r.ok) {
+              setEnqueueErrors((prev) => ({
+                ...prev,
+                [rowId]: describeAppError(errorOf(r)),
+              }));
+              continue;
+            }
+            const parsed = enqueueResultSchema.safeParse(okValue(r));
+            if (!parsed.success) {
+              setEnqueueErrors((prev) => ({
+                ...prev,
+                [rowId]: "Malformed enqueue response.",
+              }));
+              continue;
+            }
+            jobId = parsed.data.job_id;
+            trackJob({
+              jobId,
+              rowKey: rowId,
+              kind: "generate_scene",
+              station: STATION,
+              label: "scene part",
+              enqueuedAt,
+              nFrames: req.n_frames,
+              chain: req.chain,
+              prompt: promptSummary(req.parts),
+              model: req.model_id,
+            });
+            const jid = jobId;
+            setJobByRow((prev) => ({ ...prev, [rowId]: jid }));
+          } catch (e) {
+            setEnqueuing((prev) => {
+              const n = { ...prev };
+              delete n[rowId];
+              return n;
+            });
+            setEnqueueErrors((prev) => ({
+              ...prev,
+              [rowId]: e instanceof Error ? e.message : String(e),
+            }));
+            continue;
+          }
+          // SEQUENTIAL: block until this model's job is terminal before the next,
+          // so each generation gets a clean GPU (no simultaneous-load contention).
+          await waitTerminal(jobId);
+        }
+      })();
+    },
+    [],
+  );
+
+  return { byRow, anyRunning, runRows, resume, reset };
+}