Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

25.9 KB
Raw Blame
import { useCallback, useEffect, useRef, useState } from 'react';
import { useNavigate, useSearchParams } from 'react-router';
import { composeStyledPrompt, stylePromptAdditions } from '../lib/composeStyledPrompt';
import {
  FAL_IMAGE_MODEL_IDS, RUNWAY_IMAGE_MODEL_IDS,
  IMAGE_GEN_MODE,
  isCloudCliMode,
  modeLabel,
} from '../lib/imageGenBackends';
import { clampImageEdge } from '../lib/imageGenResolutions';
import { useImageGenForm } from './useImageGenForm';
import { useImageGenGallery } from './useImageGenGallery';
import { useSocketResource } from './useSocketResource';
import { useFederatedMediaTarget } from './useFederatedMediaTarget';
import { useImageGenProgress } from './useImageGenProgress';
import { useMediaCompletionRefresh } from './useMediaCompletionRefresh';
import { useMediaJobSse, isMediaRunEnded } from './useMediaJobSse';
import { useModelDownloadStatus } from './useModelDownloadStatus';
import { useHfTokenStatus } from './useHfTokenStatus';
import { useAgyModels } from './useAgyModels';
import { useModelInputPreview } from './useModelInputPreview';
import toast from '../components/ui/Toast';
import {
  buildFormData,
  cancelImageGen,
  generateImage,
  generateImageMultipart,
  getActiveImageJob,
  getFlux2Status,
  getImageGenStatus,
  getRegenAvailability,
  listMediaJobs,
  previewImagePrompt,
  regenerateGalleryImage,
} from '../services/api';
import { musicVideoFilingFields } from '../lib/musicVideoFiling';

// The style presets folded into the prompt, recorded beside it on the render (#11317).
const promptAdditionsField = (presets) => {
  const additions = stylePromptAdditions(presets);
  return additions.length ? { promptAdditions: additions } : {};
};

const IMAGE_QUEUE_EVENTS = ['media-jobs:changed'];

const STAGE_LABELS = {
  starting: 'Starting…',
  'download-tokenizer': 'Loading tokenizer…',
  'download-pipeline': 'Downloading model weights (~8 GB on first run)…',
  'download-snapshot': 'Downloading model weights…',
  'download-int8-snapshot': 'Downloading model weights (~16 GB on first run)…',
  'load-transformer': 'Loading transformer…',
  'load-text-encoder': 'Loading text encoder…',
  'move-to-device': 'Moving model to GPU…',
  inference: 'Running diffusion…',
};

