@rslsp1/fa-app-tools 5.1.0 → 7.0.1

package/dist/{chunk-3MUI4ZV7.mjs → chunk-B2YV4TNI.mjs}

@@ -4,15 +4,307 @@ import {
   preferredVersionId,
   resolvePreferredHead
 } from "./chunk-FUY2OCVC.mjs";
-import {
-  SPEICHERBARE_BILDTYPEN,
-  bildEndungFuer,
-  hfLoadImageAsBase64,
-  hfUploadImage,
-  loadHFState,
-  loadPendingEvents,
-  writeHFEvent
-} from "./chunk-NBUS7AWR.mjs";
+
+// src/lib/hfEventTypes.ts
+var HF_BASE = "https://huggingface.co";
+var HF_REPO = "RolandSch/fa-app-state";
+var CURRENT_EVENT_VERSION = { major: 1, minor: 0 };
+var SPEICHERBARE_BILDTYPEN = ["image/png", "image/jpeg", "image/webp"];
+function bildEndungFuer(mimeType) {
+  if (mimeType === "image/png") return "png";
+  if (mimeType === "image/webp") return "webp";
+  return "jpg";
+}
+
+// src/lib/hfEventLog.ts
+function treeUrl(namespace, subdir = "") {
+  const parts = [namespace.replace(/\/$/, ""), subdir].filter(Boolean).join("/");
+  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/main${parts ? "/" + parts : ""}`;
+}
+var DROSSEL_VERSUCHE = 4;
+var DROSSEL_BASIS_MS = 400;
+var schlafen = (ms) => new Promise((r) => setTimeout(r, ms));
+var HF_LESE_ZEITLIMIT_MS = 2e4;
+async function holeMitZeitlimit(url, init) {
+  const abbruch = new AbortController();
+  const timer = setTimeout(() => abbruch.abort(), HF_LESE_ZEITLIMIT_MS);
+  try {
+    return await fetch(url, { ...init, signal: abbruch.signal });
+  } catch (error) {
+    if (abbruch.signal.aborted) {
+      throw new Error(`HF-Anfrage ohne Antwort nach ${HF_LESE_ZEITLIMIT_MS}ms abgebrochen: ${url}`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function mitGeduld(anfrage) {
+  let letzte = null;
+  for (let versuch = 0; versuch < DROSSEL_VERSUCHE; versuch += 1) {
+    const res = await anfrage();
+    if (res.status !== 429 && res.status < 500) return res;
+    letzte = res;
+    if (versuch === DROSSEL_VERSUCHE - 1) break;
+    const angesagt = Number(res.headers.get("retry-after"));
+    const warten2 = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
+    await schlafen(warten2);
+  }
+  return letzte;
+}
+async function hfListDir(namespace, subdir, token) {
+  const res = await mitGeduld(() => holeMitZeitlimit(treeUrl(namespace, subdir), {
+    headers: { Authorization: `Bearer ${token}` }
+  }));
+  if (res.status === 404) return [];
+  if (!res.ok) throw new Error(`HF list failed: ${res.status} ${res.statusText}`);
+  return res.json();
+}
+async function hfDownloadJsonByPath(repoPath, token) {
+  const res = await mitGeduld(() => holeMitZeitlimit(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ));
+  if (!res.ok) throw new Error(`HF download failed: ${res.status}`);
+  return res.json();
+}
+async function hfDownloadBinaryByPath(repoPath, token) {
+  const res = await mitGeduld(() => holeMitZeitlimit(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ));
+  if (!res.ok) throw new Error(`HF download binary failed: ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+function toBase64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  bytes.forEach((b) => binary += String.fromCharCode(b));
+  return btoa(binary);
+}
+async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`) {
+  const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: [
+      JSON.stringify({ key: "header", value: { summary, description: "" } }),
+      JSON.stringify({ key: "file", value: { path: repoPath, encoding: "base64", content: toBase64(content) } })
+    ].join("\n")
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    throw new Error(`HF upload failed: ${res.status} \u2014 ${err.slice(0, 200)}`);
+  }
+}
+async function hfBatchArchive(moves, token, summary) {
+  const lines = [
+    JSON.stringify({ key: "header", value: { summary, description: "" } }),
+    ...moves.flatMap(({ from, to, content }) => [
+      JSON.stringify({ key: "file", value: { path: to, encoding: "base64", content: toBase64(content) } }),
+      JSON.stringify({ key: "deletedFile", value: { path: from } })
+    ])
+  ];
+  const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: lines.join("\n")
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    throw new Error(`HF batch archive failed: ${res.status} \u2014 ${err.slice(0, 200)}`);
+  }
+}
+function tsFromEventPath(repoPath) {
+  const filename = repoPath.split("/").pop() || "";
+  const base = filename.replace(/_[^_]+\.json$/, "");
+  const iso = base.replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
+  const ts = Date.parse(iso);
+  return isNaN(ts) ? 0 : ts;
+}
+var EVENTDOWNLOAD_PARALLELITAET = 3;
+async function mitBegrenzterParallelitaet(count, limit, task) {
+  let cursor = 0;
+  let ersterFehler;
+  let fehlerAufgetreten = false;
+  const worker = async () => {
+    while (cursor < count) {
+      const index = cursor++;
+      try {
+        await task(index);
+      } catch (error) {
+        if (!fehlerAufgetreten) {
+          fehlerAufgetreten = true;
+          ersterFehler = error;
+        }
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, count) }, worker));
+  if (fehlerAufgetreten) throw ersterFehler;
+}
+async function loadPendingEvents(namespace, token, sinceTs, knownPaths) {
+  const files = await hfListDir(namespace, "events", token);
+  const pending = files.filter((f) => f.type === "file" && tsFromEventPath(f.path) > sinceTs && !knownPaths?.has(f.path)).sort((a, b) => a.path.localeCompare(b.path));
+  if (!pending.length) return [];
+  const raw = new Array(pending.length);
+  await mitBegrenzterParallelitaet(pending.length, EVENTDOWNLOAD_PARALLELITAET, async (index) => {
+    raw[index] = await hfDownloadJsonByPath(pending[index].path, token);
+  });
+  for (const f of pending) knownPaths?.add(f.path);
+  return raw.flatMap((e) => Array.isArray(e) ? e : [e]);
+}
+var SESSION_CLIENT_ID = `client-${crypto.randomUUID().slice(0, 8)}`;
+function getSessionClientId() {
+  return SESSION_CLIENT_ID;
+}
+function tsToFilename(ts) {
+  return new Date(ts).toISOString().replace(/:/g, "-").replace(".", "-");
+}
+var writeSeq = 0;
+var lastOrderedTs = 0;
+async function writeHFEvent(namespace, token, type, payload, prevTs, options) {
+  const wallTs = Date.now();
+  const ts = options?.ordered ? Math.max(wallTs, lastOrderedTs) : wallTs;
+  if (options?.ordered) lastOrderedTs = ts;
+  const uuid = crypto.randomUUID().slice(0, 8);
+  const event = {
+    v: CURRENT_EVENT_VERSION,
+    type,
+    ts,
+    prevTs,
+    clientId: SESSION_CLIENT_ID,
+    payload
+  };
+  const suffix = options?.ordered ? `${String(++writeSeq % 1e6).padStart(6, "0")}${uuid}` : uuid;
+  const filename = `${tsToFilename(ts)}_${suffix}.json`;
+  const repoPath = `${namespace}events/${filename}`;
+  await hfUploadSmallFile(repoPath, JSON.stringify(event, null, 2), token, `Event: ${type}`);
+  return event;
+}
+
+// src/lib/hfStateService.ts
+import JSZip from "jszip";
+import { uploadFile } from "@huggingface/hub";
+var HF_TOKEN_KEY = "hf-token";
+function getHFToken() {
+  try {
+    return localStorage.getItem(HF_TOKEN_KEY);
+  } catch {
+    return null;
+  }
+}
+function setHFToken(token) {
+  try {
+    localStorage.setItem(HF_TOKEN_KEY, token);
+  } catch {
+  }
+}
+async function loadHFState(namespace, token) {
+  const files = await hfListDir(namespace, "", token);
+  const stateFiles = files.filter((f) => f.type === "file" && /^state-[\dT\-]+Z\.zip$/.test(f.path.split("/").pop() || "")).sort((a, b) => b.path.localeCompare(a.path));
+  if (!stateFiles.length) return null;
+  const zipBytes = await hfDownloadBinaryByPath(stateFiles[0].path, token);
+  const zip = await JSZip.loadAsync(zipBytes);
+  const [metadataStr, tagsStr, metaStr, openTasksStr] = await Promise.all([
+    zip.file("metadata.json")?.async("string"),
+    zip.file("tags.json")?.async("string"),
+    zip.file("state_meta.json")?.async("string"),
+    zip.file("open_tasks.json")?.async("string")
+    // optional — ältere Snapshots haben es nicht
+  ]);
+  if (!metadataStr || !tagsStr || !metaStr) throw new Error("state.zip: fehlende Pflicht-Dateien");
+  return {
+    metadata: JSON.parse(metadataStr),
+    tags: JSON.parse(tagsStr),
+    meta: JSON.parse(metaStr),
+    openTasks: openTasksStr ? JSON.parse(openTasksStr) : {}
+  };
+}
+async function hfBootstrapFromLegacy(namespace, token, onProgress) {
+  const log = (msg) => {
+    if (onProgress) onProgress(msg);
+  };
+  log("Lese tags.json \u2026");
+  const tags = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/tags.json?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ).then((r) => r.ok ? r.json() : null).catch(() => null);
+  log("Lese metadata.json \u2026");
+  const metadata = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/metadata.json?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ).then((r) => r.ok ? r.json() : []).catch(() => []);
+  const snapshot = {
+    metadata: Array.isArray(metadata) ? metadata : [],
+    tags: tags?.by_category ? tags : { by_category: {}, all: [] },
+    meta: { consolidatedAt: Date.now(), version: 1 }
+  };
+  log(`Erstelle state.zip (${snapshot.metadata.length} Bilder, ${snapshot.tags.all?.length ?? 0} Tags) \u2026`);
+  const zip = new JSZip();
+  zip.file("metadata.json", JSON.stringify(snapshot.metadata, null, 2));
+  zip.file("tags.json", JSON.stringify(snapshot.tags, null, 2));
+  zip.file("state_meta.json", JSON.stringify(snapshot.meta, null, 2));
+  const zipBytes = await zip.generateAsync({ type: "uint8array", compression: "DEFLATE" });
+  const ts = snapshot.meta.consolidatedAt;
+  const stateFilename = `state-${new Date(ts).toISOString().replace(/:/g, "-").replace(".", "-")}.zip`;
+  const repoPath = `${namespace}${stateFilename}`;
+  log("Lade state.zip hoch \u2026");
+  await uploadFile({
+    repo: { type: "dataset", name: HF_REPO },
+    credentials: { accessToken: token },
+    file: { path: repoPath, content: new Blob([zipBytes.buffer], { type: "application/zip" }) },
+    branch: "main",
+    commitTitle: `Bootstrap: initialer State aus Legacy-Daten`
+  });
+  log(`Fertig \u2014 ${stateFilename}`);
+}
+async function hfUploadImage(base64, id, token, mimeType = "image/jpeg") {
+  const ext = bildEndungFuer(mimeType);
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  await uploadFile({
+    repo: { type: "dataset", name: HF_REPO },
+    credentials: { accessToken: token },
+    file: { path: `images/${id}.${ext}`, content: new Blob([bytes], { type: mimeType }) },
+    branch: "main",
+    commitTitle: `Add image ${id}`
+  });
+}
+async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeType, hasThumb) {
+  const fetchBase64 = async (repoPath) => {
+    try {
+      const res = await fetch(
+        `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
+        { headers: { Authorization: `Bearer ${token}` } }
+      );
+      if (!res.ok) {
+        if (on404 && on404()) return "ABORT";
+        return null;
+      }
+      const blob = await res.blob();
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result.split(",")[1]);
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+      });
+    } catch {
+      return null;
+    }
+  };
+  if (filename) {
+    if (hasThumb) {
+      const thumb = await fetchBase64(`thumbs/${filename}`);
+      if (thumb && thumb !== "ABORT") return thumb;
+    }
+    const result2 = await fetchBase64(`images/${filename}`);
+    return result2 === "ABORT" ? null : result2;
+  }
+  const ext = bildEndungFuer(mimeType);
+  const result = await fetchBase64(`images/${id}.${ext}`);
+  return result === "ABORT" ? null : result;
+}
 
 // src/lib/szenen/viewPort.ts
 function capabilitiesOf(port) {
@@ -5225,6 +5517,133 @@ function findPromptRun(events, runId) {
   return collectPromptRuns(events).find((run) => run.run_id === runId) ?? null;
 }
 
+// src/lib/szenen/seedListe.ts
+var DEFAULT_SEED_VORLAGE = {
+  name: "Default",
+  seeds: "1; 10; 100; 1000",
+  builtin: true
+};
+function parseSeedListe(eingabe) {
+  if (!eingabe) return [];
+  return eingabe.split(/[,;]/).map((teil) => teil.trim()).filter((teil) => teil.length > 0);
+}
+function formatSeedListe(tokens) {
+  return tokens.join("; ");
+}
+var GANZZAHL = /^-?\d+$/;
+function ordneSeedsZu(eingabe, anzahl) {
+  const tokens = Array.isArray(eingabe) ? [...eingabe] : parseSeedListe(eingabe);
+  const eintraege = [];
+  for (let position = 0; position < anzahl; position++) {
+    const roh = tokens[position] ?? null;
+    if (roh === null) {
+      eintraege.push({ position, roh: null, seed: null, ungueltig: false });
+      continue;
+    }
+    const zahl = GANZZAHL.test(roh) ? Number(roh) : Number.NaN;
+    const gueltig = Number.isSafeInteger(zahl);
+    eintraege.push({
+      position,
+      roh,
+      seed: gueltig ? zahl : null,
+      ungueltig: !gueltig
+    });
+  }
+  return {
+    eintraege,
+    ungueltige: eintraege.filter((e) => e.ungueltig),
+    ueberzaehlig: Math.max(0, tokens.length - anzahl)
+  };
+}
+function seedFehlerText(ungueltige) {
+  const teile = ungueltige.map((e) => `Bild ${e.position + 1}: "${e.roh}"`);
+  return `Die Seedliste enth\xE4lt keine ganze Zahl an ${teile.length === 1 ? "Position" : "Positionen"} \u2014 ${teile.join(", ")}. Kein Bild wurde importiert.`;
+}
+function mitDefaultVorlage(custom) {
+  return [DEFAULT_SEED_VORLAGE, ...custom.filter((v) => !v.builtin)];
+}
+
+// src/lib/szenen/zipBilder.ts
+var BILD_ENDUNGEN = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+var UPLOAD_MAX_BYTES = 45 * 1024 * 1024;
+function byteLaenge(base64) {
+  const fuellzeichen = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.floor(base64.length * 3 / 4) - fuellzeichen;
+}
+function angekuendigteGroesse(eintrag) {
+  const roh = eintrag._data?.uncompressedSize;
+  return typeof roh === "number" && Number.isFinite(roh) && roh >= 0 ? roh : null;
+}
+function bildGroesseVerdikt(archiv, pfad, bytes) {
+  if (bytes === null || bytes <= UPLOAD_MAX_BYTES) return null;
+  return `${archiv}: Das Bild ${pfad} ist entpackt ${mb(bytes)} MB gro\xDF \u2014 die Grenze f\xFCr eine einzelne Bilddatei liegt bei ${UPLOAD_MAX_BYTES / 1024 / 1024} MB. Kein Bild wurde importiert.`;
+}
+function mb(bytes) {
+  return (bytes / 1024 / 1024).toFixed(1);
+}
+function istZipDatei(datei) {
+  return /\.zip$/i.test(datei.name);
+}
+function endungVon(pfad) {
+  const punkt = pfad.lastIndexOf(".");
+  return punkt >= 0 ? pfad.slice(punkt + 1).toLowerCase() : "";
+}
+function istImportierbar(pfad, istVerzeichnis) {
+  if (istVerzeichnis) return false;
+  if (pfad.startsWith("__MACOSX/")) return false;
+  const datei = pfad.slice(pfad.lastIndexOf("/") + 1);
+  if (datei.startsWith(".")) return false;
+  return endungVon(datei) in BILD_ENDUNGEN;
+}
+function nachPfad(a, b) {
+  return a.localeCompare(b, "en", { numeric: true, sensitivity: "base" }) || (a < b ? -1 : a > b ? 1 : 0);
+}
+async function leseBilderAusZip(datei) {
+  const name = datei.name ?? "Archiv";
+  if (datei.size > UPLOAD_MAX_BYTES) {
+    throw new Error(
+      `${name} ist ${mb(datei.size)} MB gro\xDF \u2014 die Grenze liegt bei ${UPLOAD_MAX_BYTES / 1024 / 1024} MB.`
+    );
+  }
+  const { default: JSZip2 } = await import("jszip");
+  const archiv = await JSZip2.loadAsync(datei).catch((fehler4) => {
+    throw new Error(
+      `${name} konnte nicht als ZIP gelesen werden: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+    );
+  });
+  const pfade = [];
+  archiv.forEach((pfad, eintrag) => {
+    if (istImportierbar(pfad, eintrag.dir)) pfade.push(pfad);
+  });
+  pfade.sort(nachPfad);
+  if (pfade.length === 0) {
+    throw new Error(
+      `${name} enth\xE4lt kein unterst\xFCtztes Bild (erwartet: ${Object.keys(BILD_ENDUNGEN).map((e) => `.${e}`).join(", ")}).`
+    );
+  }
+  const bilder = [];
+  for (const pfad of pfade) {
+    const eintrag = archiv.file(pfad);
+    if (!eintrag) continue;
+    const angekuendigt = bildGroesseVerdikt(name, pfad, angekuendigteGroesse(eintrag));
+    if (angekuendigt) throw new Error(angekuendigt);
+    const base64 = await eintrag.async("base64");
+    const nachgemessen = bildGroesseVerdikt(name, pfad, byteLaenge(base64));
+    if (nachgemessen) throw new Error(nachgemessen);
+    bilder.push({
+      name: pfad,
+      base64,
+      mimeType: BILD_ENDUNGEN[endungVon(pfad)]
+    });
+  }
+  return bilder;
+}
+
 // src/lib/szenen/bildVorschau.ts
 async function ladeVorschauen(port, mediaRefs, fertig, optionen = {}) {
   const laden = port.loadPreview;
@@ -6242,7 +6661,7 @@ function usePortQuery(frage, abhaengigkeiten) {
 }
 
 // src/features/szenen/areas/ElementDetail.tsx
-import { useEffect as useEffect5, useMemo as useMemo2, useState as useState10 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo2, useState as useState10 } from "react";
 
 // src/features/szenen/elementLabels.ts
 var LABELS = {
@@ -8334,10 +8753,10 @@ var VersionNavigator = ({
 };
 
 // src/features/szenen/areas/RunsPanel.tsx
-import { useState as useState9 } from "react";
+import { useEffect as useEffect5, useRef as useRef3, useState as useState9 } from "react";
 
 // src/features/szenen/areas/RunImagesPanel.tsx
-import { useEffect as useEffect4, useRef as useRef2, useState as useState8 } from "react";
+import React7, { useEffect as useEffect4, useRef as useRef2, useState as useState8 } from "react";
 
 // src/features/szenen/areas/Bildbausteine.tsx
 import { useCallback, useEffect as useEffect3, useState as useState7 } from "react";
@@ -8777,6 +9196,7 @@ function useBildQuellen(port, bilder) {
   const [stand, setStand] = useState8(() => ({ quellen: /* @__PURE__ */ new Map(), fehler: /* @__PURE__ */ new Map() }));
   const gehalten = useRef2(/* @__PURE__ */ new Map());
   const gescheitert = useRef2(/* @__PURE__ */ new Map());
+  const [versuch, setVersuch] = useState8(0);
   const schluessel = bilder.map((b) => `${b.media_ref}|${b.mime_type ?? ""}`).join(" ");
   useEffect4(() => {
     const bestand = port.imageLibrary;
@@ -8785,7 +9205,9 @@ function useBildQuellen(port, bilder) {
     void (async () => {
       for (const bild of bilder) {
         if (abgebrochen) return;
-        if (gehalten.current.has(bild.media_ref) || gescheitert.current.has(bild.media_ref)) continue;
+        const vorher = gescheitert.current.get(bild.media_ref);
+        const endgueltig = vorher !== void 0 && !vorher.retryable;
+        if (gehalten.current.has(bild.media_ref) || endgueltig) continue;
         const ergebnis = await bestand.resolveImage(bild.media_ref, bild.mime_type ?? null);
         if (abgebrochen) return;
         if (ergebnis.kind === "ok" && ergebnis.value) {
@@ -8793,8 +9215,12 @@ function useBildQuellen(port, bilder) {
             bild.media_ref,
             `data:${ergebnis.value.mime_type};base64,${ergebnis.value.data}`
           );
+          gescheitert.current.delete(bild.media_ref);
         } else if (ergebnis.kind === "error") {
-          gescheitert.current.set(bild.media_ref, ergebnis.message);
+          gescheitert.current.set(bild.media_ref, {
+            message: ergebnis.message,
+            retryable: ergebnis.retryable
+          });
         }
         setStand({
           quellen: new Map(gehalten.current),
@@ -8805,8 +9231,19 @@ function useBildQuellen(port, bilder) {
     return () => {
       abgebrochen = true;
     };
-  }, [port, schluessel]);
-  return stand;
+  }, [port, schluessel, versuch]);
+  const fehlerNachricht = /* @__PURE__ */ new Map();
+  let wiederholbar = false;
+  for (const [ref, f] of stand.fehler) {
+    fehlerNachricht.set(ref, f.message);
+    if (f.retryable) wiederholbar = true;
+  }
+  return {
+    quellen: stand.quellen,
+    fehler: fehlerNachricht,
+    wiederholbar,
+    erneutVersuchen: () => setVersuch((n) => n + 1)
+  };
 }
 var BildDetails = ({ bild, fehler: fehler4, aufloesbar }) => /* @__PURE__ */ jsxs8("span", { className: "szenen-bilder__meta", "data-testid": `batchbild-${bild.media_ref}`, children: [
   /* @__PURE__ */ jsx8("code", { children: bild.media_ref }),
@@ -8827,8 +9264,17 @@ var BildDetails = ({ bild, fehler: fehler4, aufloesbar }) => /* @__PURE__ */ jsx
   // Serverroute (A6).
   /* @__PURE__ */ jsx8("em", { "data-testid": `batchbild-unsupported-${bild.media_ref}`, children: "Dieser Host l\xF6st keine Bilder auf \u2014 nur die Metadaten sind bekannt." })
 ] });
+var HERKUNFT_TEXT = {
+  generated_in_app: "in der App erzeugt",
+  external_import: "extern importiert",
+  mixed: "gemischte Herkunft"
+};
+var HERKUNFT_KURZ = {
+  generated_in_app: "in der App erzeugt",
+  external_import: "extern importiert"
+};
 var BatchKachel = ({ port, batch }) => {
-  const { quellen, fehler: fehler4 } = useBildQuellen(port, batch.images);
+  const { quellen, fehler: fehler4, wiederholbar, erneutVersuchen } = useBildQuellen(port, batch.images);
   const aufloesbar = Boolean(port.imageLibrary);
   const bilder = batch.images.map((bild) => ({
     id: bild.media_ref,
@@ -8854,7 +9300,7 @@ var BatchKachel = ({ port, batch }) => {
         /* @__PURE__ */ jsxs8("header", { className: "szenen-bilder__batchkopf", children: [
           /* @__PURE__ */ jsx8("strong", { children: batch.title }),
           /* @__PURE__ */ jsxs8("span", { className: "szenen-bilder__herkunft", children: [
-            batch.source_kind === "generated_in_app" ? "in der App erzeugt" : "extern importiert",
+            HERKUNFT_TEXT[batch.source_kind],
             " \xB7 ",
             batch.images.length,
             " Bild(er)"
@@ -8868,6 +9314,16 @@ var BatchKachel = ({ port, batch }) => {
             satzTitel: batch.title
           }
         ),
+        wiederholbar && /* @__PURE__ */ jsx8(
+          "button",
+          {
+            type: "button",
+            className: "szenen-bilder__retry",
+            onClick: erneutVersuchen,
+            "data-testid": `batch-retry-${batch.item_id}`,
+            children: "Bilder erneut laden"
+          }
+        ),
         /* @__PURE__ */ jsxs8("details", { className: "szenen-bilder__technik", "data-testid": `batch-technik-${batch.item_id}`, children: [
           /* @__PURE__ */ jsx8("summary", { children: "Technische Details" }),
           /* @__PURE__ */ jsxs8("p", { className: "szenen-bilder__ids", children: [
@@ -8876,8 +9332,13 @@ var BatchKachel = ({ port, batch }) => {
               /* @__PURE__ */ jsx8("code", { "data-testid": `batch-item-${batch.item_id}`, children: batch.item_id })
             ] }),
             /* @__PURE__ */ jsxs8("span", { children: [
-              "Batches ",
-              /* @__PURE__ */ jsx8("code", { children: batch.generation_batch_ids.join(", ") })
+              "Batches",
+              " ",
+              batch.origins.length > 0 ? batch.origins.map((h, i) => /* @__PURE__ */ jsxs8(React7.Fragment, { children: [
+                i > 0 ? ", " : "",
+                /* @__PURE__ */ jsx8("code", { children: h.generation_batch_id }),
+                ` (${HERKUNFT_KURZ[h.source_kind]})`
+              ] }, h.generation_batch_id)) : /* @__PURE__ */ jsx8("code", { children: batch.generation_batch_ids.join(", ") })
             ] })
           ] }),
           /* @__PURE__ */ jsx8("ul", { className: "szenen-bilder__batchliste", children: batch.images.map((bild) => /* @__PURE__ */ jsx8("li", { children: /* @__PURE__ */ jsx8(
@@ -9081,21 +9542,114 @@ var ErzeugenAktion = ({ port, lauf, wahl, wahlFehler, onFertig }) => {
     )
   ] });
 };
+var DEFAULT_VORLAGE_KEY = "__default__";
 var ZuordnenAktion = ({ port, lauf, onFertig }) => {
   const [dateien, setDateien] = useState8([]);
   const [seeds, setSeeds] = useState8({});
+  const [zip, setZip] = useState8(null);
+  const [zipLaedt, setZipLaedt] = useState8(false);
+  const [seedListe, setSeedListe] = useState8("");
+  const [vorlagen, setVorlagen] = useState8([DEFAULT_SEED_VORLAGE]);
+  const [vorlageKey, setVorlageKey] = useState8(DEFAULT_VORLAGE_KEY);
+  const [vorlagenStand, setVorlagenStand] = useState8(0);
+  const [vorlageBenennen, setVorlageBenennen] = useState8(false);
+  const [vorlageName, setVorlageName] = useState8("");
   const [modell, setModell] = useState8("");
   const [itemId, setItemId] = useState8("");
   const [laeuft, setLaeuft] = useState8(false);
   const [notiz, setNotiz] = useState8(null);
+  const auswahlMarke = useRef2(0);
+  const zipAktiv = zip !== null;
+  useEffect4(() => {
+    if (!zipAktiv) return;
+    let abgebrochen = false;
+    void (async () => {
+      const gelesen = port.seedTemplates ? await port.seedTemplates.listSeedTemplates() : null;
+      if (abgebrochen) return;
+      setVorlagen(mitDefaultVorlage(
+        gelesen && gelesen.kind === "ok" ? gelesen.value : []
+      ));
+    })();
+    return () => {
+      abgebrochen = true;
+    };
+  }, [zipAktiv, port, vorlagenStand]);
   if (!port.imageBatchWrite) {
     return /* @__PURE__ */ jsx8("p", { "data-testid": `zuordnen-unsupported-${lauf.run_id}`, children: "Dieser Host ordnet keine externen Bilder zu \u2014 er hat keinen gesicherten Batch-Schreibweg. Die Historie oben bleibt trotzdem sichtbar." });
   }
-  const importieren = async () => {
+  const zuordnung = zip ? ordneSeedsZu(seedListe, zip.bilder.length) : null;
+  const dateiWahl = async (liste) => {
+    const gewaehlt = [...liste ?? []];
+    const warZip = zip !== null;
+    const meine = auswahlMarke.current += 1;
+    const veraltet = () => auswahlMarke.current !== meine;
+    const zips = gewaehlt.filter(istZipDatei);
+    const nurEinZip = zips.length === 1 && gewaehlt.length === 1;
+    setNotiz(null);
+    setSeeds({});
+    setZip(null);
+    setDateien(zips.length === 0 ? gewaehlt : []);
+    setZipLaedt(nurEinZip);
+    if (zips.length > 0 && zips.length !== gewaehlt.length) {
+      setNotiz({
+        tone: "error",
+        text: `Die Auswahl enth\xE4lt ${zips.length} ZIP-Datei(en) und ${gewaehlt.length - zips.length} Bilddatei(en). Bitte entweder ein ZIP oder einzelne Bilder w\xE4hlen \u2014 nicht beides in einem Import.`
+      });
+      return;
+    }
+    if (zips.length > 1) {
+      setNotiz({
+        tone: "error",
+        text: `${zips.length} ZIP-Dateien gew\xE4hlt (${zips.map((z) => z.name).join(", ")}). Ein Import nimmt genau ein ZIP.`
+      });
+      return;
+    }
+    if (!nurEinZip) return;
+    const datei = zips[0];
+    try {
+      const bilder = await leseBilderAusZip(datei);
+      if (veraltet()) return;
+      setZip({ datei, bilder });
+      if (!warZip) {
+        setSeedListe(DEFAULT_SEED_VORLAGE.seeds);
+        setVorlageKey(DEFAULT_VORLAGE_KEY);
+      }
+    } catch (fehler4) {
+      if (veraltet()) return;
+      setNotiz({
+        tone: "error",
+        text: fehler4 instanceof Error ? fehler4.message : String(fehler4)
+      });
+    }
+    if (veraltet()) return;
+    setZipLaedt(false);
+  };
+  const schreiben = async (bilder, generationBatchId, titel) => {
     setLaeuft(true);
     setNotiz(null);
     try {
-      const bilder = [];
+      const ergebnis = await port.imageBatchWrite.importBatch({
+        runId: lauf.run_id,
+        generationBatchId,
+        images: bilder,
+        title: titel
+      });
+      setNotiz(
+        ergebnis.kind === "ok" ? { tone: "ok", text: `Importiert als Item ${ergebnis.value.item_id} mit ${bilder.length} Bild(ern).` } : noticeFor(ergebnis, "Externe Bilder importieren")
+      );
+    } catch (fehler4) {
+      setNotiz({
+        tone: "error",
+        text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+      });
+    }
+    setLaeuft(false);
+    onFertig();
+  };
+  const importieren = async () => {
+    let bilder;
+    try {
+      bilder = [];
       for (let index = 0; index < dateien.length; index++) {
         const roh = (seeds[index] ?? "").trim();
         const seed = roh === "" ? void 0 : Number.parseInt(roh, 10);
@@ -9108,25 +9662,42 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
           ...seed !== void 0 ? { seed } : {}
         });
       }
-      const ergebnis = await port.imageBatchWrite.importBatch({
-        runId: lauf.run_id,
-        // Vor dem Aufruf gebildet und stabil (D-113): eine Wiederholung
-        // derselben Einreichung erzeugt kein zweites Item.
-        generationBatchId: `imp-${lauf.run_id}-${dateien.length}-${dateien.map((d) => d.size).join("_")}`,
-        images: bilder,
-        title: `Externer Import zu Lauf ${lauf.run_id}`
-      });
-      setNotiz(
-        ergebnis.kind === "ok" ? { tone: "ok", text: `Importiert als Item ${ergebnis.value.item_id} mit ${bilder.length} Bild(ern).` } : noticeFor(ergebnis, "Externe Bilder importieren")
-      );
     } catch (fehler4) {
       setNotiz({
         tone: "error",
         text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
       });
+      return;
     }
-    setLaeuft(false);
-    onFertig();
+    await schreiben(
+      bilder,
+      // Vor dem Aufruf gebildet und stabil (D-113): eine Wiederholung
+      // derselben Einreichung erzeugt kein zweites Item.
+      `imp-${lauf.run_id}-${dateien.length}-${dateien.map((d) => d.size).join("_")}`,
+      `Externer Import zu Lauf ${lauf.run_id}`
+    );
+  };
+  const zipImportieren = async () => {
+    if (!zip || !zuordnung) return;
+    if (zuordnung.ungueltige.length > 0) {
+      setNotiz({ tone: "error", text: seedFehlerText(zuordnung.ungueltige) });
+      return;
+    }
+    const bilder = zip.bilder.map((bild, index) => {
+      const seed = zuordnung.eintraege[index]?.seed ?? null;
+      return {
+        imageBase64: bild.base64,
+        ...modell.trim() ? { model: modell.trim() } : {},
+        // Unbekannt bleibt unbekannt: kein Feld statt eines erfundenen
+        // Werts (§6.1).
+        ...seed !== null ? { seed } : {}
+      };
+    });
+    await schreiben(
+      bilder,
+      `imp-${lauf.run_id}-zip-${zip.datei.size}-${bilder.length}`,
+      `Externer Import zu Lauf ${lauf.run_id} (${zip.datei.name})`
+    );
   };
   const zuordnen = async () => {
     setLaeuft(true);
@@ -9144,35 +9715,63 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
     setLaeuft(false);
     onFertig();
   };
+  const vorlageWaehlen = (key) => {
+    setVorlageKey(key);
+    const vorlage = key === DEFAULT_VORLAGE_KEY ? DEFAULT_SEED_VORLAGE : vorlagen.find((v) => String(v.id) === key);
+    if (vorlage) setSeedListe(vorlage.seeds);
+  };
+  const vorlageSpeichern = async () => {
+    const name = vorlageName.trim();
+    if (!name || !seedListe.trim() || !port.seedTemplates?.saveSeedTemplate) return;
+    const ergebnis = await port.seedTemplates.saveSeedTemplate({ name, seeds: seedListe.trim() });
+    if (ergebnis.kind !== "ok") {
+      setNotiz(noticeFor(ergebnis, "Seed-Vorlage speichern"));
+      return;
+    }
+    setVorlageBenennen(false);
+    setVorlageName("");
+    if (ergebnis.value.id !== void 0) setVorlageKey(String(ergebnis.value.id));
+    setVorlagenStand((n) => n + 1);
+  };
+  const vorlageLoeschen = async () => {
+    if (vorlageKey === DEFAULT_VORLAGE_KEY || !port.seedTemplates?.deleteSeedTemplate) return;
+    const ergebnis = await port.seedTemplates.deleteSeedTemplate(vorlageKey);
+    if (ergebnis.kind !== "ok") {
+      setNotiz(noticeFor(ergebnis, "Seed-Vorlage l\xF6schen"));
+      return;
+    }
+    setVorlageKey(DEFAULT_VORLAGE_KEY);
+    setVorlagenStand((n) => n + 1);
+  };
   return /* @__PURE__ */ jsxs8("div", { className: "szenen-bilder__aktion-inhalt", "data-testid": `zuordnen-${lauf.run_id}`, children: [
     /* @__PURE__ */ jsxs8("label", { children: [
-      "Bilddateien",
+      "Bilddateien oder ein ZIP",
       /* @__PURE__ */ jsx8(
         "input",
         {
           type: "file",
-          accept: "image/*",
+          accept: "image/*,.zip",
           multiple: true,
           "data-testid": `zuordnen-dateien-${lauf.run_id}`,
           onChange: (e) => {
-            setDateien([...e.target.files ?? []]);
-            setSeeds({});
+            void dateiWahl(e.target.files);
           }
         }
       )
     ] }),
+    zipLaedt && /* @__PURE__ */ jsx8("p", { "data-testid": `zuordnen-zip-laedt-${lauf.run_id}`, children: "ZIP wird gelesen \u2026" }),
+    (dateien.length > 0 || zip) && /* @__PURE__ */ jsxs8("label", { children: [
+      "Modell (f\xFCr alle Bilder, leer = unbekannt)",
+      /* @__PURE__ */ jsx8(
+        "input",
+        {
+          value: modell,
+          "data-testid": `zuordnen-modell-${lauf.run_id}`,
+          onChange: (e) => setModell(e.target.value)
+        }
+      )
+    ] }),
     dateien.length > 0 && /* @__PURE__ */ jsxs8(Fragment4, { children: [
-      /* @__PURE__ */ jsxs8("label", { children: [
-        "Modell (f\xFCr alle Bilder, leer = unbekannt)",
-        /* @__PURE__ */ jsx8(
-          "input",
-          {
-            value: modell,
-            "data-testid": `zuordnen-modell-${lauf.run_id}`,
-            onChange: (e) => setModell(e.target.value)
-          }
-        )
-      ] }),
       /* @__PURE__ */ jsx8("ol", { "data-testid": `zuordnen-vorschau-${lauf.run_id}`, children: dateien.map((datei, index) => /* @__PURE__ */ jsxs8("li", { children: [
         /* @__PURE__ */ jsxs8("span", { children: [
           "Position ",
@@ -9206,6 +9805,157 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
         }
       )
     ] }),
+    zip && zuordnung && /* @__PURE__ */ jsxs8("div", { className: "szenen-bilder__zip", "data-testid": `zuordnen-zip-${lauf.run_id}`, children: [
+      /* @__PURE__ */ jsxs8("p", { className: "szenen-bilder__zipkopf", children: [
+        "ZIP ",
+        /* @__PURE__ */ jsx8("code", { children: zip.datei.name }),
+        " \u2014 ",
+        zip.bilder.length,
+        " Bild(er) erkannt"
+      ] }),
+      /* @__PURE__ */ jsxs8("label", { children: [
+        "Seeds (pro Bild ein Seed, Trenner , oder ;)",
+        /* @__PURE__ */ jsx8(
+          "input",
+          {
+            "data-testid": `zuordnen-seedliste-${lauf.run_id}`,
+            value: seedListe,
+            placeholder: "z. B. 1; 10; 100; 1000",
+            onChange: (e) => setSeedListe(e.target.value)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs8("label", { children: [
+        "Seed-Vorlage",
+        /* @__PURE__ */ jsxs8(
+          "select",
+          {
+            "data-testid": `zuordnen-seedvorlage-${lauf.run_id}`,
+            value: vorlageKey,
+            onChange: (e) => vorlageWaehlen(e.target.value),
+            children: [
+              /* @__PURE__ */ jsxs8("option", { value: DEFAULT_VORLAGE_KEY, children: [
+                "Default (",
+                DEFAULT_SEED_VORLAGE.seeds,
+                ")"
+              ] }),
+              vorlagen.filter((v) => !v.builtin).map((v) => /* @__PURE__ */ jsxs8("option", { value: String(v.id), children: [
+                v.name,
+                " (",
+                v.seeds,
+                ")"
+              ] }, String(v.id)))
+            ]
+          }
+        )
+      ] }),
+      (port.seedTemplates?.saveSeedTemplate || port.seedTemplates?.deleteSeedTemplate) && /* @__PURE__ */ jsxs8("p", { className: "szenen-bilder__zipvorlagen", children: [
+        port.seedTemplates?.saveSeedTemplate && !vorlageBenennen && /* @__PURE__ */ jsx8(
+          "button",
+          {
+            type: "button",
+            "data-testid": `zuordnen-vorlage-neu-${lauf.run_id}`,
+            disabled: !seedListe.trim(),
+            onClick: () => {
+              setVorlageName("");
+              setVorlageBenennen(true);
+            },
+            children: "Als Vorlage speichern"
+          }
+        ),
+        port.seedTemplates?.deleteSeedTemplate && /* @__PURE__ */ jsx8(
+          "button",
+          {
+            type: "button",
+            "data-testid": `zuordnen-vorlage-loeschen-${lauf.run_id}`,
+            disabled: vorlageKey === DEFAULT_VORLAGE_KEY,
+            onClick: () => {
+              void vorlageLoeschen();
+            },
+            children: "Vorlage l\xF6schen"
+          }
+        )
+      ] }),
+      vorlageBenennen && /* @__PURE__ */ jsxs8(Fragment4, { children: [
+        /* @__PURE__ */ jsxs8("label", { children: [
+          "Name der Vorlage",
+          /* @__PURE__ */ jsx8(
+            "input",
+            {
+              "data-testid": `zuordnen-vorlage-name-${lauf.run_id}`,
+              value: vorlageName,
+              onChange: (e) => setVorlageName(e.target.value)
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs8("p", { className: "szenen-bilder__zipvorlagen", children: [
+          /* @__PURE__ */ jsx8(
+            "button",
+            {
+              type: "button",
+              "data-testid": `zuordnen-vorlage-sichern-${lauf.run_id}`,
+              disabled: !vorlageName.trim(),
+              onClick: () => {
+                void vorlageSpeichern();
+              },
+              children: "Speichern"
+            }
+          ),
+          /* @__PURE__ */ jsx8(
+            "button",
+            {
+              type: "button",
+              "data-testid": `zuordnen-vorlage-abbrechen-${lauf.run_id}`,
+              onClick: () => setVorlageBenennen(false),
+              children: "Abbrechen"
+            }
+          )
+        ] })
+      ] }),
+      zuordnung.ueberzaehlig > 0 && /* @__PURE__ */ jsxs8("p", { "data-testid": `zuordnen-ueberzaehlig-${lauf.run_id}`, children: [
+        zuordnung.ueberzaehlig,
+        " Seed(s) mehr als Bilder \u2014 die \xFCberz\xE4hligen werden nicht geschrieben."
+      ] }),
+      /* @__PURE__ */ jsx8(
+        "ol",
+        {
+          className: "szenen-bilder__zipliste",
+          "data-testid": `zuordnen-zip-vorschau-${lauf.run_id}`,
+          children: zip.bilder.map((bild, index) => {
+            const eintrag = zuordnung.eintraege[index];
+            return /* @__PURE__ */ jsxs8("li", { children: [
+              /* @__PURE__ */ jsxs8("span", { children: [
+                "Position ",
+                index,
+                ": ",
+                bild.name
+              ] }),
+              /* @__PURE__ */ jsx8(
+                "span",
+                {
+                  "data-testid": `zuordnen-zip-seed-${lauf.run_id}-${index}`,
+                  "data-seed": eintrag.seed === null ? "" : String(eintrag.seed),
+                  children: eintrag.ungueltig ? `Seed ung\xFCltig: "${eintrag.roh}"` : eintrag.seed === null ? "Seed unbekannt" : `Seed ${eintrag.seed}`
+                }
+              )
+            ] }, `${bild.name}-${index}`);
+          })
+        }
+      ),
+      /* @__PURE__ */ jsxs8(
+        "button",
+        {
+          type: "button",
+          "data-testid": `zuordnen-zip-import-${lauf.run_id}`,
+          disabled: laeuft || zipLaedt,
+          onClick: zipImportieren,
+          children: [
+            zip.bilder.length,
+            " Bild(er) aus ZIP importieren"
+          ]
+        }
+      )
+    ] }),
     /* @__PURE__ */ jsxs8("label", { children: [
       "Oder ein bestehendes Library-Item",
       /* @__PURE__ */ jsx8(
@@ -9261,6 +10011,8 @@ var RunsPanel = ({ port, source, contextId }) => {
   const [nachladen, setNachladen] = useState9(0);
   const faehig = capabilitiesOf(port);
   const quellSchluessel = source.kind === "published" ? source.shotVersionId : source.kind === "draft_chain" ? source.chainId : source.sceneElementId;
+  const aktuelleQuelle = useRef3({ kind: source.kind, id: quellSchluessel });
+  aktuelleQuelle.current = { kind: source.kind, id: quellSchluessel };
   const [phase, neuLaden] = usePortQuery(
     () => {
       if (source.kind === "published") return port.runs.listRunsForShot(source.shotVersionId);
@@ -9271,12 +10023,16 @@ var RunsPanel = ({ port, source, contextId }) => {
   );
   const starten = async () => {
     if (source.kind !== "published") return;
+    const gestartetFuer = { kind: source.kind, id: source.shotVersionId };
     setLaeuft(true);
     const ergebnis = await port.runs.startRun({
       shotVersionId: source.shotVersionId,
       ...anweisung.trim() ? { userInstruction: anweisung.trim() } : {},
       contextId
     });
+    if (aktuelleQuelle.current.kind !== gestartetFuer.kind || aktuelleQuelle.current.id !== gestartetFuer.id) {
+      return;
+    }
     setNotiz(noticeFor(ergebnis, "Prompt-Lauf starten"));
     setLaeuft(false);
     setNachladen((n) => n + 1);
@@ -9286,6 +10042,12 @@ var RunsPanel = ({ port, source, contextId }) => {
   const [gewaehlteRunde, setGewaehlteRunde] = useState9(void 0);
   const neueste = laeufe.length > 0 ? laeufe[laeufe.length - 1].run_id : null;
   const offeneRunde = gewaehlteRunde === void 0 ? neueste : gewaehlteRunde;
+  useEffect5(() => {
+    setGewaehlteRunde(void 0);
+    setAnweisung("");
+    setNotiz(null);
+    setLaeuft(false);
+  }, [source.kind, quellSchluessel]);
   return /* @__PURE__ */ jsxs9("div", { className: "szenen-runs", "data-testid": "laeufe-bereich", "data-shot-version": quellSchluessel, children: [
     /* @__PURE__ */ jsx9("h4", { children: "Prompt-L\xE4ufe" }),
     source.kind === "published" && /* @__PURE__ */ jsxs9("div", { className: "szenen-runs__start", children: [
@@ -9356,6 +10118,26 @@ var Sekundaertext = ({ titel, text, testId }) => {
     )
   ] });
 };
+var LISTE_ANFANG = 3;
+var SekundaerListe = ({ titel, eintraege, testId, className }) => {
+  const [alle, setAlle] = useState9(false);
+  const lang = eintraege.length > LISTE_ANFANG;
+  const gezeigt = lang && !alle ? eintraege.slice(0, LISTE_ANFANG) : eintraege;
+  return /* @__PURE__ */ jsxs9("section", { className: "szenen-runs__sekundaer", children: [
+    /* @__PURE__ */ jsx9("h5", { children: titel }),
+    /* @__PURE__ */ jsx9("ul", { className, "data-testid": testId, children: gezeigt.map((eintrag, i) => /* @__PURE__ */ jsx9("li", { children: eintrag }, i)) }),
+    lang && /* @__PURE__ */ jsx9(
+      "button",
+      {
+        type: "button",
+        className: "szenen-runs__mehr",
+        onClick: () => setAlle(!alle),
+        "data-testid": `${testId}-mehr`,
+        children: alle ? "weniger anzeigen" : `${eintraege.length - LISTE_ANFANG} weitere anzeigen`
+      }
+    )
+  ] });
+};
 var RundenEintrag = ({ port, lauf, runde, offen, onUmschalten, itemMoeglich, onItemGespeichert }) => {
   const [notiz, setNotiz] = useState9(null);
   const [laeuft, setLaeuft] = useState9(false);
@@ -9441,11 +10223,23 @@ var RundenEintrag = ({ port, lauf, runde, offen, onUmschalten, itemMoeglich, onI
             testId: `feedback-${lauf.run_id}`
           }
         ),
-        lauf.output.visibility.assumptions.length > 0 && /* @__PURE__ */ jsxs9("section", { className: "szenen-runs__sekundaer", children: [
-          /* @__PURE__ */ jsx9("h5", { children: "Annahmen" }),
-          /* @__PURE__ */ jsx9("ul", { "data-testid": `annahmen-${lauf.run_id}`, children: lauf.output.visibility.assumptions.map((a, i) => /* @__PURE__ */ jsx9("li", { children: a }, i)) })
-        ] }),
-        lauf.output.notes.length > 0 && /* @__PURE__ */ jsx9("ul", { className: "szenen-runs__notizen", "data-testid": `notizen-${lauf.run_id}`, children: lauf.output.notes.map((n, i) => /* @__PURE__ */ jsx9("li", { children: n }, i)) })
+        lauf.output.visibility.assumptions.length > 0 && /* @__PURE__ */ jsx9(
+          SekundaerListe,
+          {
+            titel: "Annahmen",
+            eintraege: lauf.output.visibility.assumptions,
+            testId: `annahmen-${lauf.run_id}`
+          }
+        ),
+        lauf.output.notes.length > 0 && /* @__PURE__ */ jsx9(
+          SekundaerListe,
+          {
+            titel: "Notizen",
+            eintraege: lauf.output.notes,
+            testId: `notizen-${lauf.run_id}`,
+            className: "szenen-runs__notizen"
+          }
+        )
       ] }),
       lauf.raw_output && /* @__PURE__ */ jsxs9("details", { "data-testid": `diagnose-${lauf.run_id}`, children: [
         /* @__PURE__ */ jsx9("summary", { children: "Rohantwort (Diagnose)" }),
@@ -9533,7 +10327,7 @@ var ElementDetail = ({
     () => schnappschuss ? fieldsForType(schnappschuss.element.type) : [],
     [schnappschuss?.element.type]
   );
-  useEffect5(() => {
+  useEffect6(() => {
     setWahl(null);
     setBasiswechsel(null);
     setNotiz(null);
@@ -9564,7 +10358,7 @@ var ElementDetail = ({
     return {};
   }, [schnappschuss, angezeigt]);
   const anzeigeSchluessel = angezeigt.kind === "version" ? `v:${angezeigt.versionId}` : angezeigt.kind;
-  useEffect5(() => {
+  useEffect6(() => {
     if (!schnappschuss) return;
     setEntwurf(formFromPayload(felder, angezeigtePayload));
   }, [
@@ -9996,7 +10790,7 @@ var ElementDetail = ({
 };
 
 // src/features/szenen/areas/useSchmalesDisplay.ts
-import { useEffect as useEffect6, useState as useState11 } from "react";
+import { useEffect as useEffect7, useState as useState11 } from "react";
 var SCHMALE_ANSICHT = "(max-width: 760px)";
 function messen(abfrage) {
   if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
@@ -10004,7 +10798,7 @@ function messen(abfrage) {
 }
 function useSchmalesDisplay(abfrage = SCHMALE_ANSICHT) {
   const [schmal, setSchmal] = useState11(() => messen(abfrage));
-  useEffect6(() => {
+  useEffect7(() => {
     if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
     const liste = window.matchMedia(abfrage);
     const aktualisieren = () => setSchmal(liste.matches);
@@ -10431,7 +11225,7 @@ var MediaArea = ({ port }) => {
 };
 
 // src/features/szenen/areas/DeriveArea.tsx
-import { useEffect as useEffect7, useMemo as useMemo3, useRef as useRef3, useState as useState16 } from "react";
+import { useEffect as useEffect8, useMemo as useMemo3, useRef as useRef4, useState as useState16 } from "react";
 
 // src/features/szenen/areas/RecoveryPanel.tsx
 import { useState as useState14 } from "react";
@@ -10704,7 +11498,7 @@ var MODUS_TEXT = {
 };
 var BelegFeld = ({ titel, text, testId, offen }) => {
   const [kopiert, setKopiert] = useState16(false);
-  const feld = useRef3(null);
+  const feld = useRef4(null);
   async function kopieren() {
     try {
       await navigator.clipboard.writeText(text);
@@ -10803,7 +11597,7 @@ var ERSTE_KACHELN = 12;
 function useSichtbareKacheln(alle, wurzel) {
   const [gesehen, setGesehen] = useState16([]);
   const schluessel = alle.join(" ");
-  useEffect7(() => {
+  useEffect8(() => {
     const ziel = wurzel.current;
     if (!ziel || typeof IntersectionObserver === "undefined") return void 0;
     const beobachter = new IntersectionObserver((eintraege) => {
@@ -10822,10 +11616,10 @@ function useSichtbareKacheln(alle, wurzel) {
 }
 function useVorschauen(port, mediaRefs) {
   const [stand, setStand] = useState16(() => ({ quellen: /* @__PURE__ */ new Map(), gescheitert: /* @__PURE__ */ new Set() }));
-  const gehalten = useRef3(/* @__PURE__ */ new Map());
-  const ohneBild = useRef3(/* @__PURE__ */ new Set());
+  const gehalten = useRef4(/* @__PURE__ */ new Map());
+  const ohneBild = useRef4(/* @__PURE__ */ new Set());
   const schluessel = mediaRefs.join(" ");
-  useEffect7(() => {
+  useEffect8(() => {
     const bestand = port.imageLibrary;
     if (!bestand?.loadPreview) return void 0;
     const refs = schluessel ? schluessel.split(" ") : [];
@@ -10865,7 +11659,7 @@ function useVorschauen(port, mediaRefs) {
 var BildWaehler = ({ port, gewaehlt, onWaehlen, onEntfernen }) => {
   const [suche, setSuche] = useState16("");
   const [fokus, setFokus] = useState16(null);
-  const browser = useRef3(null);
+  const browser = useRef4(null);
   const [items] = usePortQuery(
     () => port.imageLibrary.listItems({ search: suche.trim() || void 0, limit: 60 }),
     [port, suche]
@@ -11092,8 +11886,6 @@ var DeriveArea = ({ port, contextId }) => {
       if (ergebnis.kind === "ok") setLauf(ergebnis.value);
       else if (ergebnis.kind === "unsupported") {
         setMeldung(`Dieser Host bietet \u201E${ergebnis.capability}" nicht an.`);
-      } else if (ergebnis.kind === "rejected") {
-        setMeldung(ergebnis.errors.map((e) => e.message).join("; "));
       } else {
         setMeldung(ergebnis.message);
       }
@@ -11183,8 +11975,6 @@ ${teile.map((t) => `- ${t}`).join("\n")}`;
     });
     if (ergebnis.kind === "ok") {
       setUebernommen((v) => ({ ...v, [type]: ergebnis.value.elementId }));
-    } else if (ergebnis.kind === "rejected") {
-      setMeldung(ergebnis.errors.map((e) => e.message).join("; "));
     } else if (ergebnis.kind === "unsupported") {
       setMeldung(`Dieser Host bietet \u201E${ergebnis.capability}" nicht an.`);
     } else {
@@ -14601,7 +15391,7 @@ function createHfImageStore(options) {
   const now = options.now ?? (() => Date.now());
   const versuche = options.leseVersuche ?? 4;
   const basisMs = options.leseBasisMs ?? 400;
-  const schlafen = options.schlafen ?? warten;
+  const schlafen2 = options.schlafen ?? warten;
   const abgelegt = /* @__PURE__ */ new Map();
   const vorschauen = /* @__PURE__ */ new Map();
   const bekanntePfade = /* @__PURE__ */ new Set();
@@ -14698,7 +15488,7 @@ function createHfImageStore(options) {
       }
       const pfadTyp = typ ?? "image/png";
       for (let versuch = 0; versuch < versuche; versuch += 1) {
-        if (versuch > 0) await schlafen(basisMs * 2 ** (versuch - 1));
+        if (versuch > 0) await schlafen2(basisMs * 2 ** (versuch - 1));
         const base64 = await hfLoadImageAsBase64(
           id,
           token,
@@ -14950,11 +15740,14 @@ function findImageGenerationOrder(events, batchId) {
 
 // src/lib/szenen/imageBatchStore.ts
 var istText6 = (wert) => typeof wert === "string" && wert.trim().length > 0;
-function alsBilder(rohe) {
+function alsBilder(rohe, generationBatchId) {
   if (!Array.isArray(rohe)) return [];
   return rohe.filter((b) => !!b && typeof b === "object").filter((b) => istText6(b.media_ref) && typeof b.position === "number").map((b) => ({
     media_ref: b.media_ref,
     position: b.position,
+    // Welcher Provideraufruf dieses Bild geliefert hat (§8) — aus dem
+    // Ereignis, in dem es steht, nicht aus seiner Position abgeleitet.
+    generation_batch_id: generationBatchId,
     ...istText6(b.asset_id) ? { asset_id: b.asset_id } : {},
     // Der bestätigte MIME-Typ (Review 2026-08-18 §5 P2) muss durch das
     // Rücklesen hindurch: Genau hier braucht ihn der Lesepfad, um den
@@ -14967,6 +15760,11 @@ function alsBilder(rohe) {
     height: b.height ?? null
   }));
 }
+function gesamtHerkunft(origins) {
+  const vertreten = new Set(origins.map((o) => o.source_kind));
+  if (vertreten.size === 1) return [...vertreten][0];
+  return "mixed";
+}
 function collectImageBatches(events) {
   const byItemId = /* @__PURE__ */ new Map();
   for (const event of events) {
@@ -14976,21 +15774,29 @@ function collectImageBatches(events) {
     if (payload.source_kind !== "generated_in_app" && payload.source_kind !== "external_import") continue;
     const bestehend = byItemId.get(payload.item_id);
     if (bestehend?.generation_batch_ids.includes(payload.generation_batch_id)) continue;
-    const bilder = alsBilder(payload.images);
+    const bilder = alsBilder(payload.images, payload.generation_batch_id);
+    const herkunft = {
+      generation_batch_id: payload.generation_batch_id,
+      source_kind: payload.source_kind
+    };
     if (!bestehend) {
       byItemId.set(payload.item_id, {
         item_id: payload.item_id,
         prompt_run_id: payload.prompt_run_id,
         generation_batch_ids: [payload.generation_batch_id],
         source_kind: payload.source_kind,
+        origins: [herkunft],
         title: istText6(payload.title) ? payload.title : `Batch aus Lauf ${payload.prompt_run_id}`,
         images: bilder
       });
       continue;
     }
+    const origins = [...bestehend.origins, herkunft];
     byItemId.set(payload.item_id, {
       ...bestehend,
       generation_batch_ids: [...bestehend.generation_batch_ids, payload.generation_batch_id],
+      origins,
+      source_kind: gesamtHerkunft(origins),
       images: [...bestehend.images, ...bilder]
     });
   }
@@ -15109,13 +15915,21 @@ async function legeBatchAb(options, input) {
       `Die Batch-Metadaten fuer ${input.generationBatchId} konnten nicht protokolliert werden, obwohl die Bilder bereits im Bestand liegen: ${error instanceof Error ? error.message : String(error)}`
     );
   }
+  const origins = [
+    ...bestehend?.origins ?? [],
+    { generation_batch_id: input.generationBatchId, source_kind: input.sourceKind }
+  ];
   const zusammengefuehrt = {
     item_id: itemId,
     prompt_run_id: input.runId,
     generation_batch_ids: bestehend ? [...bestehend.generation_batch_ids, input.generationBatchId] : [input.generationBatchId],
-    source_kind: bestehend?.source_kind ?? input.sourceKind,
+    source_kind: gesamtHerkunft(origins),
+    origins,
     title: titel,
-    images: [...bestehend?.images ?? [], ...abgelegt]
+    images: [
+      ...bestehend?.images ?? [],
+      ...abgelegt.map((bild) => ({ ...bild, generation_batch_id: input.generationBatchId }))
+    ]
   };
   return { kind: "ok", value: zusammengefuehrt };
 }
@@ -15499,6 +16313,20 @@ function createFlowSzenenViewPort(options) {
 }
 
 export {
+  hfListDir,
+  hfDownloadBinaryByPath,
+  hfUploadSmallFile,
+  hfBatchArchive,
+  tsFromEventPath,
+  loadPendingEvents,
+  getSessionClientId,
+  writeHFEvent,
+  getHFToken,
+  setHFToken,
+  loadHFState,
+  hfBootstrapFromLegacy,
+  hfUploadImage,
+  hfLoadImageAsBase64,
   applyEvents,
   capabilitiesOf,
   unsupportedReason,
@@ -15560,6 +16388,15 @@ export {
   preferredHeadRevisionOf,
   collectPromptRuns,
   findPromptRun,
+  DEFAULT_SEED_VORLAGE,
+  parseSeedListe,
+  formatSeedListe,
+  ordneSeedsZu,
+  seedFehlerText,
+  mitDefaultVorlage,
+  UPLOAD_MAX_BYTES,
+  istZipDatei,
+  leseBilderAusZip,
   ladeVorschauen,
   simulatedAnswerFor,
   SIMULATION_PROVIDER,
@@ -15642,6 +16479,7 @@ export {
   collectImageGenerationOrders,
   ordersForPromptRun,
   findImageGenerationOrder,
+  gesamtHerkunft,
   collectImageBatches,
   batchesForPromptRun,
   findImageBatch,