@hugpy/video-intelligence-ui 0.1.0

package/src/stations/useCropJobs.ts

@@ -0,0 +1,206 @@
+// The crop station's enqueue surface, now riding the session-wide job tracker.
+// It still owns the request-body construction (one crop job per queued region)
+// and POSTs each 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 poll cap, the terminal parse, and the single library push
+// all live in jobTracker now — so a crop enqueued here keeps running (and lands
+// in the library) even after the user switches sub-tabs (which unmounts this
+// station) or reloads the page.
+//
+// The public API to ImageCropStation is UNCHANGED: `{ jobs, runCrops, resume,
+// reset }` where each job carries { key, index, region, jobId, status, output,
+// error, capped, startedAt }. `jobs` is now DERIVED from the tracker (this
+// station's crop records) merged with any still-enqueuing local placeholders.
+import { useCallback, useMemo, useRef, useState } from "react";
+import { request, okValue, errorOf, describeAppError } from "../transport/client";
+import { hugpyConfig } from "../config";
+import {
+  enqueueResultSchema,
+  type CropJobRequest,
+  type JobStatus,
+  type MediaRef,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  resumeStation,
+  dismissTerminal,
+  type TrackedJob as TrackerRecord,
+} from "../video/jobTracker";
+import type { SpatialRegion } from "../regions/types";
+
+export interface TrackedJob {
+  /** Stable local key (the server job id once enqueued). */
+  key: string;
+  /** 1-based position, for display. */
+  index: number;
+  /** The native-px region this job crops. */
+  region: SpatialRegion;
+  /** Server job id once enqueued, else null. */
+  jobId: string | null;
+  /** Latest polled status (null = enqueued but not yet claimed). */
+  status: JobStatus;
+  /** Result crop MediaRef on success. */
+  output: MediaRef | null;
+  /** Human message on failure (enqueue error or job error). */
+  error: string | null;
+  /** Poll cap reached while non-terminal — NOT a failure (Phase 8). */
+  capped: boolean;
+  /** Enqueue timestamp — the anchor for the poll cap. */
+  startedAt: number;
+}
+
+// A pre-enqueue placeholder: the brief window between the user clicking Run and
+// the enqueue POST returning a job_id (or failing). Once a job_id arrives the
+// tracker owns the job and the placeholder is dropped; a failed enqueue keeps its
+// placeholder (as a failed row) since it never became a tracker record.
+interface Pending {
+  key: string;
+  index: number;
+  region: SpatialRegion;
+  status: Extract<JobStatus, "queued" | "failed">;
+  error: string | null;
+  startedAt: number;
+}
+
+let _seq = 0;
+function makeKey(): string {
+  _seq += 1;
+  return `job_${_seq.toString(36)}_${Date.now().toString(36)}`;
+}
+
+export interface CropJobsApi {
+  jobs: TrackedJob[];
+  /** Enqueue one crop job per region and begin polling (via the tracker). */
+  runCrops: (regions: SpatialRegion[]) => void;
+  /**
+   * Re-anchor the poll clock for a capped job (or every capped crop when `key`
+   * is omitted) and resume polling. Clears `capped`, keeps status.
+   */
+  resume: (key?: string) => void;
+  /** Forget this station's finished jobs (called when a new source is ingested). */
+  reset: () => void;
+}
+
+const STATION = "image-crop";
+
+export function useCropJobs(source: MediaRef | null): CropJobsApi {
+  const records = useJobTracker();
+  const [pending, setPending] = useState<Pending[]>([]);
+
+  // This station's crop records, newest-index last (stable via useMemo).
+  const mine = useMemo(
+    () => records.filter((r) => r.station === STATION && r.kind === "crop"),
+    [records],
+  );
+
+  const mineRef = useRef<TrackerRecord[]>(mine);
+  mineRef.current = mine;
+  const pendingRef = useRef<Pending[]>(pending);
+  pendingRef.current = pending;
+
+  const jobs = useMemo<TrackedJob[]>(() => {
+    const fromTracker: TrackedJob[] = mine.map((r) => ({
+      key: r.jobId,
+      index: r.index,
+      region: (r.region as SpatialRegion) ?? { x: 0, y: 0, w: 0, h: 0 },
+      jobId: r.jobId,
+      status: r.status,
+      output: r.outputs[0] ?? null,
+      error: r.error,
+      capped: r.capped,
+      startedAt: r.startedAt,
+    }));
+    const fromPending: TrackedJob[] = pending.map((p) => ({
+      key: p.key,
+      index: p.index,
+      region: p.region,
+      jobId: null,
+      status: p.status,
+      output: null,
+      error: p.error,
+      capped: false,
+      startedAt: p.startedAt,
+    }));
+    return [...fromTracker, ...fromPending].sort((a, b) => a.index - b.index);
+  }, [mine, pending]);
+
+  const reset = useCallback(() => {
+    setPending([]);
+    dismissTerminal(STATION);
+  }, []);
+
+  const resume = useCallback((key?: string) => {
+    if (key != null) resumeJob(key);
+    else resumeStation(STATION);
+  }, []);
+
+  const runCrops = useCallback(
+    (regions: SpatialRegion[]) => {
+      if (!source || regions.length === 0) return;
+      // Continue the 1-based numbering past any existing/pending rows.
+      const base = Math.max(
+        0,
+        ...mineRef.current.map((r) => r.index),
+        ...pendingRef.current.map((p) => p.index),
+      );
+
+      regions.forEach((region, i) => {
+        const key = makeKey();
+        const index = base + i + 1;
+        const enqueuedAt = Date.now();
+        const label = `crop ${region.w}×${region.h}`;
+        setPending((prev) => [
+          ...prev,
+          { key, index, region, status: "queued", error: null, startedAt: enqueuedAt },
+        ]);
+
+        const body: CropJobRequest = { source, spatial: region, temporal: null };
+        void request<unknown>(hugpyConfig.cropEnqueueUrl, {
+          method: "POST",
+          body: JSON.stringify(body),
+          headers: { "Content-Type": "application/json" },
+          meta: { specKey: STATION, operation: "crop.enqueue" },
+        }).then((r) => {
+          if (!r.ok) {
+            setPending((prev) =>
+              prev.map((p) =>
+                p.key === key
+                  ? { ...p, status: "failed", error: describeAppError(errorOf(r)) }
+                  : p,
+              ),
+            );
+            return;
+          }
+          const parsed = enqueueResultSchema.safeParse(okValue(r));
+          if (!parsed.success) {
+            setPending((prev) =>
+              prev.map((p) =>
+                p.key === key
+                  ? { ...p, status: "failed", error: "Malformed enqueue response." }
+                  : p,
+              ),
+            );
+            return;
+          }
+          // Hand the job to the durable tracker, then drop the local placeholder.
+          trackJob({
+            jobId: parsed.data.job_id,
+            kind: "crop",
+            station: STATION,
+            label,
+            libLabel: label,
+            enqueuedAt,
+            index,
+            region,
+          });
+          setPending((prev) => prev.filter((p) => p.key !== key));
+        });
+      });
+    },
+    [source],
+  );
+
+  return { jobs, runCrops, resume, reset };
+}

