@hugpy/video-intelligence-ui 0.1.1 → 0.3.0

package/src/stations/studio/promptCard.tsx

@@ -55,8 +55,62 @@ export function composeNegative(negative: string, stdNegative: boolean): string
   return terms.join(", ");
 }
 
+/** The standard set as individual lower-cased terms (the dedupe keys composeNegative uses). */
+const STANDARD_NEGATIVE_TERMS: readonly string[] = STANDARD_NEGATIVE.split(",")
+  .map((t) => t.trim().replace(/\s+/g, " ").toLowerCase())
+  .filter((t) => t !== "");
+
+/**
+ * True when EVERY standard term is present in `negative` (k93 — the explicit
+ * "std." tick reads its state from the visible field, so the checkbox can never
+ * claim something the wire won't carry).
+ */
+export function hasStandardNegative(negative: string): boolean {
+  const present = new Set(
+    negative
+      .split(",")
+      .map((t) => t.trim().replace(/\s+/g, " ").toLowerCase())
+      .filter((t) => t !== ""),
+  );
+  return STANDARD_NEGATIVE_TERMS.every((t) => present.has(t));
+}
+
+/**
+ * Remove exactly the standard terms from `negative`, leaving every other term
+ * (order preserved, whitespace normalized). The inverse of composeNegative(x, true).
+ */
+export function stripStandardNegative(negative: string): string {
+  const std = new Set(STANDARD_NEGATIVE_TERMS);
+  const kept: string[] = [];
+  for (const raw of negative.split(",")) {
+    const term = raw.trim().replace(/\s+/g, " ");
+    if (term === "") continue;
+    if (std.has(term.toLowerCase())) continue;
+    kept.push(term);
+  }
+  return kept.join(", ");
+}
+
+/** Explicit std. tick semantics: ticked ⇒ insert the standard set into the field; unticked ⇒ remove it. */
+export function applyStandardNegative(negative: string, on: boolean): string {
+  return on ? composeNegative(negative, true) : stripStandardNegative(negative);
+}
+
 // ── PromptListToolbar ───────────────────────────────────────────────────────
 