function useImageGenBackendRuntime() {
  const [status, setStatus] = useState(null);
  const [statusLoading, setStatusLoading] = useState(true);
  const [selectedMode, setSelectedMode] = useState(null);
  const [availableBackends, setAvailableBackends] = useState([]);
  const selectedModeRef = useRef(null);
  selectedModeRef.current = selectedMode;
  const statusRequestToken = useRef(0);
  const effectiveMode = selectedMode || status?.mode || IMAGE_GEN_MODE.EXTERNAL;
  const isLocalMode = effectiveMode === IMAGE_GEN_MODE.LOCAL;
  const isCloudMode = isCloudCliMode(effectiveMode);
  const cloudModeLabel = modeLabel(effectiveMode);
  const isAgyMode = effectiveMode === IMAGE_GEN_MODE.AGY;
  const isRunwayMode = effectiveMode === IMAGE_GEN_MODE.RUNWAY;
  const isFalMode = effectiveMode === IMAGE_GEN_MODE.FAL;
  const remoteTarget = useFederatedMediaTarget('image');
  const remoteTargetActive = effectiveMode !== IMAGE_GEN_MODE.GROK && remoteTarget.isRemote;
  const localBackendPending = statusLoading && !remoteTargetActive;
  const agy = useAgyModels(isAgyMode);

  const refreshStatus = useCallback((mode, localModelId) => {
    const requestToken = ++statusRequestToken.current;
    setStatusLoading(true);
    getImageGenStatus(mode, mode === IMAGE_GEN_MODE.LOCAL ? localModelId : undefined)
      .then((nextStatus) => {
        if (requestToken !== statusRequestToken.current) return;
        setStatus(nextStatus);
      })
      .catch(() => {
        if (requestToken !== statusRequestToken.current) return;
        setStatus({ connected: false, reason: 'Status check failed' });
      })
      .finally(() => {
        if (requestToken === statusRequestToken.current) setStatusLoading(false);
      });
  }, []);

  const configureBackends = useCallback((backends, savedMode) => {
    const previous = selectedModeRef.current;
    const next = (previous && backends.find((backend) => backend.id === previous)) ? previous
      : backends.find((backend) => backend.id === savedMode) ? savedMode
      : backends.length ? backends[0].id
      : savedMode;
    setAvailableBackends(backends);
    setSelectedMode(next);
    return next;
  }, []);

  return {
    status,
    statusLoading,
    availableBackends,
    effectiveMode,
    isLocalMode,
    isCloudMode,
    cloudModeLabel,
    isAgyMode,
    isRunwayMode,
    isFalMode,
    remoteTarget,
    remoteTargetActive,
    localBackendPending,
    agy,
    refreshStatus,
    setSelectedMode,
    configureBackends,
  };
}