package/src/stations/useFrameJobs.ts

@@ -0,0 +1,140 @@
+// The Frames station's enqueue surface, now riding the session-wide job tracker.
+// frame-extract is ONE job that produces MANY frames. This hook still owns the
+// 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 poll cap, the terminal parse, and the
+// single "push every produced frame into the library" step all live in
+// jobTracker now — so an extraction kicked off here keeps running (and its frames
+// land in the shared library) even after the user switches sub-tabs (which
+// unmounts this station) or reloads the page.
+//
+// The public API to FrameExtractStation is UNCHANGED:
+// `{ jobId, status, frames, error, capped, running, run, resume, reset }`.
+// Those values are DERIVED from the tracker (this station's newest frame-extract
+// record) plus a little local state for the brief pre-enqueue window.
+import { useCallback, useMemo, useRef, useState } from "react";
+import { request, okValue, errorOf, describeAppError } from "../transport/client";
+import { hugpyConfig } from "../config";
+import {
+  enqueueResultSchema,
+  type FrameExtractRequest,
+  type JobStatus,
+  type MediaRef,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  dismissTerminal,
+  isJobActive,
+} from "../video/jobTracker";
+
+export interface FrameJobsApi {
+  /** Server job id once enqueued, else null. */
+  jobId: string | null;
+  /** Latest polled status (null = idle or enqueued-but-not-yet-claimed). */
+  status: JobStatus;
+  /** The produced frame MediaRefs (populated on done). */
+  frames: MediaRef[];
+  /** Human message on failure (enqueue error or job error). */
+  error: string | null;
+  /** Poll cap reached while non-terminal (Phase 8) — NOT a failure. */
+  capped: boolean;
+  /** True while enqueuing or polling a non-terminal job. */
+  running: boolean;
+  /** Enqueue ONE frame-extract job and begin polling. Replaces any prior run. */
+  run: (req: FrameExtractRequest) => void;
+  /** Re-anchor the poll clock and resume polling a capped job. Clears `capped`. */
+  resume: () => void;
+  /** Forget this station's finished job (called when a new source is ingested). */
+  reset: () => void;
+}
+
+const STATION = "frames";
+
+export function useFrameJobs(): FrameJobsApi {
+  const records = useJobTracker();
+  const [currentJobId, setCurrentJobId] = useState<string | null>(null);
+  const [enqueuing, setEnqueuing] = useState<boolean>(false);
+  const [enqueueError, setEnqueueError] = useState<string | null>(null);
+
+  // The record this hook instance is watching: the one it just enqueued
+  // (currentJobId), or — on a fresh mount after a tab switch / reload, when the
+  // local pointer is gone — the newest frame-extract record for this station.
+  const record = useMemo(() => {
+    const mine = records.filter(
+      (r) => r.station === STATION && r.kind === "frame_extract",
+    );
+    if (currentJobId) return mine.find((r) => r.jobId === currentJobId) ?? null;
+    if (enqueuing) return null; // a fresh run is in flight — don't resurface the old one
+    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: FrameExtractRequest) => {
+    // Fresh run — hide any prior result and enqueue one job.
+    setCurrentJobId(null);
+    setEnqueueError(null);
+    setEnqueuing(true);
+    const enqueuedAt = Date.now();
+
+    void request<unknown>(hugpyConfig.frameExtractEnqueueUrl, {
+      method: "POST",
+      body: JSON.stringify(req),
+      headers: { "Content-Type": "application/json" },
+      meta: { specKey: STATION, operation: "frame_extract.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: "frame_extract",
+        station: STATION,
+        label: `frames @ ${req.fps} fps`,
+        enqueuedAt,
+      });
+      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);
+
+  return {
+    jobId: record?.jobId ?? null,
+    status,
+    frames: record?.outputs ?? [],
+    error,
+    capped: record?.capped ?? false,
+    running: enqueuing || (record != null && isJobActive(record)),
+    run,
+    resume,
+    reset,
+  };
+}

package/src/stations/useGenerateJob.ts

@@ -0,0 +1,151 @@
+// The Generate station's enqueue surface, now riding the session-wide job
+// tracker. ONE ordered multimodal prompt → ONE generate job → ONE image. This
+// hook still owns the 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
+// generate poll cap (GENERATE_POLL_CAP_MS), the terminal parse, and the single
+// library push (origin "generate") all live in jobTracker now — so a generation
+// 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 public API to GenerateStation is UNCHANGED:
+// `{ jobId, status, output, error, capped, running, run, resume, reset }`.
+import { useCallback, useMemo, useRef, 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,
+  type JobProject,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  dismissTerminal,
+  isJobActive,
+} from "../video/jobTracker";
+
+export interface GenerateJobApi {
+  /** Server job id once enqueued, else null. */
+  jobId: string | null;
+  /** Latest polled status (null = idle or enqueued-but-not-yet-claimed). */
+  status: JobStatus;
+  /** The generated image MediaRef (populated on done). */
+  output: MediaRef | null;
+  /** Human message on failure (enqueue error or job error). */
+  error: string | null;
+  /** Poll cap reached while non-terminal (Phase 8) — 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); null otherwise. */
+  progress: JobProgress | null;
+  /** Auto-archive project this run was saved into (populated on done); null otherwise. */
+  project: JobProject | null;
+  /** Enqueue ONE generate job and begin polling. Replaces any prior run. */
+  run: (req: GenerateImageRequest) => 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 useGenerateJob(): GenerateJobApi {
+  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_image",
+    );
+    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: GenerateImageRequest) => {
+    setCurrentJobId(null);
+    setEnqueueError(null);
+    setEnqueuing(true);
+    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(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_image",
+        station: STATION,
+        label: "generate image",
+        enqueuedAt,
+        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_image 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,
+    output: record?.outputs[0] ?? null,
+    error,
+    capped: record?.capped ?? false,
+    running: enqueuing || (record != null && isJobActive(record)),
+    progress,
+    project: record?.project ?? null,
+    run,
+    resume,
+    reset,
+  };
+}

package/src/stations/useGenerateMovieJob.ts

@@ -0,0 +1,177 @@
+// The Generate station's MOVIE enqueue surface — Movie mode's sibling to
+// useGenerateSceneJob. ONE goal timeline → ONE generate_movie job → N segments of
+// consecutive frames + one assembled mp4 clip (LAST), with an opt-in vision
+// director loop. Cloned from useGenerateSceneJob: 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 segments×frames-scaled movie poll cap
+// (generateMoviePollCapMs, plumbed via trackJob.segments/nFrames → capFor), the
+// terminal parse, and the centralized library push (segment frames + the movie clip,
+// origin "generate") all live in jobTracker — so a movie 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 shape differences from useGenerateSceneJob: the request is a
+// GenerateMovieRequest (a goal timeline + director knobs), and `progress` is the
+// NESTED MovieProgress (segment strip + a current-segment view) rather than a flat
+// JobProgress. Outputs are still the full result.outputs array (segment frames,
+// then the movie.mp4 last).
+import { useCallback, useMemo, useRef, useState } from "react";
+import { request, okValue, errorOf, describeAppError } from "../transport/client";
+import { hugpyConfig } from "../config";
+import {
+  enqueueResultSchema,
+  isMovieProgress,
+  type GenerateMovieRequest,
+  type JobStatus,
+  type MediaRef,
+  type MovieProgress,
+  type JobProject,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  dismissTerminal,
+  isJobActive,
+} from "../video/jobTracker";
+
+export interface GenerateMovieJobApi {
+  /** 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 (segment image frames, then the movie clip last). */
+  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 NESTED movie progress while running (segment strip + current view); null otherwise. */
+  progress: MovieProgress | null;
+  /** Auto-archive project this movie was saved into (populated on done); null otherwise. */
+  project: JobProject | null;
+  /** Enqueue ONE generate_movie job and begin polling. Replaces any prior run. */
+  run: (req: GenerateMovieRequest) => 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";
+
+/** Flatten the goal-timeline prompts into one provenance summary string. */
+function moviePromptSummary(req: GenerateMovieRequest): string {
+  return req.goals
+    .map((g) => g.prompt.trim())
+    .filter((t) => t !== "")
+    .join(" · ")
+    .trim();
+}
+
+export function useGenerateMovieJob(): GenerateMovieJobApi {
+  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_movie",
+    );
+    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: GenerateMovieRequest) => {
+    setCurrentJobId(null);
+    setEnqueueError(null);
+    setEnqueuing(true);
+    const enqueuedAt = Date.now();
+
+    void request<unknown>(hugpyConfig.generateMovieEnqueueUrl, {
+      method: "POST",
+      body: JSON.stringify(req),
+      headers: { "Content-Type": "application/json" },
+      meta: { specKey: STATION, operation: "generate_movie.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;
+      // total frame count = max end_frame across the (contiguous) timeline; the
+      // poll cap scales off segments × total frames (see generateMoviePollCapMs).
+      const framesTotal = req.goals.reduce(
+        (mx, g) => Math.max(mx, g.end_frame),
+        0,
+      );
+      trackJob({
+        jobId,
+        kind: "generate_movie",
+        station: STATION,
+        label: "generate movie",
+        enqueuedAt,
+        segments: req.goals.length,
+        nFrames: framesTotal,
+        chain: req.chain ?? false,
+        prompt: moviePromptSummary(req),
+        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);
+
+  // The tracker stores progress as a union (flat OR nested); narrow to the movie
+  // shape for this hook's consumers (a generate_movie record only ever carries a
+  // movie blob, but the narrow keeps the type honest).
+  const progress: MovieProgress | 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,
+  };
+}