updated

backend/analyze.go

@@ -613,13 +613,11 @@ func mergeAnalyzeHits(in []analyzeHit) []analyzeHit {
 	for i := 1; i < len(cp); i++ {
 		n := cp[i]
 
-		// Nur direkt aufeinanderfolgende Treffer mit gleichem Label zusammenfassen
+		// Direkt aufeinanderfolgende Treffer mit gleichem Label immer zusammenfassen.
-		const mergeGapSeconds = 1.0
+		// Sobald ein anderes Label dazwischen liegt, wird automatisch nicht gemergt.
-
 		sameLabel := strings.EqualFold(cur.Label, n.Label)
-		touchesOrNear := n.Start <= cur.End+mergeGapSeconds
 
-		if sameLabel && touchesOrNear {
+		if sameLabel {
 			if n.Start < cur.Start {
 				cur.Start = n.Start
 			}

backend/assets_generate.go

@@ -932,7 +932,6 @@ func ensureAssetsForVideoDetailed(ctx context.Context, videoPath string, sourceU
 			}); err != nil {
 				if isFFmpegInputInvalidError(err) {
 					sourceInputInvalid = true
-					fmt.Printf("⚠️ preview clips skipped (invalid/incomplete input): %s\n", videoPath)
 					return
 				}
 				return

backend/tasks_regenerate_assets.go

@@ -14,10 +14,35 @@ import (
 	"time"
 )
 
+const regenerateAssetsMaxParallel = 3
+
 type regenerateAssetsRequest struct {
 	File string `json:"file"`
 }
 
+type regenerateAssetsJob struct {
+	File      string
+	VideoPath string
+	AssetID   string
+
+	Ctx    context.Context
+	Cancel context.CancelFunc
+
+	State string // queued | running | done | error | cancelled
+	Error string
+
+	EnqueuedAt time.Time
+	StartedAt  time.Time
+	EndedAt    time.Time
+}
+
+var (
+	regenerateAssetsMu             sync.Mutex
+	regenerateAssetsJobs           = map[string]*regenerateAssetsJob{} // key = file
+	regenerateAssetsQueue          []string                            // file names
+	regenerateAssetsWorkersStarted bool
+)
+
 func publishFinishedPostworkPhase(
 	file string,
 	assetID string,
@@ -41,11 +66,274 @@ func publishFinishedPostworkPhase(
 	}
 }
 
-var (
+func ensureRegenerateAssetsWorkersStarted() {
-	regenerateAssetsRunMu  sync.Mutex
+	regenerateAssetsMu.Lock()
-	regenerateAssetsCancel context.CancelFunc
+	defer regenerateAssetsMu.Unlock()
-	regenerateAssetsFile   string
+
-)
+	if regenerateAssetsWorkersStarted {
+		return
+	}
+
+	regenerateAssetsWorkersStarted = true
+
+	for i := 0; i < regenerateAssetsMaxParallel; i++ {
+		go regenerateAssetsWorker()
+	}
+}
+
+func enqueueRegenerateAssetsJob(job *regenerateAssetsJob) {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	regenerateAssetsJobs[job.File] = job
+	regenerateAssetsQueue = append(regenerateAssetsQueue, job.File)
+}
+
+func nextQueuedRegenerateAssetsJob() *regenerateAssetsJob {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	for len(regenerateAssetsQueue) > 0 {
+		file := regenerateAssetsQueue[0]
+		regenerateAssetsQueue = regenerateAssetsQueue[1:]
+
+		job := regenerateAssetsJobs[file]
+		if job == nil {
+			continue
+		}
+		if job.State != "queued" {
+			continue
+		}
+
+		job.State = "running"
+		job.StartedAt = time.Now()
+		return job
+	}
+
+	return nil
+}
+
+func finishRegenerateAssetsJob(file string, state string, errMsg string) {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	job := regenerateAssetsJobs[file]
+	if job == nil {
+		return
+	}
+
+	job.State = state
+	job.Error = strings.TrimSpace(errMsg)
+	job.EndedAt = time.Now()
+}
+
+func removeRegenerateAssetsJobLater(file string, after time.Duration) {
+	time.AfterFunc(after, func() {
+		regenerateAssetsMu.Lock()
+		defer regenerateAssetsMu.Unlock()
+
+		delete(regenerateAssetsJobs, file)
+	})
+}
+
+func getRegenerateAssetsJobsSnapshot() []map[string]any {
+	regenerateAssetsMu.Lock()
+	defer regenerateAssetsMu.Unlock()
+
+	out := make([]map[string]any, 0, len(regenerateAssetsJobs))
+	for _, job := range regenerateAssetsJobs {
+		out = append(out, map[string]any{
+			"file":       job.File,
+			"assetId":    job.AssetID,
+			"state":      job.State,
+			"error":      job.Error,
+			"enqueuedAt": job.EnqueuedAt.UnixMilli(),
+			"startedAt": func() int64 {
+				if job.StartedAt.IsZero() {
+					return 0
+				}
+				return job.StartedAt.UnixMilli()
+			}(),
+			"endedAt": func() int64 {
+				if job.EndedAt.IsZero() {
+					return 0
+				}
+				return job.EndedAt.UnixMilli()
+			}(),
+		})
+	}
+
+	return out
+}
+
+func regenerateAssetsWorker() {
+	for {
+		job := nextQueuedRegenerateAssetsJob()
+		if job == nil {
+			time.Sleep(250 * time.Millisecond)
+			continue
+		}
+
+		runRegenerateAssetsJob(job)
+	}
+}
+
+func runRegenerateAssetsJob(job *regenerateAssetsJob) {
+	file := job.File
+	videoPath := job.VideoPath
+	id := job.AssetID
+	ctx := job.Ctx
+
+	setRegenerateAssetsTaskRunning(file, file)
+
+	cancelDeferredEnrichForFile(file)
+
+	select {
+	case <-ctx.Done():
+		finishRegenerateAssetsJob(file, "cancelled", "Abgebrochen")
+		setRegenerateAssetsTaskError(file, "Abgebrochen")
+
+		publishFinishedPostworkPhase(file, id, "postwork", "meta", "missing", "")
+		publishFinishedPostworkPhase(file, id, "postwork", "teaser", "missing", "")
+		publishFinishedPostworkPhase(file, id, "postwork", "thumb", "missing", "")
+		publishFinishedPostworkPhase(file, id, "postwork", "sprites", "missing", "")
+		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
+
+		removeRegenerateAssetsJobLater(file, 2*time.Second)
+		return
+	default:
+	}
+
+	publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
+
+	publishFinishedPostworkPhase(file, id, "postwork", "meta", "running", "Meta")
+	publishFinishedPostworkPhase(file, id, "postwork", "teaser", "running", "Teaser")
+	publishFinishedPostworkPhase(file, id, "postwork", "thumb", "running", "Vorschaubild")
+	publishFinishedPostworkPhase(file, id, "postwork", "sprites", "running", "Sprites")
+
+	if id != "" {
+		if assetDir, _, _, _, metaPath, err := assetPathsForID(id); err == nil {
+			_ = os.Remove(filepath.Join(assetDir, "preview.jpg"))
+			_ = os.Remove(filepath.Join(assetDir, "preview.mp4"))
+			_ = os.Remove(filepath.Join(assetDir, "preview-sprite.jpg"))
+			_ = os.Remove(metaPath)
+		}
+	}
+
+	assetWatchDone := make(chan struct{})
+
+	go func(ctx context.Context, file string, id string) {
+		ticker := time.NewTicker(300 * time.Millisecond)
+		defer ticker.Stop()
+
+		sentMetaDone := false
+		sentTeaserDone := false
+		sentThumbDone := false
+		sentSpritesDone := false
+
+		checkAndEmit := func() {
+			truth := finishedPhaseTruthForID(id)
+
+			if truth.MetaReady && !sentMetaDone {
+				sentMetaDone = true
+				publishFinishedPostworkPhase(file, id, "postwork", "meta", "done", "Meta")
+			}
+			if truth.TeaserReady && !sentTeaserDone {
+				sentTeaserDone = true
+				publishFinishedPostworkPhase(file, id, "postwork", "teaser", "done", "Teaser")
+			}
+			if truth.ThumbReady && !sentThumbDone {
+				sentThumbDone = true
+				publishFinishedPostworkPhase(file, id, "postwork", "thumb", "done", "Vorschaubild")
+			}
+			if truth.SpritesReady && !sentSpritesDone {
+				sentSpritesDone = true
+				publishFinishedPostworkPhase(file, id, "postwork", "sprites", "done", "Sprites")
+			}
+		}
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-assetWatchDone:
+				checkAndEmit()
+				return
+			case <-ticker.C:
+				checkAndEmit()
+			}
+		}
+	}(ctx, file, id)
+
+	_, errAssets := ensureAssetsForVideoWithProgressCtx(ctx, videoPath, "", nil)
+	close(assetWatchDone)
+
+	if errors.Is(errAssets, context.Canceled) || ctx.Err() == context.Canceled {
+		finishRegenerateAssetsJob(file, "cancelled", "Abgebrochen")
+		setRegenerateAssetsTaskError(file, "Abgebrochen")
+
+		publishFinishedPostworkPhase(file, id, "postwork", "meta", "missing", "")
+		publishFinishedPostworkPhase(file, id, "postwork", "teaser", "missing", "")
+		publishFinishedPostworkPhase(file, id, "postwork", "thumb", "missing", "")
+		publishFinishedPostworkPhase(file, id, "postwork", "sprites", "missing", "")
+		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
+
+		removeRegenerateAssetsJobLater(file, 2*time.Second)
+		return
+	}
+
+	if errAssets == nil {
+		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "running", "KI-Analyse")
+	}
+
+	errAI := ensureDeferredAssetsAndAI(ctx, videoPath, "")
+
+	if errors.Is(errAI, context.Canceled) || ctx.Err() == context.Canceled {
+		finishRegenerateAssetsJob(file, "cancelled", "Abgebrochen")
+		setRegenerateAssetsTaskError(file, "Abgebrochen")
+		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
+
+		removeRegenerateAssetsJobLater(file, 2*time.Second)
+		return
+	}
+
+	if errAssets == nil && errAI == nil {
+		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "done", "KI-Analyse")
+	}
+
+	if errAssets != nil || errAI != nil {
+		errMsg := ""
+		if errAssets != nil {
+			errMsg = errAssets.Error()
+		} else {
+			errMsg = errAI.Error()
+		}
+
+		finishRegenerateAssetsJob(file, "error", errMsg)
+		setRegenerateAssetsTaskError(file, errMsg)
+
+		errEv := finishedPostworkEvent{
+			Type:    "finished_postwork",
+			File:    file,
+			AssetID: id,
+			Queue:   "enrich",
+			State:   "error",
+			Phase:   "assets",
+			Label:   "Fehler",
+			TS:      time.Now().UnixMilli(),
+		}
+		if b, err := json.Marshal(errEv); err == nil {
+			publishSSE("finishedPostwork", b)
+		}
+
+		removeRegenerateAssetsJobLater(file, 5*time.Second)
+		return
+	}
+
+	finishRegenerateAssetsJob(file, "done", "")
+	setRegenerateAssetsTaskDone(file, "Fertig")
+	removeRegenerateAssetsJobLater(file, 3*time.Second)
+}
 
 func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost && r.Method != http.MethodDelete {
@@ -54,42 +342,28 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if r.Method == http.MethodDelete {
-		regenerateAssetsRunMu.Lock()
+		var req regenerateAssetsRequest
-		cancel := regenerateAssetsCancel
+		_ = json.NewDecoder(r.Body).Decode(&req)
-		file := regenerateAssetsFile
-		regenerateAssetsCancel = nil
-		regenerateAssetsFile = ""
-		regenerateAssetsRunMu.Unlock()
 
-		if cancel != nil {
+		file := strings.TrimSpace(req.File)
-			cancel()
+		if file == "" {
+			http.Error(w, "missing file", http.StatusBadRequest)
+			return
 		}
 
-		if strings.TrimSpace(file) != "" {
+		regenerateAssetsMu.Lock()
-			setRegenerateAssetsTaskError(file, "Abgebrochen")
+		job := regenerateAssetsJobs[file]
+		regenerateAssetsMu.Unlock()
 
-			id := strings.TrimSpace(assetIDFromVideoPath(file))
+		if job != nil && job.Cancel != nil {
-			if id == "" {
+			job.Cancel()
-				id = stripHotPrefix(strings.TrimSuffix(filepath.Base(file), filepath.Ext(file)))
-			}
-
-			publishFinishedPostworkPhase(file, id, "postwork", "meta", "missing", "")
-			publishFinishedPostworkPhase(file, id, "postwork", "teaser", "missing", "")
-			publishFinishedPostworkPhase(file, id, "postwork", "thumb", "missing", "")
-			publishFinishedPostworkPhase(file, id, "postwork", "sprites", "missing", "")
-			publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
-
-			time.AfterFunc(2*time.Second, func() {
-				clearRegenerateAssetsTaskState()
-			})
-		} else {
-			clearRegenerateAssetsTaskState()
 		}
 
 		w.Header().Set("Content-Type", "application/json")
 		_ = json.NewEncoder(w).Encode(map[string]any{
 			"ok":        true,
 			"cancelled": true,
+			"file":      file,
 		})
 		return
 	}
@@ -131,184 +405,51 @@ func handleRegenerateAssets(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	ensureRegenerateAssetsWorkersStarted()
+
+	regenerateAssetsMu.Lock()
+	if existing := regenerateAssetsJobs[file]; existing != nil {
+		regenerateAssetsMu.Unlock()
+
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"ok":    true,
+			"file":  file,
+			"state": existing.State,
+		})
+		return
+	}
+	regenerateAssetsMu.Unlock()
+
 	runCtx, runCancel := context.WithCancel(context.Background())
 
-	regenerateAssetsRunMu.Lock()
+	id := assetIDFromVideoPath(videoPath)
-	if regenerateAssetsCancel != nil {
+	if strings.TrimSpace(id) == "" {
-		regenerateAssetsCancel()
+		id = stripHotPrefix(strings.TrimSuffix(filepath.Base(file), filepath.Ext(file)))
 	}
-	regenerateAssetsCancel = runCancel
-	regenerateAssetsFile = file
-	regenerateAssetsRunMu.Unlock()
 
-	setRegenerateAssetsTaskRunning(file, file)
+	job := &regenerateAssetsJob{
+		File:       file,
+		VideoPath:  videoPath,
+		AssetID:    id,
+		Ctx:        runCtx,
+		Cancel:     runCancel,
+		State:      "queued",
+		EnqueuedAt: time.Now(),
+	}
 
-	go func(ctx context.Context, videoPath string, file string) {
+	enqueueRegenerateAssetsJob(job)
-		defer func() {
-			regenerateAssetsRunMu.Lock()
-			if regenerateAssetsFile == file {
-				regenerateAssetsCancel = nil
-				regenerateAssetsFile = ""
-			}
-			regenerateAssetsRunMu.Unlock()
-		}()
 
-		id := assetIDFromVideoPath(videoPath)
+	publishFinishedPostworkPhase(file, id, "postwork", "meta", "queued", "Meta")
-		if strings.TrimSpace(id) == "" {
+	publishFinishedPostworkPhase(file, id, "postwork", "teaser", "queued", "Teaser")
-			id = stripHotPrefix(strings.TrimSuffix(filepath.Base(file), filepath.Ext(file)))
+	publishFinishedPostworkPhase(file, id, "postwork", "thumb", "queued", "Vorschaubild")
-		}
+	publishFinishedPostworkPhase(file, id, "postwork", "sprites", "queued", "Sprites")
-
+	publishFinishedPostworkPhase(file, id, "enrich", "analyze", "queued", "KI-Analyse")
-		cancelDeferredEnrichForFile(file)
-
-		select {
-		case <-ctx.Done():
-			setRegenerateAssetsTaskError(file, "Abgebrochen")
-			time.AfterFunc(2*time.Second, func() {
-				clearRegenerateAssetsTaskState()
-			})
-			return
-		default:
-		}
-
-		publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
-
-		publishFinishedPostworkPhase(file, id, "postwork", "meta", "running", "Meta")
-		publishFinishedPostworkPhase(file, id, "postwork", "teaser", "running", "Teaser")
-		publishFinishedPostworkPhase(file, id, "postwork", "thumb", "running", "Vorschaubild")
-		publishFinishedPostworkPhase(file, id, "postwork", "sprites", "running", "Sprites")
-
-		if id != "" {
-			if assetDir, _, _, _, metaPath, err := assetPathsForID(id); err == nil {
-				_ = os.Remove(filepath.Join(assetDir, "preview.jpg"))
-				_ = os.Remove(filepath.Join(assetDir, "preview.mp4"))
-				_ = os.Remove(filepath.Join(assetDir, "preview-sprite.jpg"))
-				_ = os.Remove(metaPath)
-			}
-		}
-
-		assetWatchDone := make(chan struct{})
-
-		go func(ctx context.Context, file string, id string) {
-			ticker := time.NewTicker(300 * time.Millisecond)
-			defer ticker.Stop()
-
-			sentMetaDone := false
-			sentTeaserDone := false
-			sentThumbDone := false
-			sentSpritesDone := false
-
-			checkAndEmit := func() {
-				truth := finishedPhaseTruthForID(id)
-
-				if truth.MetaReady && !sentMetaDone {
-					sentMetaDone = true
-					publishFinishedPostworkPhase(file, id, "postwork", "meta", "done", "Meta")
-				}
-				if truth.TeaserReady && !sentTeaserDone {
-					sentTeaserDone = true
-					publishFinishedPostworkPhase(file, id, "postwork", "teaser", "done", "Teaser")
-				}
-				if truth.ThumbReady && !sentThumbDone {
-					sentThumbDone = true
-					publishFinishedPostworkPhase(file, id, "postwork", "thumb", "done", "Vorschaubild")
-				}
-				if truth.SpritesReady && !sentSpritesDone {
-					sentSpritesDone = true
-					publishFinishedPostworkPhase(file, id, "postwork", "sprites", "done", "Sprites")
-				}
-			}
-
-			for {
-				select {
-				case <-ctx.Done():
-					return
-				case <-assetWatchDone:
-					checkAndEmit()
-					return
-				case <-ticker.C:
-					checkAndEmit()
-				}
-			}
-		}(ctx, file, id)
-
-		_, errAssets := ensureAssetsForVideoWithProgressCtx(ctx, videoPath, "", nil)
-		close(assetWatchDone)
-
-		if errors.Is(errAssets, context.Canceled) || ctx.Err() == context.Canceled {
-			setRegenerateAssetsTaskError(file, "Abgebrochen")
-
-			publishFinishedPostworkPhase(file, id, "postwork", "meta", "missing", "")
-			publishFinishedPostworkPhase(file, id, "postwork", "teaser", "missing", "")
-			publishFinishedPostworkPhase(file, id, "postwork", "thumb", "missing", "")
-			publishFinishedPostworkPhase(file, id, "postwork", "sprites", "missing", "")
-			publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
-
-			time.AfterFunc(2*time.Second, func() {
-				clearRegenerateAssetsTaskState()
-			})
-			return
-		}
-
-		if errAssets == nil {
-			publishFinishedPostworkPhase(file, id, "enrich", "analyze", "running", "KI-Analyse")
-		}
-
-		errAI := ensureDeferredAssetsAndAI(ctx, videoPath, "")
-
-		if errors.Is(errAI, context.Canceled) || ctx.Err() == context.Canceled {
-			setRegenerateAssetsTaskError(file, "Abgebrochen")
-			publishFinishedPostworkPhase(file, id, "enrich", "analyze", "missing", "")
-
-			time.AfterFunc(2*time.Second, func() {
-				clearRegenerateAssetsTaskState()
-			})
-			return
-		}
-
-		if errAssets == nil && errAI == nil {
-			publishFinishedPostworkPhase(file, id, "enrich", "analyze", "done", "KI-Analyse")
-		}
-
-		if errAssets != nil || errAI != nil {
-			errMsg := ""
-			if errAssets != nil {
-				errMsg = errAssets.Error()
-			} else {
-				errMsg = errAI.Error()
-			}
-
-			setRegenerateAssetsTaskError(file, errMsg)
-
-			errEv := finishedPostworkEvent{
-				Type:    "finished_postwork",
-				File:    file,
-				AssetID: id,
-				Queue:   "enrich",
-				State:   "error",
-				Phase:   "assets",
-				Label:   "Fehler",
-				TS:      time.Now().UnixMilli(),
-			}
-			if b, err := json.Marshal(errEv); err == nil {
-				publishSSE("finishedPostwork", b)
-			}
-
-			time.AfterFunc(5*time.Second, func() {
-				clearRegenerateAssetsTaskState()
-			})
-			return
-		}
-
-		setRegenerateAssetsTaskDone(file, "Fertig")
-
-		time.AfterFunc(3*time.Second, func() {
-			clearRegenerateAssetsTaskState()
-		})
-	}(runCtx, videoPath, file)
 
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(map[string]any{
-		"ok":   true,
+		"ok":    true,
-		"file": file,
+		"file":  file,
+		"state": "queued",
 	})
 }

backend/tasks_status.go

@@ -28,10 +28,11 @@ type RegenerateAssetsTaskState struct {
 }
 
 type TasksStatusResponse struct {
-	GenerateAssets   AssetsTaskState           `json:"generateAssets"`
+	GenerateAssets       AssetsTaskState           `json:"generateAssets"`
-	RegenerateAssets RegenerateAssetsTaskState `json:"regenerateAssets"`
+	RegenerateAssets     RegenerateAssetsTaskState `json:"regenerateAssets"`
-	Cleanup          CleanupTaskState          `json:"cleanup"`
+	RegenerateAssetsJobs []map[string]any          `json:"regenerateAssetsJobs"`
-	AnyRunning       bool                      `json:"anyRunning"`
+	Cleanup              CleanupTaskState          `json:"cleanup"`
+	AnyRunning           bool                      `json:"anyRunning"`
 }
 
 var (
@@ -47,6 +48,17 @@ func cleanupNowISO() *string {
 	return &s
 }
 
+func anyToString(v any) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	case []byte:
+		return string(x)
+	default:
+		return ""
+	}
+}
+
 func snapshotRegenerateAssetsTaskState() RegenerateAssetsTaskState {
 	regenerateAssetsTaskMu.Lock()
 	st := regenerateAssetsTaskState
@@ -175,13 +187,26 @@ func tasksStatusHandler(w http.ResponseWriter, r *http.Request) {
 
 	assets := getGenerateAssetsTaskStatus()
 	regenerate := snapshotRegenerateAssetsTaskState()
+	regenerateJobs := getRegenerateAssetsJobsSnapshot()
 	cleanup := snapshotCleanupTaskState()
 
+	anyRegenerateRunning := regenerate.Running
+	if !anyRegenerateRunning {
+		for _, job := range regenerateJobs {
+			state := strings.TrimSpace(strings.ToLower(anyToString(job["state"])))
+			if state == "queued" || state == "running" {
+				anyRegenerateRunning = true
+				break
+			}
+		}
+	}
+
 	resp := TasksStatusResponse{
-		GenerateAssets:   assets,
+		GenerateAssets:       assets,
-		RegenerateAssets: regenerate,
+		RegenerateAssets:     regenerate,
-		Cleanup:          cleanup,
+		RegenerateAssetsJobs: regenerateJobs,
-		AnyRunning:       assets.Running || regenerate.Running || cleanup.Running,
+		Cleanup:              cleanup,
+		AnyRunning:           assets.Running || anyRegenerateRunning || cleanup.Running,
 	}
 
 	w.Header().Set("Content-Type", "application/json")

frontend/src/components/ui/FinishedDownloads.tsx

@@ -1477,89 +1477,90 @@ export default function FinishedDownloads({
         const data = await res.json().catch(() => null)
         if (!alive || !data) return
 
-        const regen = data?.regenerateAssets
+        const jobs = Array.isArray(data?.regenerateAssetsJobs)
-        const file = String(regen?.file ?? '').trim()
+          ? data.regenerateAssetsJobs
+          : []
 
-        if (!file) return
+        if (jobs.length > 0) {
+          setPostworkByFile((prev) => {
+            const next = { ...prev }
 
-        if (regen?.running) {
+            for (const item of jobs) {
-          setPostworkByFile((prev) => ({
+              const file = String(item?.file ?? '').trim()
-            ...prev,
+              if (!file) continue
-            [file]: [
-              {
-                file,
-                assetId: fileStemFromOutput(file),
-                queue: 'enrich',
-                state: 'running',
-                phase: 'assets',
-                label: 'Vorschaubild',
-                ts: Date.now(),
-              },
-            ],
-          }))
-          return
-        }
 
-        if (regen?.error) {
+              const rawState = String(item?.state ?? '').trim().toLowerCase()
-          setPostworkByFile((prev) => ({
+              const assetId =
-            ...prev,
+                String(item?.assetId ?? '').trim() || fileStemFromOutput(file)
-            [file]: [
-              {
-                file,
-                assetId: fileStemFromOutput(file),
-                queue: 'enrich',
-                state: 'error',
-                phase: 'assets',
-                label: 'Fehler',
-                ts: Date.now(),
-              },
-            ],
-          }))
-          return
-        }
 
-        const bulk = data?.generateAssets
+              const state: FinishedPostworkState =
-        const bulkFile = String(bulk?.currentFile ?? '').trim()
+                rawState === 'queued' ||
-        const bulkQueue =
+                rawState === 'running' ||
-          String(bulk?.currentQueue ?? '').trim().toLowerCase() === 'enrich'
+                rawState === 'done' ||
-            ? 'enrich'
+                rawState === 'error' ||
-            : 'postwork'
+                rawState === 'missing'
-        const bulkPhase = String(bulk?.currentPhase ?? '').trim().toLowerCase()
+                  ? rawState
-        const bulkLabel = String(bulk?.currentLabel ?? '').trim()
+                  : rawState === 'cancelled'
+                    ? 'missing'
+                    : 'missing'
 
-        if (bulk?.running && bulkFile && bulkPhase) {
+              // Nur aktive / noch relevante Jobs beim Initial-Load wiederherstellen.
-          setPostworkByFile((prev) => ({
+              // "done" kommt danach ohnehin sauber über Meta/SSE rein.
-            ...prev,
+              if (state !== 'queued' && state !== 'running' && state !== 'error') {
-            [bulkFile]: [
+                continue
-              {
+              }
-                file: bulkFile,
-                assetId: fileStemFromOutput(bulkFile),
-                queue: bulkQueue,
-                state: 'running',
-                phase: bulkPhase,
-                label: bulkLabel || undefined,
-                ts: Date.now(),
-              },
-            ],
-          }))
-        }
 
-        // optional: wenn du "done" kurz nach Reload noch sichtbar haben willst
+              next[file] = [
-        if (regen?.text) {
+                {
-          setPostworkByFile((prev) => ({
+                  file,
-            ...prev,
+                  assetId,
-            [file]: [
+                  queue: 'postwork',
-              {
+                  state,
-                file,
+                  phase: 'meta',
-                assetId: fileStemFromOutput(file),
+                  label: 'Meta',
-                queue: 'enrich',
+                  ts: Date.now(),
-                state: 'done',
+                },
-                phase: 'assets',
+                {
-                label: 'Fertig',
+                  file,
-                ts: Date.now(),
+                  assetId,
-              },
+                  queue: 'postwork',
-            ],
+                  state,
-          }))
+                  phase: 'teaser',
+                  label: 'Teaser',
+                  ts: Date.now(),
+                },
+                {
+                  file,
+                  assetId,
+                  queue: 'postwork',
+                  state,
+                  phase: 'thumb',
+                  label: 'Vorschaubild',
+                  ts: Date.now(),
+                },
+                {
+                  file,
+                  assetId,
+                  queue: 'postwork',
+                  state,
+                  phase: 'sprites',
+                  label: 'Sprites',
+                  ts: Date.now(),
+                },
+                {
+                  file,
+                  assetId,
+                  queue: 'enrich',
+                  state,
+                  phase: 'analyze',
+                  label: 'KI-Analyse',
+                  ts: Date.now(),
+                },
+              ]
+            }
+
+            return next
+          })
         }
       } catch {
         // ignore
@@ -2820,13 +2821,49 @@ export default function FinishedDownloads({
     setPostworkByFile((prev) => ({
       ...prev,
       [cleanFile]: [
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'meta',
+          label: 'Meta',
+          ts: Date.now(),
+        },
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'teaser',
+          label: 'Teaser',
+          ts: Date.now(),
+        },
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'thumb',
+          label: 'Vorschaubild',
+          ts: Date.now(),
+        },
+        {
+          file: cleanFile,
+          assetId: fileStemFromOutput(cleanFile),
+          queue: 'postwork',
+          state: 'queued',
+          phase: 'sprites',
+          label: 'Sprites',
+          ts: Date.now(),
+        },
         {
           file: cleanFile,
           assetId: fileStemFromOutput(cleanFile),
           queue: 'enrich',
-          state: 'running',
+          state: 'queued',
-          phase: 'assets',
+          phase: 'analyze',
-          label: 'Wird verarbeitet…',
+          label: 'KI-Analyse',
           ts: Date.now(),
         },
       ],

frontend/src/components/ui/FinishedVideoPreview.tsx

@@ -151,47 +151,10 @@ export default function FinishedVideoPreview({
     return m
   }, [job])
 
-  // ✅ falls job.meta keine previewClips enthält: meta.json nachladen
-  const [fetchedMeta, setFetchedMeta] = useState<any | null>(null)
-
-  // ✅ verhindert mehrfachen fallback-fetch pro Datei in derselben Komponenteninstanz
-  const fetchedMetaFilesRef = useRef<Set<string>>(new Set())  
-
   // ✅ merge statt "meta ?? fetchedMeta"
   // job.meta bleibt Basis, fetchedMeta ergänzt fehlende Felder (z.B. previewClips)
-  const metaForPreview = useMemo(() => {
+  const metaForPreview = meta
-    if (!meta && !fetchedMeta) return null
+  
-    if (!meta) return fetchedMeta
-    if (!fetchedMeta) return meta
-    return { ...meta, ...fetchedMeta }
-  }, [meta, fetchedMeta])
-
-  // ✅ stabiler Guard für den fallback-fetch (berücksichtigt auch bereits geholtes fetchedMeta)
-  const hasPreviewClipsInAnyMeta = useMemo(() => {
-    let pcs: any = (metaForPreview as any)?.previewClips
-
-    if (typeof pcs === 'string') {
-      const s = pcs.trim()
-      if (s.length > 0) {
-        try {
-          const parsed = JSON.parse(s)
-          if (Array.isArray(parsed) && parsed.length > 0) return true
-          // falls string vorhanden aber nicht parsebar, behandeln wir ihn trotzdem als "vorhanden"
-          return true
-        } catch {
-          return true
-        }
-      }
-    }
-
-    if (Array.isArray(pcs) && pcs.length > 0) return true
-
-    const nested = (metaForPreview as any)?.preview?.clips
-    if (Array.isArray(nested) && nested.length > 0) return true
-
-    return false
-  }, [metaForPreview])
-
   const [progressMountTick, setProgressMountTick] = useState(0)
 
   // previewClips mapping: preview.mp4 ist Concatenation von Segmenten
@@ -587,7 +550,6 @@ export default function FinishedVideoPreview({
   useEffect(() => {
     setTeaserReady(false)
     setTeaserOk(true)
-    setFetchedMeta(null) // ✅ neue Datei/Asset -> alten fallback-meta cache in state verwerfen
 
     // ✅ neue Datei/Asset -> Callback-Dedupe zurücksetzen
     emittedDurationRef.current = ''
@@ -783,63 +745,6 @@ export default function FinishedVideoPreview({
     if (did) setMetaLoaded(true)
   }, [file, job, onDuration, onResolution, hasDuration, hasResolution, effectiveDurationSec, effectiveW, effectiveH])
 
-  
-  // ✅ meta fallback fetch: nur wenn previewClips fehlen (für teaser-sprünge)
-  //    und pro Datei in dieser Komponenteninstanz nur 1x
-  useEffect(() => {
-    if (!previewId) return
-    if (!file) return
-    if (!animated || animatedMode !== 'teaser') return
-    if (!shouldPreloadAnimatedAssets) return
-
-    // ✅ wenn wir schon previewClips aus job.meta ODER fetchedMeta haben -> kein Request
-    if (hasPreviewClipsInAnyMeta) return
-
-    // ✅ gleicher file-Request in dieser Instanz schon gemacht -> nicht nochmal feuern
-    if (fetchedMetaFilesRef.current.has(file)) return
-
-    let aborted = false
-    const ctrl = new AbortController()
-
-    const tryFetch = async (url: string) => {
-      try {
-        const res = await fetch(url, {
-          signal: ctrl.signal,
-          cache: 'no-store',
-          credentials: 'include',
-        })
-        if (!res.ok) return null
-        return await res.json()
-      } catch {
-        return null
-      }
-    }
-
-    ;(async () => {
-      const byFile = await tryFetch(`/api/record/done/meta?file=${encodeURIComponent(file)}`)
-      if (aborted) return
-
-      // ✅ als "versucht" markieren (auch wenn null), damit nearView/inView/hover nicht spammt
-      fetchedMetaFilesRef.current.add(file)
-
-      if (byFile) {
-        setFetchedMeta(byFile)
-      }
-    })()
-
-    return () => {
-      aborted = true
-      ctrl.abort()
-    }
-  }, [
-    previewId,
-    file,
-    animated,
-    animatedMode,
-    shouldPreloadAnimatedAssets,
-    hasPreviewClipsInAnyMeta,
-  ])
-
   // ✅ Fallback: nur wenn wir wirklich noch nichts haben, über loadedmetadata nachladen
   const handleLoadedMetadata = (e: SyntheticEvent<HTMLVideoElement>) => {
     setMetaLoaded(true)

frontend/src/components/ui/VideoSplitModal.tsx

@@ -942,10 +942,7 @@ export default function VideoSplitModal({
         const clipMap = extractPreviewClipMap(data)
 
         const metaDuration = extractMetaDuration(data)
-        const resolvedDuration =
+        const resolvedDuration = metaDuration > 0 ? metaDuration : 0
-          metaDuration > 0
-            ? metaDuration
-            : duration
 
         const shouldMapPreviewAi =
           Boolean(shouldMapAiPreviewTimes(ai, clipMap, resolvedDuration) && clipMap)
@@ -997,7 +994,7 @@ export default function VideoSplitModal({
     return () => {
       cancelled = true
     }
-  }, [open, job?.id, job?.output, duration])
+  }, [open, job?.id, job?.output])
 
   const effectiveDuration = mediaDuration > 0 ? mediaDuration : duration