+/**
+ * The k93 RANGE selector that replaces "Select all (n/m)" on the Scene toolbar:
+ * 1-based `[start] - [end]` over the text rows + a select-all tick. Optional —
+ * Movie/Cinema omit it and keep the original select-all label.
+ */
+export interface PromptListToolbarRange {
+  /** 1-based inclusive bounds of the CURRENT selection, or null when nothing is selected. */
+  start: number | null;
+  end: number | null;
+  /** The host re-selects rows `[start, end]` (already clamped by the toolbar). */
+  onChange: (start: number, end: number) => void;
+}
+
 /** The optional "how many rows" count input at the toolbar's left edge. */
 export interface PromptListToolbarCount {
   id: string;
@@ -64,7 +118,8 @@ export interface PromptListToolbarCount {
   label: string;
   value: number;
   min?: number;
-  max: number;
+  /** Omit for no upper bound. */
+  max?: number;
   onChange: (n: number) => void;
   title?: string;
 }
@@ -95,6 +150,68 @@ export interface PromptListToolbarProps {
   onStandardNegatives: () => void;
   standardNegativesTitle?: string;
   disabled?: boolean;
+
+  // ── k93 group layout (all OPTIONAL — Movie/Cinema pass none and render the
+  // original single-line toolbar byte-for-byte) ───────────────────────────────
+  /** Rendered on its own line ABOVE the selection line (the "prompt assist model" select). */
+  modelRow?: ReactNode;
+  /** When given, replaces "Select all (n/m)" with `[start] - [end]  [ ] select all`. */
+  range?: PromptListToolbarRange;
+  /**
+   * The `negatives: [on/off]` toggle. When given, the separate "✨ Generate
+   * negatives" button is NOT rendered — the group actions write negatives
+   * themselves when the toggle is on (the host implements that rule).
+   */
+  negativesOn?: boolean;
+  onNegativesOnChange?: (on: boolean) => void;
+  negativesOnTitle?: string;
+  /**
+   * The explicit `[ ] std.` checkbox (k93): ticked ⇒ the host INSERTS the
+   * standard set into every selected row's Negative field; unticked ⇒ removes
+   * it. When given, the "standard negatives" button is NOT rendered.
+   */
+  stdChecked?: boolean;
+  onStdChange?: (on: boolean) => void;
+  stdTitle?: string;
+  /** The `✨ enhance (M selected)` group action; rendered only when `onEnhance` is given. */
+  enhanceLabel?: string;
+  enhanceTitle?: string;
+  onEnhance?: () => void;
+  /** Enhance is disabled when this is false (M = 0) — the host counts non-blank rows. */
+  canEnhance?: boolean;
+  /** Trailing content on the actions line (the `[+ video]` pretext attach). */
+  actionsExtra?: ReactNode;
+  /** Content rendered under the toolbar lines, full width (the expanded attach panel). */
+  below?: ReactNode;
+}
+
+/** Draft-tolerant count field: the host state is authoritative, but while the
+ * user is typing we show their raw draft — a controlled `value={count.value}`
+ * used to swallow any keystroke the host rejected (typing "10" past an old max,
+ * or clearing the field to retype, silently snapped back), which read as "the
+ * input only takes N digits". Valid integers commit on every keystroke; the
+ * draft resets to the host value on blur. */
+function CountInput({ count, disabled }: { count: PromptListToolbarCount; disabled?: boolean }) {
+  const [draft, setDraft] = useState<string | null>(null);
+  return (
+    <input
+      id={count.id}
+      className="vi-knob-input"
+      type="number"
+      min={count.min ?? 1}
+      max={count.max}
+      value={draft ?? count.value}
+      disabled={disabled}
+      title={count.title}
+      onChange={(e) => {
+        const raw = e.target.value;
+        setDraft(raw);
+        const n = Number(raw);
+        if (raw.trim() !== "" && Number.isInteger(n) && n >= (count.min ?? 1)) count.onChange(n);
+      }}
+      onBlur={() => setDraft(null)}
+    />
+  );
 }
 
 export function PromptListToolbar({
@@ -115,70 +232,237 @@ export function PromptListToolbar({
   onStandardNegatives,
   standardNegativesTitle,
   disabled = false,
+  modelRow,
+  range,
+  negativesOn,
+  onNegativesOnChange,
+  negativesOnTitle,
+  stdChecked,
+  onStdChange,
+  stdTitle,
+  enhanceLabel,
+  enhanceTitle,
+  onEnhance,
+  canEnhance = true,
+  actionsExtra,
+  below,
 }: PromptListToolbarProps) {
   const actionsDisabled = disabled || assistBusy || selectedCount === 0;
+  const grouped =
+    modelRow != null ||
+    range != null ||
+    onNegativesOnChange != null ||
+    onStdChange != null ||
+    onEnhance != null ||
+    actionsExtra != null ||
+    below != null;
+
+  // Clamp + drag rule (k93 §A.1): 1 ≤ start ≤ end ≤ itemCount; raising start above
+  // end drags end up; lowering end below start drags start down.
+  function setRangeStart(raw: string) {
+    if (!range || itemCount === 0) return;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) return;
+    const s = Math.min(Math.max(1, Math.round(n)), itemCount);
+    const e = Math.max(range.end ?? s, s);
+    range.onChange(s, Math.min(e, itemCount));
+  }
+  function setRangeEnd(raw: string) {
+    if (!range || itemCount === 0) return;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) return;
+    const e = Math.min(Math.max(1, Math.round(n)), itemCount);
+    const s = Math.min(range.start ?? e, e);
+    range.onChange(Math.max(s, 1), e);
+  }
+
+  const countKnob = count && (
+    <div className="vi-knob vi-prompt-toolbar-count">
+      <label htmlFor={count.id}>{count.label}</label>
+      <CountInput count={count} disabled={disabled} />
+    </div>
+  );
+
+  const selectAll = (
+    <label className="vi-comfy-hint vi-prompt-toolbar-selectall">
+      <input
+        type="checkbox"
+        checked={allSelected}
+        disabled={disabled || itemCount === 0}
+        onChange={onToggleSelectAll}
+        aria-label={`Select every ${noun}`}
+      />
+      {range ? "select all" : `Select all (${selectedCount}/${itemCount})`}
+    </label>
+  );
+
+  const generateBtn = (
+    <button
+      type="button"
+      className="vi-btn vi-btn-sm vi-btn-accent"
+      disabled={actionsDisabled}
+      title={selectedCount === 0 ? (generateDisabledTitle ?? generateTitle) : generateTitle}
+      onClick={onGenerate}
+    >
+      {generateLabel}
+    </button>
+  );
+
+  if (!grouped) {
+    return (
+      <div
+        className="vi-prompt-toolbar"
+        role="group"
+        aria-label={`${noun} count and group prompt assist`}
+      >
+        {countKnob}
+        {selectAll}
+        {generateBtn}
+        <button
+          type="button"
+          className="vi-btn vi-btn-sm vi-btn-ghost"
+          disabled={actionsDisabled}
+          title={negativesTitle}
+          onClick={onNegatives}
+        >
+          {negativesLabel}
+        </button>
+        <button
+          type="button"
+          className="vi-btn vi-btn-sm vi-btn-ghost"
+          disabled={disabled || itemCount === 0}
+          title={
+            standardNegativesTitle ??
+            "Tick the [standard negative] checkbox on for the selected rows (or every row when none are selected)."
+          }
+          onClick={onStandardNegatives}
+        >
+          standard negatives
+        </button>
+      </div>
+    );
+  }
+
+  // ── k93 three-line group layout ──────────────────────────────────────────
+  //   prompt assist model  [select]
+  //   [start] - [end]   [ ] select all    negatives: [on/off]  [ ] std.
+  //   (✨ generate (N selected))  (✨ enhance (M selected))  [+ video]
   return (
     <div
-      className="vi-prompt-toolbar"
+      className="vi-prompt-toolbar vi-prompt-toolbar-group"
       role="group"
       aria-label={`${noun} count and group prompt assist`}
     >
-      {count && (
-        <div className="vi-knob vi-prompt-toolbar-count">
-          <label htmlFor={count.id}>{count.label}</label>
-          <input
-            id={count.id}
-            className="vi-knob-input"
-            type="number"
-            min={count.min ?? 1}
-            max={count.max}
-            value={count.value}
-            disabled={disabled}
-            title={count.title}
-            onChange={(e) => count.onChange(Number(e.target.value))}
-          />
-        </div>
-      )}
-      <label className="vi-comfy-hint vi-prompt-toolbar-selectall">
-        <input
-          type="checkbox"
-          checked={allSelected}
-          disabled={disabled || itemCount === 0}
-          onChange={onToggleSelectAll}
-          aria-label={`Select every ${noun}`}
-        />
-        Select all ({selectedCount}/{itemCount})
-      </label>
-      <button
-        type="button"
-        className="vi-btn vi-btn-sm vi-btn-accent"
-        disabled={actionsDisabled}
-        title={selectedCount === 0 ? (generateDisabledTitle ?? generateTitle) : generateTitle}
-        onClick={onGenerate}
-      >
-        {generateLabel}
-      </button>
-      <button
-        type="button"
-        className="vi-btn vi-btn-sm vi-btn-ghost"
-        disabled={actionsDisabled}
-        title={negativesTitle}
-        onClick={onNegatives}
-      >
-        {negativesLabel}
-      </button>
-      <button
-        type="button"
-        className="vi-btn vi-btn-sm vi-btn-ghost"
-        disabled={disabled || itemCount === 0}
-        title={
-          standardNegativesTitle ??
-          "Tick the [standard negative] checkbox on for the selected rows (or every row when none are selected)."
-        }
-        onClick={onStandardNegatives}
-      >
-        standard negatives
-      </button>
+      {modelRow && <div className="vi-prompt-toolbar-line">{modelRow}</div>}
+      <div className="vi-prompt-toolbar-line">
+        {countKnob}
+        {range && (
+          <span className="vi-prompt-toolbar-range" title={`1-based ${noun} range the group actions target (text ${noun}s only).`}>
+            <input
+              type="number"
+              className="vi-knob-input vi-prompt-toolbar-range-input"
+              min={1}
+              max={Math.max(1, itemCount)}
+              value={range.start ?? ""}
+              placeholder="start"
+              disabled={disabled || itemCount === 0 || allSelected}
+              aria-label={`First ${noun} of the selection range`}
+              onChange={(e) => setRangeStart(e.target.value)}
+            />
+            <span aria-hidden="true">-</span>
+            <input
+              type="number"
+              className="vi-knob-input vi-prompt-toolbar-range-input"
+              min={1}
+              max={Math.max(1, itemCount)}
+              value={range.end ?? ""}
+              placeholder="end"
+              disabled={disabled || itemCount === 0 || allSelected}
+              aria-label={`Last ${noun} of the selection range`}
+              onChange={(e) => setRangeEnd(e.target.value)}
+            />
+          </span>
+        )}
+        {selectAll}
+        {onNegativesOnChange ? (
+          <label
+            className="vi-comfy-hint vi-prompt-toolbar-neg"
+            title={
+              negativesOnTitle ??
+              "On: group generate / enhance also write each selected row's Negative field. Off: prompts only."
+            }
+          >
+            negatives:
+            <button
+              type="button"
+              className={`vi-btn vi-btn-sm vi-toggle${negativesOn ? " vi-toggle-on" : ""}`}
+              role="switch"
+              aria-checked={!!negativesOn}
+              disabled={disabled}
+              onClick={() => onNegativesOnChange(!negativesOn)}
+            >
+              {negativesOn ? "on" : "off"}
+            </button>
+          </label>
+        ) : (
+          <button
+            type="button"
+            className="vi-btn vi-btn-sm vi-btn-ghost"
+            disabled={actionsDisabled}
+            title={negativesTitle}
+            onClick={onNegatives}
+          >
+            {negativesLabel}
+          </button>
+        )}
+        {onStdChange ? (
+          <label
+            className="vi-comfy-hint vi-prompt-toolbar-std"
+            title={
+              stdTitle ??
+              "Tick: insert the standard exclusion set into every selected row's Negative field (visible, sent as-is). Untick: remove exactly those terms."
+            }
+          >
+            <input
+              type="checkbox"
+              checked={!!stdChecked}
+              disabled={disabled || selectedCount === 0}
+              onChange={(e) => onStdChange(e.target.checked)}
+              aria-label="Insert the standard negative into the selected rows"
+            />
+            std.
+          </label>
+        ) : (
+          <button
+            type="button"
+            className="vi-btn vi-btn-sm vi-btn-ghost"
+            disabled={disabled || itemCount === 0}
+            title={
+              standardNegativesTitle ??
+              "Tick the [standard negative] checkbox on for the selected rows (or every row when none are selected)."
+            }
+            onClick={onStandardNegatives}
+          >
+            standard negatives
+          </button>
+        )}
+      </div>
+      <div className="vi-prompt-toolbar-line">
+        {generateBtn}
+        {onEnhance && (
+          <button
+            type="button"
+            className="vi-btn vi-btn-sm vi-btn-ghost"
+            disabled={actionsDisabled || !canEnhance}
+            title={enhanceTitle}
+            onClick={onEnhance}
+          >
+            {enhanceLabel ?? "✨ enhance"}
+          </button>
+        )}
+        {actionsExtra}
+      </div>
+      {below}
     </div>
   );
 }
@@ -349,6 +633,18 @@ export interface PromptFieldTabsProps {
   negativeExtras?: ReactNode;
   /** Rendered under the prompt pane when it is active. */
   promptExtras?: ReactNode;
+  /**
+   * k93: render the editor labels ("prompt" / "negative prompt (optional)")
+   * visually hidden — the tabs already say it. aria-labels are kept.
+   */
+  hideLabels?: boolean;
+  /**
+   * k93: omit the tab-strip [standard negative] tick (the host renders an
+   * explicit std. checkbox of its own in its assist row).
+   */
+  hideStdTick?: boolean;
+  /** Tooltip on the Negative tab (Scene: "part #1's field is also the group negative"). */
+  negativeTabTitle?: string;
 }
 
 export function PromptFieldTabs({
@@ -370,6 +666,9 @@ export function PromptFieldTabs({
   disabled = false,
   negativeExtras,
   promptExtras,
+  hideLabels = false,
+  hideStdTick = false,
+  negativeTabTitle,
 }: PromptFieldTabsProps) {
   // Ephemeral VIEW state only — which pane shows. All editor data rides props.
   const [tab, setTab] = useState<"prompt" | "negative">("prompt");
@@ -393,13 +692,14 @@ export function PromptFieldTabs({
           className="vi-prompt-tab"
           aria-selected={active === "negative"}
           disabled={negativeLocked}
-          title={negativeDisabledNote}
+          title={negativeDisabledNote ?? negativeTabTitle}
           onClick={() => setTab("negative")}
         >
           Negative
           {/* The content marker — tab state must not hide a written negative. */}
           {negative.trim() !== "" && <span className="vi-prompt-tab-dot" aria-label="has content" />}
         </button>
+        {!hideStdTick && (
         <label
           className="vi-comfy-hint vi-prompt-tab-std"
           title={
@@ -415,12 +715,14 @@ export function PromptFieldTabs({
           />
           standard negative
         </label>
+        )}
       </div>
       {active === "prompt" ? (
         <>
           <GoalComposer
             id={`${idPrefix}-prompt`}
             label={promptLabel}
+            hideLabel={hideLabels}
             value={prompt}
             placeholder={promptPlaceholder}
             onChange={onPromptChange}
@@ -435,6 +737,7 @@ export function PromptFieldTabs({
           <GoalComposer
             id={`${idPrefix}-negative`}
             label={negativeLabel}
+            hideLabel={hideLabels}
             value={negative}
             placeholder={negativePlaceholder}
             onChange={onNegativeChange}

package/src/stations/studio/useIdentityCreateJob.ts

@@ -0,0 +1,184 @@
+// k94 — the ONE-PATH "Create identity" job watcher.
+//
+// Both create routes (from-video → identity_from_video, from-images →
+// identity_mesh_build) hand back a bus job_id; this hook polls the generic
+// GET /video/jobs/<id> (`videoJobUrl`) the way the other identity flows in this
+// station do, and reduces the reply to what the panel shows on ONE line:
+//   stage · % · log tail
+// `progress` is the relay's mirrored blob ({stage, progress 0..1, log_tail[]}
+// — additive fields an older render service may omit), `progress_ratio` is the
+// bus's numeric bar, `result` is the terminal JobResult ({ok, error?,
+// identities?}). Terminal = `result.ok` is a boolean. Bounded (90 min — char360
+// plus a textured Hunyuan3D mesh PER character runs minutes each; clownworld's
+// own ceiling) so a wedged remote never spins the panel forever.
+//
+// Why not the session job tracker (video/jobTracker.ts)? Its JobKind/StationId
+// unions + per-kind terminal parse are closed over the crop/frames/generate
+// arms; widening them is a cross-station change outside this task's files. The
+// poll shape here is the same one ExtractFromVideoPanel / generateFullIdentity
+// already use in this station.
+import { useCallback, useEffect, useRef, useState } from "react";
+import { request, okValue } from "../../transport/client";
+import { videoJobUrl } from "../../config";
+
+export type CreateJobPhase = "idle" | "queued" | "running" | "done" | "error";
+
+export interface CreatedIdentity {
+  char?: string;
+  slug: string;
+  name?: string;
+  glb?: boolean;
+  n_views?: number;
+  canonical?: number;
+  error?: string;
+}
+
+export interface CreateJobView {
+  phase: CreateJobPhase;
+  jobId: string | null;
+  /** The remote stage ("detect", "mesh", …) or the bus's current_stage. */
+  stage: string | null;
+  /** 0..100 when the job reports anything measurable, else null. */
+  pct: number | null;
+  /** The last line of the relay's mirrored log tail. */
+  logLine: string | null;
+  /** Human error text on failure (enqueue or job). */
+  error: string | null;
+  /** from-video: the profiles the job minted (empty for from-images). */
+  identities: CreatedIdentity[];
+}
+
+const IDLE: CreateJobView = {
+  phase: "idle", jobId: null, stage: null, pct: null, logLine: null, error: null, identities: [],
+};
+
+const POLL_MS = 4000;
+const CAP_MS = 90 * 60 * 1000;
+
+type JobReply = {
+  status?: string | null;
+  progress?: { stage?: unknown; progress?: unknown; log_tail?: unknown; message?: unknown } | null;
+  progress_ratio?: number | null;
+  current_stage?: string | null;
+  result?: {
+    ok?: boolean;
+    error?: { message?: string } | null;
+    identities?: { profiles?: CreatedIdentity[] } | null;
+  } | null;
+};
+
+export interface CreateJobApi {
+  view: CreateJobView;
+  /** Start watching a job; `onDone(identities)` fires once on success. */
+  watch: (jobId: string, onDone?: (ids: CreatedIdentity[]) => void) => void;
+  /** Surface an enqueue-time failure on the same line. */
+  fail: (message: string) => void;
+  reset: () => void;
+}
+
+export function useIdentityCreateJob(): CreateJobApi {
+  const [view, setView] = useState<CreateJobView>(IDLE);
+  const timer = useRef<number | null>(null);
+  const active = useRef(false);
+
+  const stop = useCallback(() => {
+    active.current = false;
+    if (timer.current != null) {
+      window.clearTimeout(timer.current);
+      timer.current = null;
+    }
+  }, []);
+
+  useEffect(() => stop, [stop]);
+
+  const watch = useCallback<CreateJobApi["watch"]>(
+    (jobId, onDone) => {
+      stop();
+      active.current = true;
+      setView({ ...IDLE, phase: "queued", jobId });
+      const deadline = Date.now() + CAP_MS;
+
+      const pollOnce = async () => {
+        if (!active.current) return;
+        if (Date.now() > deadline) {
+          stop();
+          setView((v) => ({ ...v, phase: "error", error: "Timed out waiting for the identity build." }));
+          return;
+        }
+        const res = await request<unknown>(videoJobUrl(jobId), {
+          meta: { specKey: "studio", operation: "identity.create.status" },
+        });
+        if (!active.current) return;
+        if (res.ok) {
+          const job = okValue(res) as JobReply;
+          const result = job.result;
+          if (result && typeof result.ok === "boolean") {
+            stop();
+            if (result.ok) {
+              const ids = (result.identities && Array.isArray(result.identities.profiles)
+                ? result.identities.profiles
+                : []).filter((p) => p && typeof p.slug === "string");
+              setView((v) => ({ ...v, phase: "done", pct: 100, identities: ids, error: null }));
+              if (onDone) onDone(ids);
+            } else {
+              setView((v) => ({
+                ...v,
+                phase: "error",
+                error: (result.error && result.error.message) || "The identity build failed.",
+              }));
+            }
+            return;
+          }
+          const blob = job.progress || {};
+          const stage =
+            (typeof blob.stage === "string" && blob.stage) ||
+            (typeof blob.message === "string" && blob.message) ||
+            job.current_stage ||
+            null;
+          const ratio =
+            typeof job.progress_ratio === "number"
+              ? job.progress_ratio
+              : typeof blob.progress === "number"
+                ? blob.progress
+                : null;
+          const tail = Array.isArray(blob.log_tail) ? blob.log_tail : [];
+          const last = tail.length ? tail[tail.length - 1] : null;
+          setView((v) => ({
+            ...v,
+            phase: job.status === "running" ? "running" : "queued",
+            stage,
+            pct: ratio == null ? null : Math.max(0, Math.min(100, Math.round(ratio * 100))),
+            logLine: typeof last === "string" ? last : null,
+          }));
+        }
+        // queued / running / transient poll failure → keep polling.
+        timer.current = window.setTimeout(() => void pollOnce(), POLL_MS);
+      };
+      timer.current = window.setTimeout(() => void pollOnce(), POLL_MS);
+    },
+    [stop],
+  );
+
+  const fail = useCallback<CreateJobApi["fail"]>((message) => {
+    stop();
+    setView({ ...IDLE, phase: "error", error: message });
+  }, [stop]);
+
+  const reset = useCallback(() => {
+    stop();
+    setView(IDLE);
+  }, [stop]);
+
+  return { view, watch, fail, reset };
+}
+
+/** The one-line progress text: "stage · 42% · last log line". */
+export function describeCreateJob(v: CreateJobView): string | null {
+  if (v.phase === "idle") return null;
+  if (v.phase === "error") return v.error || "failed";
+  if (v.phase === "done") return "done";
+  const parts: string[] = [v.phase === "queued" && !v.stage ? "queued" : (v.stage || "running")];
+  if (v.pct != null) parts.push(`${v.pct}%`);
+  if (v.logLine) parts.push(v.logLine);
+  return parts.join(" · ");
+}