export function useImageGenPageRuntime() {
  const navigate = useNavigate();
  const [searchParams, setSearchParams] = useSearchParams();
  const settingsOpen = searchParams.get('settings') === '1';
  const openSettings = () => setSearchParams((previous) => {
    const next = new URLSearchParams(previous);
    next.set('settings', '1');
    return next;
  });
  const closeSettings = () => setSearchParams((previous) => {
    const next = new URLSearchParams(previous);
    next.delete('settings');
    return next;
  });
  const backend = useImageGenBackendRuntime();
  const form = useImageGenForm({ searchParams, setSearchParams, backend });
  const gallery = useImageGenGallery({ previewParam: searchParams.get('preview') });
  const [flux2Status, setFlux2Status] = useState(null);
  const [flux2InstallOpen, setFlux2InstallOpen] = useState(false);
  const [generating, setGenerating] = useState(false);
  const [statusMsg, setStatusMsg] = useState('');
  const [errorMeta, setErrorMeta] = useState(null);
  const [localProgress, setLocalProgress] = useState(null);
  const [stage, setStage] = useState(null);
  const [result, setResult] = useState(null);
  const [error, setError] = useState(null);
  const [regenInfo, setRegenInfo] = useState(null);
  // One run owner for the displayed render: Cancel targets exactly its job, and
  // unmount detaches the stream without cancelling accepted durable work.
  const { start: startRun, cancel: cancelRun } = useMediaJobSse('image', {
    cancelJob: (jobId) => cancelImageGen({ jobId }),
  });
  const { progress: externalProgress, begin: beginGenerate, end: endGenerate, resume: resumeGenerate } = useImageGenProgress();
  useMediaCompletionRefresh({ onImageCompleted: gallery.refreshRecent });
  const modelDownload = useModelDownloadStatus({ kind: 'image' });
  const { present: hfTokenPresent, refresh: refreshHfTokenStatus } = useHfTokenStatus({ enabled: form.derived.needsHfTokenGate });
  const progress = externalProgress || localProgress;
  const progressPct = progress?.progress != null ? Math.round(progress.progress * 100) : null;
  const { fields, derived, images, actions } = form;
  const { effectiveMode, isCloudMode, remoteTargetActive } = backend;
  const effectiveAgyModel = backend.agy.models.includes(fields.agyModel) ? fields.agyModel : '';
  // Only a catalog id is ever sent — the server refuses anything else.
  const effectiveFalModel = FAL_IMAGE_MODEL_IDS.includes(fields.falModel) ? fields.falModel : '';
  const effectiveRunwayModel = RUNWAY_IMAGE_MODEL_IDS.includes(fields.runwayModel) ? fields.runwayModel : '';
  const effectiveCloudModel = backend.isAgyMode ? effectiveAgyModel : backend.isFalMode ? effectiveFalModel : backend.isRunwayMode ? effectiveRunwayModel : '';

  useEffect(() => {
    if (!effectiveMode) return;
    backend.refreshStatus(effectiveMode, fields.modelId);
  }, [effectiveMode, fields.modelId, backend.refreshStatus]);

  const refreshFlux2Status = useCallback((signal) => getFlux2Status({ modelId: fields.modelId, signal })
    .then((status) => { if (status) setFlux2Status(status); })
    .catch(() => {}), [fields.modelId]);

  const handleFlux2ModalClose = useCallback(() => setFlux2InstallOpen(false), []);
  const handleFlux2InstallComplete = useCallback(() => {
    refreshFlux2Status();
    backend.refreshStatus(effectiveMode, fields.modelId);
    toast.success('FLUX.2 runtime installed');
  }, [refreshFlux2Status, backend.refreshStatus, effectiveMode, fields.modelId]);

  useEffect(() => {
    if (!derived.sharesFlux2Venv) {
      setFlux2Status(null);
      return;
    }
    const controller = new AbortController();
    refreshFlux2Status(controller.signal);
    return () => controller.abort();
  }, [derived.sharesFlux2Venv, fields.modelId, refreshFlux2Status]);

  useEffect(() => {
    // Adopt the job still running server-side after a reload. `ifIdle` yields to
    // a render this tab already owns; the owner creates no stream (or
    // presentation) when the page unmounts before the read resolves.
    startRun(
      () => getActiveImageJob().then(({ activeJob }) => activeJob),
      {
        onAcknowledged: (activeJob) => {
          actions.restoreActiveJob(activeJob);
          setGenerating(true);
          setStatusMsg('Resuming…');
          resumeGenerate(activeJob);
        },
        onStatus: (message) => setStatusMsg(message.message),
        onProgress: (message) => setLocalProgress({ progress: message.progress }),
        onComplete: () => setGenerating(false),
        onError: () => setGenerating(false),
        onCanceled: () => setGenerating(false),
        onConnectionError: () => setGenerating(false),
      },
      { ifIdle: true, jobIdOf: (activeJob) => activeJob?.generationId },
    ).catch(() => {});
  }, [actions.restoreActiveJob, startRun, resumeGenerate]);

  const regenAvailable = !!regenInfo?.available;
  const refreshRegenAvailability = useCallback(() => {
    getRegenAvailability().then((availability) => setRegenInfo(availability || null)).catch(() => {});
  }, []);
  useEffect(() => { refreshRegenAvailability(); }, [refreshRegenAvailability]);

  const wasSettingsOpenRef = useRef(false);
  useEffect(() => {
    if (wasSettingsOpenRef.current && !settingsOpen) {
      refreshRegenAvailability();
      form.settings.reloadBackends();
    }
    wasSettingsOpenRef.current = settingsOpen;
  }, [settingsOpen, refreshRegenAvailability, form.settings.reloadBackends]);

  const { data: queueJobs, updateData: updateQueueJobs } = useSocketResource(
    () => listMediaJobs({ kind: 'image' }),
    { events: IMAGE_QUEUE_EVENTS },
  );
  const previousQueueRef = useRef(null);
  useEffect(() => {
    if (!queueJobs) return;
    const previous = previousQueueRef.current;
    previousQueueRef.current = queueJobs;
    if (!previous) return;
    const activeIds = new Set(queueJobs
      .filter((job) => job.status === 'queued' || job.status === 'running')
      .map((job) => job.id));
    // Recover gallery output when a terminal event was missed while offline.
    // Compare identities, not just counts: another enqueue can replace a job.
    if (previous.some((job) => ['queued', 'running'].includes(job.status) && !activeIds.has(job.id))) {
      gallery.refreshRecent();
    }
  }, [queueJobs, gallery.refreshRecent]);
  const pendingQueued = Math.max(0, (queueJobs || [])
    .filter((job) => job.status === 'queued' || job.status === 'running').length - (generating ? 1 : 0));
  const rememberQueuedJob = (ack) => {
    const id = ack?.jobId || ack?.generationId;
    if (!id) return;
    // The queue event may beat the HTTP acknowledgement. Merge by id so the
    // response cannot double-count a job or revive an already completed one.
    updateQueueJobs((previous) => (previous || []).some((job) => job.id === id)
      ? previous : [...(previous || []), { id, status: ack.status || 'queued' }]);
  };

  const buildGenerationPayload = () => {
    const composed = composeStyledPrompt(fields.prompt, fields.negativePrompt, derived.activeStylePresets);
    const width = clampImageEdge(fields.width);
    const height = clampImageEdge(fields.height);
    const payload = remoteTargetActive ? {
      prompt: composed.prompt,
      negativePrompt: composed.negativePrompt || undefined,
      width,
      height,
      steps: fields.steps ? Number(fields.steps) : undefined,
      guidance: fields.guidance ? Number(fields.guidance) : undefined,
      seed: fields.seed && Number(fields.seed) >= 0 ? Number(fields.seed) : undefined,
      ...backend.remoteTarget.submissionFields,
    } : isCloudMode ? {
      prompt: composed.prompt,
      negativePrompt: composed.negativePrompt || undefined,
      width,
      height,
      mode: effectiveMode,
      ...(effectiveCloudModel ? { cloudModel: effectiveCloudModel } : {}),
      cleanC2PA: fields.cleanC2PA,
      denoise: fields.denoise,
    } : {
      prompt: composed.prompt,
      negativePrompt: composed.negativePrompt || undefined,
      modelId: fields.modelId || undefined,
      width,
      height,
      steps: fields.steps ? Number(fields.steps) : undefined,
      guidance: fields.guidance ? Number(fields.guidance) : undefined,
      seed: fields.seed && Number(fields.seed) >= 0 ? Number(fields.seed) : undefined,
      quantize: derived.currentModel?.runner === 'moss-swift' ? undefined : fields.quantize,
      loraFilenames: fields.selectedLoras.map((lora) => lora.filename),
      loraScales: fields.selectedLoras.map((lora) => lora.scale),
      mode: IMAGE_GEN_MODE.LOCAL,
      cleanC2PA: fields.cleanC2PA,
      denoise: fields.denoise,
    };
    Object.assign(payload, musicVideoFilingFields(searchParams), promptAdditionsField(derived.activeStylePresets));
    const hasInitImage = derived.i2iCapable && images.initImage.source != null;
    const hasReferenceImages = derived.populatedRefs.length > 0;
    const initFields = hasInitImage ? {
      ...(images.initImage.source === 'upload'
        ? { initImage: images.initImage.file }
        : { initImageFile: images.initImage.name }),
      initImageStrength: images.initImageStrength,
    } : {};
    const referenceFields = hasReferenceImages ? {
      ...Object.fromEntries(derived.populatedRefs.map((slot, index) => [`referenceImage${index + 1}`, slot.file])),
      referenceStrengths: derived.populatedRefs.map((slot) => slot.strength),
    } : {};
    return { payload, initFields, referenceFields, hasInputImages: hasInitImage || hasReferenceImages };
  };

  // The same request as Generate, with uploads named by count (#11317).
  const previewBody = (() => {
    if (!derived.isAsyncMode) {
      const composed = composeStyledPrompt(fields.prompt, fields.negativePrompt, derived.activeStylePresets);
      return {
        prompt: composed.prompt, negativePrompt: composed.negativePrompt || undefined,
        width: clampImageEdge(fields.width), height: clampImageEdge(fields.height), mode: IMAGE_GEN_MODE.EXTERNAL,
        ...promptAdditionsField(derived.activeStylePresets),
      };
    }
    const { payload, initFields, referenceFields } = buildGenerationPayload();
    const { initImage, ...initRest } = initFields;
    const { referenceStrengths, ...referenceUploads } = referenceFields;
    const uploadedReferenceCount = Object.keys(referenceUploads).length;
    return {
      ...payload, ...initRest,
      ...(initImage ? { uploadedInitImage: true } : {}),
      ...(uploadedReferenceCount ? { uploadedReferenceCount, referenceStrengths } : {}),
    };
  })();
  const modelInputPreview = useModelInputPreview(previewImagePrompt, previewBody, {
    enabled: !form.remix.pending && !derived.cloudNeedsPrompt && !derived.editImageMissing,
  });

  const submitGenerationPayload = async () => {
    const { payload, initFields, referenceFields, hasInputImages } = buildGenerationPayload();
    if (hasInputImages) {
      const formData = buildFormData({ ...payload, ...initFields, ...referenceFields });
      const data = await generateImageMultipart(formData, { silent: true });
      rememberQueuedJob(data);
      return { payload, data };
    }
    const data = await generateImage(payload, { silent: true });
    rememberQueuedJob(data);
    return { payload, data };
  };

  const startLocalGeneration = () => {
    setLocalProgress({ progress: 0 });
    let submitted;
    return startRun(async () => {
      submitted = await submitGenerationPayload();
      return submitted.data;
    }, (data) => ({
      onStage: (message) => setStage({ name: message.stage, detail: message.detail }),
      onStatus: (message) => setStatusMsg(message.message),
      onProgress: (message) => {
        setLocalProgress({ progress: message.progress, phase: message.phase });
        setStatusMsg(message.message);
      },
      onComplete: (message) => {
        const { payload } = submitted;
        const localOnlyMeta = isCloudMode ? {} : {
          steps: payload.steps ?? derived.currentModel?.steps,
          guidance: payload.guidance ?? derived.currentModel?.guidance,
        };
        setResult({
          ...data,
          ...message.result,
          prompt: payload.prompt,
          negativePrompt: payload.negativePrompt,
          width: payload.width,
          height: payload.height,
          ...localOnlyMeta,
        });
        return message.result;
      },
      onError: (message) => {
        const generationError = new Error(message.error);
        if (message.kind) generationError.kind = message.kind;
        if (message.repo) generationError.repo = message.repo;
        return generationError;
      },
    }));
  };

  const queueAdditional = async (count = 1) => {
    if (count < 1) return;
    const submissions = Array.from({ length: count }, () => (
      submitGenerationPayload().then(({ data }) => data).catch((generationError) => generationError)
    ));
    const results = await Promise.all(submissions);
    const queued = results.filter((result) => result && !(result instanceof Error)).length;
    const failed = results.length - queued;
    if (queued > 0) toast.success(count === 1 ? 'Queued' : `Queued ${queued}`);
    if (failed > 0) toast.error(`${failed} job(s) failed to queue`);
  };

  const handleGenerate = async (event) => {
    event?.preventDefault?.();
    if (form.remix.pending || derived.loraHandoffBlocked || derived.unsupportedLocalInputs) return;
    if (derived.editImageMissing || derived.cloudNeedsPrompt) return;
    if (derived.localBackendPending || (!remoteTargetActive && derived.notConnected)) return;
    if (remoteTargetActive) {
      if (derived.remoteUnsupportedInputs) {
        toast.error(derived.remoteUnsupportedInputs);
        return;
      }
      const fresh = backend.remoteTarget.verify();
      if (!fresh.ok) {
        toast.error(fresh.message);
        return;
      }
    }
    const batch = derived.isAsyncMode ? Math.max(1, fields.batchCount) : 1;
    if (generating) return queueAdditional(batch);
    const width = clampImageEdge(fields.width);
    const height = clampImageEdge(fields.height);
    if (width !== fields.width) fields.setWidth(width);
    if (height !== fields.height) fields.setHeight(height);
    setGenerating(true);
    setStatusMsg('Starting...');
    setError(null);
    setErrorMeta(null);
    setResult(null);
    setStage(null);
    beginGenerate();

    try {
      if (derived.isAsyncMode) {
        const extras = batch > 1 ? queueAdditional(batch - 1) : Promise.resolve();
        await startLocalGeneration();
        await extras;
      } else {
        const composed = composeStyledPrompt(fields.prompt, fields.negativePrompt, derived.activeStylePresets);
        const payload = {
          prompt: composed.prompt,
          negativePrompt: composed.negativePrompt || undefined,
          width,
          height,
          steps: fields.steps ? Number(fields.steps) : 25,
          cfgScale: fields.cfgScale,
          mode: IMAGE_GEN_MODE.EXTERNAL,
          cleanC2PA: fields.cleanC2PA,
          denoise: fields.denoise,
        };
        if (fields.seed && Number(fields.seed) >= 0) payload.seed = Number(fields.seed);
        Object.assign(payload, musicVideoFilingFields(searchParams), promptAdditionsField(derived.activeStylePresets));
        const data = await generateImage(payload, { silent: true });
        setResult({
          ...data,
          prompt: payload.prompt,
          negativePrompt: payload.negativePrompt,
          width,
          height,
          steps: payload.steps,
          cfgScale: payload.cfgScale,
        });
      }
      toast.success('Image generated');
      gallery.refreshRecent();
    } catch (generationError) {
      // Cancelled / detached runs are not failures: Cancel already did the
      // presentation, and an unmounted page has nothing to present.
      if (isMediaRunEnded(generationError)) return;
      setError(generationError.message || 'Image generation failed');
      if (generationError.kind) setErrorMeta({ kind: generationError.kind, repo: generationError.repo });
      const firstLine = String(generationError.message || 'Image generation failed').split('\n')[0];
      toast.error(firstLine);
    } finally {
      setGenerating(false);
      setLocalProgress(null);
      setStage(null);
      endGenerate();
    }
  };

  const handleCancel = async () => {
    // Cancel exactly the render this page owns. Only a render with no owned job
    // (a synchronous external-service call) falls back to the legacy
    // "most recent job" cancel.
    const owned = await cancelRun();
    if (!owned) await cancelImageGen().catch(() => {});
    setGenerating(false);
    setStatusMsg('Cancelled');
  };

  const handleRegenerate = async (image, options = {}) => {
    if (!image?.filename) throw new Error('Missing filename');
    if (options.method === 'light') {
      const variant = await regenerateGalleryImage(image.filename, { method: 'light' }).catch((generationError) => {
        toast.error(generationError.message || 'Failed to run light regen');
        throw generationError;
      });
      gallery.actions.prependVariant(variant);
      toast.success(`Light regen → ${variant.filename}`);
      return;
    }
    const ack = await regenerateGalleryImage(image.filename, { strength: options.strength, prompt: options.prompt }).catch((generationError) => {
      toast.error(generationError.message || 'Failed to start regeneration');
      throw generationError;
    });
    rememberQueuedJob(ack);
    toast.success('Regenerating — the new image will appear when it finishes');
  };

  const sendToVideo = useCallback((item) => {
    const image = item?.raw || item;
    if (!image?.filename) return;
    const params = new URLSearchParams({ sourceImageFile: image.filename });
    const sourcePrompt = image.prompt || image.metadata?.prompt;
    const sourceNegative = image.negativePrompt || image.negative_prompt || image.metadata?.negativePrompt;
    if (sourcePrompt) params.set('prompt', sourcePrompt);
    if (sourceNegative) params.set('negativePrompt', sourceNegative);
    navigate(`/media/video?${params}`);
  }, [navigate]);

  const handleSendToImage = useCallback((item) => {
    const image = item?.raw || item;
    if (!image?.filename) return;
    actions.handleRemix(image, { applyModel: false });
    fields.setPrompt(image.prompt || '');
    actions.ensureI2iCapableMode();
    actions.setGalleryInitImage(image.filename);
  }, [actions.ensureI2iCapableMode, actions.handleRemix, actions.setGalleryInitImage, fields.setPrompt]);

  const handleSendTo3d = useCallback((item) => {
    const image = item?.raw || item;
    if (!image?.filename) return;
    navigate(`/3d?image=${encodeURIComponent(image.filename)}`);
  }, [navigate]);

  return {
    form,
    backend: { ...backend, effectiveAgyModel, effectiveFalModel, effectiveRunwayModel },
    generation: {
      handleGenerate,
      handleCancel,
      generating,
      statusMsg,
      errorMeta,
      progress,
      progressPct,
      pendingQueued,
      stage,
      stageLabel: stage ? (STAGE_LABELS[stage.name] || stage.name) : null,
      result,
      error,
      modelDownload,
      hfTokenPresent,
      refreshHfTokenStatus,
      flux2Status,
      refreshFlux2Status,
      needsFlux2Token: derived.isFlux2Model && !!flux2Status && flux2Status.venvInstalled && !flux2Status.hfTokenPresent,
      handleRegenerate,
      modelInputPreview,
    },
    gallery: {
      view: gallery.view,
      cards: {
        setPreview: gallery.preview.set,
        handleRemix: actions.handleRemix,
        handleSendToImage,
        sendToVideo,
        handleSendTo3d,
        handleDelete: gallery.actions.delete,
        handleToggleHidden: gallery.actions.toggleHidden,
        getCardProps: gallery.getCardProps,
        toggleGalleryStar: gallery.actions.toggleStar,
      },
      overlay: {
        value: gallery.preview.value,
        set: gallery.preview.set,
        items: gallery.preview.items,
        annotations: gallery.preview.annotations,
        updateAnnotation: gallery.preview.updateAnnotation,
        onPromptSaved: gallery.actions.promptSaved,
        onRemix: (item) => item?.raw && actions.handleRemix(item.raw),
        onSendToImage: (item) => item?.raw?.filename && handleSendToImage(item.raw),
        onSendToVideo: (item) => item?.raw?.filename && sendToVideo(item.raw),
        onSendTo3d: (item) => item?.raw?.filename && handleSendTo3d(item.raw),
        onClean: (item) => gallery.actions.clean(item?.raw),
        onRegenerate: (item, options) => handleRegenerate(item?.raw, options),
        onRemoveWatermark: (item) => gallery.actions.removeWatermark(item?.raw),
        regenAvailable,
        regenBounds: regenInfo,
      },
      picker: {
        value: images.galleryPicker,
        onClose: () => images.setGalleryPicker(null),
        onSelect: images.handleGallerySelect,
      },
    },
    header: {
      status: {
        loading: backend.statusLoading,
        value: backend.status,
        ready: derived.statusReady,
        unknown: derived.statusUnknown,
        mode: effectiveMode,
      },
      backends: {
        available: backend.availableBackends,
        value: effectiveMode,
        onChange: actions.switchMode,
      },
      remix: form.remix,
      actions: {
        onRefresh: () => backend.refreshStatus(effectiveMode, fields.modelId),
        onOpenSettings: openSettings,
        onInstallRuntime: () => setFlux2InstallOpen(true),
      },
    },
    settings: {
      open: settingsOpen,
      onClose: closeSettings,
    },
    flux2: {
      open: flux2InstallOpen,
      onClose: handleFlux2ModalClose,
      onComplete: handleFlux2InstallComplete,
      modelId: fields.modelId,
    },
  };
}