@hugpy/video-intelligence-ui 0.1.0

package/src/stations/studio/useReconstruction.ts

@@ -0,0 +1,283 @@
+// src/stations/studio/useReconstruction.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+import { z } from "zod";
+import { request, okValue, errorOf, describeAppError } from "../../transport/client";
+import {
+  jobStatusUrl,
+  identityReconstructionUrl,
+  identityCanonicalUrl,
+} from "../../config";
+import { jobRecordSchema, isTerminal } from "../../video/contract";
+import type { JobStatus } from "../../video/contract";
+
+export const DEFAULT_VIEWS = ["front", "three_quarter", "profile", "back"] as const;
+export type ViewName = (typeof DEFAULT_VIEWS)[number];
+
+export const VIEW_LABELS: Record<string, string> = {
+  front: "Front",
+  three_quarter: "¾ view",
+  profile: "Profile",
+  back: "Back",
+};
+
+const reconEnqueueSchema = z
+  .object({
+    recon_id: z.string().optional(),
+    job_id: z.union([z.string(), z.array(z.string())]).optional(),
+    job_ids: z.array(z.string()).optional(),
+  })
+  .passthrough();
+
+export interface ReconstructionRun {
+  prompt?: string;
+  views?: string[];
+  seed?: number;
+  mode?: "sheet" | "turntable" | "angle-ring";
+  angle_step_deg?: number;
+  elevations_deg?: number[];
+  reference_images?: string[];
+}
+
+export interface PromoteResult {
+  ok: boolean;
+  message?: string;
+}
+
+export interface ReconstructionApi {
+  running: boolean;
+  jobIds: string[];
+  reconId: string | null;
+  done: number;
+  total: number;
+  error: string | null;
+  
+  generate: (run: ReconstructionRun) => void;
+  promote: (reconId: string, viewIndices: number[]) => Promise<PromoteResult>;
+  reset: () => void;
+  
+  // Angle-ring specific operations
+  setViewStatus: (reconId: string, viewId: string, status: "approved" | "rejected") => Promise<PromoteResult>;
+  regenerateView: (reconId: string, viewId: string, prompt?: string, seed?: number, useNeighbors?: boolean) => void;
+  buildMesh: (reconId: string, viewIds: string[]) => void;
+}
+
+export function useReconstruction(slug: string, onComplete: () => void): ReconstructionApi {
+  const [running, setRunning] = useState(false);
+  const [jobIds, setJobIds] = useState<string[]>([]);
+  const [statuses, setStatuses] = useState<Record<string, JobStatus>>({});
+  const [reconId, setReconId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const mounted = useRef(true);
+  const timer = useRef<number | null>(null);
+  const idsRef = useRef<string[]>([]);
+  const statusesRef = useRef<Record<string, JobStatus>>({});
+  const onCompleteRef = useRef(onComplete);
+  onCompleteRef.current = onComplete;
+
+  const stopPoll = useCallback(() => {
+    if (timer.current != null) {
+      window.clearInterval(timer.current);
+      timer.current = null;
+    }
+  }, []);
+
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      stopPoll();
+    };
+  }, [stopPoll]);
+
+  const poll = useCallback(async () => {
+    const ids = idsRef.current;
+    if (ids.length === 0) return;
+    const records = await Promise.all(
+      ids.map(async (id) => {
+        const res = await request<unknown>(jobStatusUrl(id), {
+          meta: { specKey: "studio", operation: "identity.reconstruction.status" },
+        });
+        if (!res.ok) return null;
+        const parsed = jobRecordSchema.safeParse(okValue(res));
+        return parsed.success ? parsed.data : null;
+      }),
+    );
+    if (!mounted.current) return;
+    const merged: Record<string, JobStatus> = { ...statusesRef.current };
+    let firstError: string | null = null;
+    records.forEach((jr, i) => {
+      if (!jr) return;
+      merged[ids[i]] = jr.status ?? null;
+      if ((jr.status === "failed" || jr.status === "cancelled") && firstError == null) {
+        firstError = jr.result?.error?.message ?? `Job ${jr.status}.`;
+      }
+    });
+    statusesRef.current = merged;
+    setStatuses(merged);
+    if (firstError != null) setError(firstError);
+    if (ids.every((id) => isTerminal(merged[id] ?? null))) {
+      stopPoll();
+      setRunning(false);
+      onCompleteRef.current();
+    }
+  }, [stopPoll]);
+
+  // Shared response handler for anything that enqueues jobs (generate, regenerate, buildMesh)
+  const handleEnqueueResponse = useCallback((r: Awaited<ReturnType<typeof request<unknown>>>) => {
+    if (!mounted.current) return;
+    if (!r.ok) {
+      setError(describeAppError(errorOf(r)));
+      setRunning(false);
+      return;
+    }
+    const parsed = reconEnqueueSchema.safeParse(okValue(r));
+    if (!parsed.success) {
+      setError("Malformed reconstruction response.");
+      setRunning(false);
+      return;
+    }
+    const d = parsed.data;
+    if (d.recon_id) setReconId(d.recon_id);
+    const ids: string[] = [];
+    if (typeof d.job_id === "string") ids.push(d.job_id);
+    else if (Array.isArray(d.job_id)) ids.push(...d.job_id);
+    if (Array.isArray(d.job_ids)) ids.push(...d.job_ids);
+    const uniq = Array.from(new Set(ids.filter((x) => typeof x === "string" && x !== "")));
+    if (uniq.length === 0) {
+      setRunning(false);
+      onCompleteRef.current();
+      return;
+    }
+    idsRef.current = uniq;
+    setJobIds(uniq);
+    const seeded: Record<string, JobStatus> = {};
+    uniq.forEach((id) => (seeded[id] = "queued"));
+    statusesRef.current = seeded;
+    setStatuses(seeded);
+    void poll();
+    timer.current = window.setInterval(() => void poll(), 2000);
+  }, [poll]);
+
+  const generate = useCallback(
+    (run: ReconstructionRun) => {
+      stopPoll();
+      setError(null);
+      setReconId(null);
+      setJobIds([]);
+      setStatuses({});
+      statusesRef.current = {};
+      idsRef.current = [];
+      setRunning(true);
+
+      const body: Record<string, unknown> = {};
+      if (run.prompt != null && run.prompt.trim() !== "") body.prompt = run.prompt.trim();
+      if (run.views && run.views.length > 0) body.views = run.views;
+      if (run.seed != null && Number.isFinite(run.seed)) body.seed = run.seed;
+      if (run.mode) body.mode = run.mode;
+      if (run.angle_step_deg != null) body.angle_step_deg = run.angle_step_deg;
+      if (run.elevations_deg != null) body.elevations_deg = run.elevations_deg;
+      if (run.reference_images != null) body.reference_images = run.reference_images;
+
+      void request<unknown>(identityReconstructionUrl(slug), {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: { "Content-Type": "application/json" },
+        meta: { specKey: "studio", operation: "identity.reconstruction.enqueue" },
+      }).then(handleEnqueueResponse);
+    },
+    [slug, handleEnqueueResponse, stopPoll],
+  );
+
+  const setViewStatus = useCallback(
+    async (rid: string, viewId: string, status: "approved" | "rejected"): Promise<PromoteResult> => {
+      const base = identityReconstructionUrl(slug);
+      const res = await request<unknown>(`${base}/${rid}/views/${viewId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ status }),
+        headers: { "Content-Type": "application/json" },
+        meta: { specKey: "studio", operation: "identity.view.status" },
+      });
+      if (!res.ok) return { ok: false, message: describeAppError(errorOf(res)) };
+      onCompleteRef.current(); // reload profile so UI marks it approved immediately
+      return { ok: true };
+    },
+    [slug]
+  );
+
+  const regenerateView = useCallback(
+    (rid: string, viewId: string, prompt?: string, seed?: number, useNeighbors: boolean = true) => {
+      stopPoll();
+      setError(null);
+      setJobIds([]);
+      setStatuses({});
+      statusesRef.current = {};
+      idsRef.current = [];
+      setRunning(true);
+
+      const body: Record<string, unknown> = { use_nearest_approved_neighbors: useNeighbors };
+      if (prompt) body.prompt = prompt.trim();
+      if (seed != null) body.seed = seed;
+
+      const base = identityReconstructionUrl(slug);
+      void request<unknown>(`${base}/${rid}/views/${viewId}/regenerate`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: { "Content-Type": "application/json" },
+        meta: { specKey: "studio", operation: "identity.view.regenerate" },
+      }).then(handleEnqueueResponse);
+    },
+    [slug, handleEnqueueResponse, stopPoll]
+  );
+
+  const buildMesh = useCallback(
+    (rid: string, viewIds: string[]) => {
+      stopPoll();
+      setError(null);
+      setJobIds([]);
+      setStatuses({});
+      statusesRef.current = {};
+      idsRef.current = [];
+      setRunning(true);
+
+      const base = identityReconstructionUrl(slug);
+      void request<unknown>(`${base}/${rid}/mesh`, {
+        method: "POST",
+        body: JSON.stringify({ views: viewIds }),
+        headers: { "Content-Type": "application/json" },
+        meta: { specKey: "studio", operation: "identity.mesh.build" },
+      }).then(handleEnqueueResponse);
+    },
+    [slug, handleEnqueueResponse, stopPoll]
+  );
+
+  const promote = useCallback(
+    async (rid: string, viewIndices: number[]): Promise<PromoteResult> => {
+      const res = await request<unknown>(identityCanonicalUrl(slug), {
+        method: "POST",
+        body: JSON.stringify({ recon_id: rid, views: viewIndices }),
+        headers: { "Content-Type": "application/json" },
+        meta: { specKey: "studio", operation: "identity.canonical.promote" },
+      });
+      if (!res.ok) return { ok: false, message: describeAppError(errorOf(res)) };
+      return { ok: true };
+    },
+    [slug]
+  );
+
+  const reset = useCallback(() => {
+    stopPoll();
+    setRunning(false);
+    setJobIds([]);
+    setStatuses({});
+    statusesRef.current = {};
+    idsRef.current = [];
+    setReconId(null);
+    setError(null);
+  }, [stopPoll]);
+
+  const total = jobIds.length;
+  const done = jobIds.filter((id) => isTerminal(statuses[id] ?? null)).length;
+
+  return { running, jobIds, reconId, done, total, error, generate, setViewStatus, regenerateView, buildMesh, promote, reset };
+}

package/src/stations/types.ts

@@ -0,0 +1,43 @@
+// Station contract for the video-intelligence arm — the PageSpec analog at this
+// layer. A station is a capability page: it consumes MediaRefs, builds ONE frozen
+// spec type, enqueues it on the job bus, and subscribes to results by job_id.
+// The registry (registry.ts) is the single place stations are declared; the
+// shell renders whatever is registered. Registries over globals, top to bottom.
+import type { ComponentType } from "react";
+
+export type StationStatus = "planned" | "active";
+
+export interface StationSpec {
+  /** Stable id — also the route segment (/#/<id> equivalent under the router). */
+  id: string;
+  /** Tab label, matching the sample image's top-tab affordance. */
+  title: string;
+  /** One-line purpose shown on the placeholder card. */
+  blurb: string;
+  /** ROADMAP.md phase that turns this station real. */
+  phase: string;
+  /** Backend spec type this station will build (from the architecture map). */
+  buildsSpec: string;
+  /** Planned affordances, rendered as the placeholder checklist. */
+  planned: string[];
+  /**
+   * Workbench group id. Every built station now shares the single "studio"
+   * group and appears as a sub-tab of the one workbench (the old Studio/Generate
+   * top-level split is retired). Kept optional so a future station can opt out.
+   */
+  group?: string;
+  /**
+   * Hide this station from the sub-tab NAV strip while keeping its ROUTE live —
+   * WorkbenchStation still resolves /<id>, so deep-links (e.g. the sidebar's
+   * "Send to Studio") keep working. Retires a redundant tab from the nav without
+   * deleting the page.
+   */
+  navHidden?: boolean;
+  status: StationStatus;
+  /**
+   * The real body, once the station is built. When present AND status==="active"
+   * the shell renders this instead of the PlaceholderStation. Receives its own
+   * StationSpec so a component can read its id/title/phase.
+   */
+  component?: ComponentType<{ spec: StationSpec }>;
+}

package/src/stations/useAudioCropJobs.ts

@@ -0,0 +1,202 @@
+// The Audio Crop station's enqueue surface — the temporal sibling of
+// useCropJobs. It still owns the request-body construction (one TEMPORAL crop
+// job per queued window, reusing the crop endpoint with spatial: null) 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 clip enqueued here keeps running (and lands in
+// the library, origin "audio-crop") even after the user switches sub-tabs
+// (which unmounts this station) or reloads the page.
+//
+// The public API to AudioCropStation is UNCHANGED: `{ jobs, runCrops, resume,
+// reset }` where each job carries { key, index, region, jobId, status, output,
+// error, capped, startedAt }. `jobs` is 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 { TemporalRegion } from "../regions/types";
+
+export interface TrackedAudioJob {
+  /** Stable local key (the server job id once enqueued). */
+  key: string;
+  /** 1-based position, for display. */
+  index: number;
+  /** The temporal window (seconds) this job crops. */
+  region: TemporalRegion;
+  /** Server job id once enqueued, else null. */
+  jobId: string | null;
+  /** Latest polled status (null = enqueued but not yet claimed). */
+  status: JobStatus;
+  /** Result audio-clip 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 — see useCropJobs.ts for the rationale.
+interface Pending {
+  key: string;
+  index: number;
+  region: TemporalRegion;
+  status: Extract<JobStatus, "queued" | "failed">;
+  error: string | null;
+  startedAt: number;
+}
+
+let _seq = 0;
+function makeKey(): string {
+  _seq += 1;
+  return `aclip_${_seq.toString(36)}_${Date.now().toString(36)}`;
+}
+
+export interface AudioCropJobsApi {
+  jobs: TrackedAudioJob[];
+  /** Enqueue one temporal crop job per region and begin polling (via the tracker). */
+  runCrops: (regions: TemporalRegion[]) => void;
+  /**
+   * Re-anchor the poll clock for a capped job (or every capped clip 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 = "audio-crop";
+
+export function useAudioCropJobs(source: MediaRef | null): AudioCropJobsApi {
+  const records = useJobTracker();
+  const [pending, setPending] = useState<Pending[]>([]);
+
+  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<TrackedAudioJob[]>(() => {
+    const fromTracker: TrackedAudioJob[] = mine.map((r) => ({
+      key: r.jobId,
+      index: r.index,
+      region: (r.region as TemporalRegion) ?? { start_s: 0, end_s: 0 },
+      jobId: r.jobId,
+      status: r.status,
+      output: r.outputs[0] ?? null,
+      error: r.error,
+      capped: r.capped,
+      startedAt: r.startedAt,
+    }));
+    const fromPending: TrackedAudioJob[] = 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: TemporalRegion[]) => {
+      if (!source || regions.length === 0) return;
+      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 = `clip ${region.start_s.toFixed(2)}–${region.end_s.toFixed(2)}s`;
+        setPending((prev) => [
+          ...prev,
+          { key, index, region, status: "queued", error: null, startedAt: enqueuedAt },
+        ]);
+
+        // Temporal audio crop reuses the crop endpoint — spatial is null.
+        const body: CropJobRequest = { source, spatial: null, temporal: region };
+        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;
+          }
+          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/useAudioExtractJob.ts

@@ -0,0 +1,144 @@
+// The Audio Crop station's video→audio step, now riding the session-wide job
+// tracker. When the ingested source is a VIDEO we pull its audio track out into
+// a standalone audio MediaRef before the temporal editor can open. This hook
+// still owns the request-body construction (fmt "wav") 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, and the terminal parse all live in jobTracker now — so the extract
+// keeps running even after a sub-tab switch or a page reload.
+//
+// The extracted audio is INTERMEDIATE (it feeds the temporal editor), so the
+// tracker deliberately does NOT push it to the media library — only the finished
+// crops are (see useAudioCropJobs). It is still tracked/polled so the process is
+// visible and survives tab switches.
+//
+// The public API to AudioCropStation 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,
+  type AudioExtractRequest,
+  type JobStatus,
+  type MediaRef,
+} from "../video/contract";
+import {
+  useJobTracker,
+  trackJob,
+  resumeJob,
+  dismissTerminal,
+  isJobActive,
+} from "../video/jobTracker";
+
+export interface AudioExtractJobApi {
+  /** Server job id once enqueued, else null. */
+  jobId: string | null;
+  /** Latest polled status (null = idle or enqueued-but-not-yet-claimed). */
+  status: JobStatus;
+  /** The extracted audio 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;
+  /** Enqueue ONE audio_extract job for a video source (fmt "wav") and poll. */
+  run: (source: MediaRef) => void;
+  /** Re-anchor the poll clock and resume polling a capped job. Clears `capped`. */
+  resume: () => void;
+  /** Forget this station's finished extract (called when a new source is ingested). */
+  reset: () => void;
+}
+
+const STATION = "audio-crop";
+
+export function useAudioExtractJob(): AudioExtractJobApi {
+  const records = useJobTracker();
+  const [currentJobId, setCurrentJobId] = useState<string | null>(null);
+  const [enqueuing, setEnqueuing] = useState<boolean>(false);
+  const [enqueueError, setEnqueueError] = useState<string | null>(null);
+
+  // Only the audio_extract kind — the crop kind on this same station is owned by
+  // useAudioCropJobs, so the two never cross-derive.
+  const record = useMemo(() => {
+    const mine = records.filter(
+      (r) => r.station === STATION && r.kind === "audio_extract",
+    );
+    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);
+    // Only forget finished audio_extract rows — leave any in-flight crop of this
+    // station alone (useAudioCropJobs.reset handles the crop rows).
+    dismissTerminal(STATION);
+  }, []);
+
+  const resume = useCallback(() => {
+    const id = jobIdRef.current;
+    if (id) resumeJob(id);
+  }, []);
+
+  const run = useCallback((source: MediaRef) => {
+    // Fresh run — default fmt "wav" (lossless, trivially decodable for the waveform).
+    setCurrentJobId(null);
+    setEnqueueError(null);
+    setEnqueuing(true);
+    const enqueuedAt = Date.now();
+
+    const body: AudioExtractRequest = { source, fmt: "wav" };
+    void request<unknown>(hugpyConfig.audioExtractEnqueueUrl, {
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: { "Content-Type": "application/json" },
+      meta: { specKey: STATION, operation: "audio_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: "audio_extract",
+        station: STATION,
+        label: "extract audio track",
+        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,
+    output: record?.outputs[0] ?? null,
+    error,
+    capped: record?.capped ?? false,
+    running: enqueuing || (record != null && isJobActive(record)),
+    run,
+    resume,
+    reset,
+  };
+}