@rslsp1/fa-app-tools 2.0.82 → 2.0.84

package/dist/index.js

@@ -786,7 +786,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "2.0.82";
+var version = "2.0.84";
 
 // src/hooks/useOnClickOutside.ts
 var import_react = require("react");
@@ -6593,13 +6593,13 @@ function noticeFor(ergebnis, was) {
       };
     }
     case "rejected": {
-      const fehler3 = ergebnis.errors ?? [];
+      const fehler4 = ergebnis.errors ?? [];
       const ungeprueft = ergebnis.unchecked ?? [];
       return {
         tone: "rejected",
-        text: `${was}: abgelehnt \u2014 ${fehler3.length} Befund${fehler3.length === 1 ? "" : "e"}.`,
+        text: `${was}: abgelehnt \u2014 ${fehler4.length} Befund${fehler4.length === 1 ? "" : "e"}.`,
         details: [
-          ...fehler3.map((f) => `${f.path ?? "(ohne Pfad)"}: ${f.message ?? "ohne Meldung"}`),
+          ...fehler4.map((f) => `${f.path ?? "(ohne Pfad)"}: ${f.message ?? "ohne Meldung"}`),
           // Nicht verschweigen: was nicht geprüft wurde, ist nicht in Ordnung,
           // sondern ungeprüft.
           ...ungeprueft.map((u) => `ungepr\xFCft: ${u}`)
@@ -11294,7 +11294,7 @@ var ERKLAERUNG = {
 };
 var CapabilityPanel = ({ port, elementId, setupPayload }) => {
   const [bericht, setBericht] = (0, import_react36.useState)(null);
-  const [fehler3, setFehler] = (0, import_react36.useState)(null);
+  const [fehler4, setFehler] = (0, import_react36.useState)(null);
   (0, import_react36.useEffect)(() => {
     let abgemeldet = false;
     setBericht(null);
@@ -11316,10 +11316,10 @@ var CapabilityPanel = ({ port, elementId, setupPayload }) => {
       abgemeldet = true;
     };
   }, [port, elementId, setupPayload]);
-  if (fehler3) {
+  if (fehler4) {
     return /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)("p", { "data-testid": "capability-fehler", role: "alert", children: [
       "F\xE4higkeitsbericht nicht erstellbar: ",
-      fehler3
+      fehler4
     ] });
   }
   if (!bericht) return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("p", { "data-testid": "capability-laden", children: "F\xE4higkeitsbericht wird erstellt \u2026" });
@@ -11429,6 +11429,10 @@ var ChainPromptAction = ({
 var import_react39 = require("react");
 
 // src/lib/szenen/itemDerivation.ts
+var SZENEN_ITEM_PREFIX = "szn-";
+function itemIdForRun(runId) {
+  return `${SZENEN_ITEM_PREFIX}${runId}`;
+}
 function roundOfRun(run, runsOfShot) {
   return runsOfShot.findIndex((kandidat) => kandidat.run_id === run.run_id) + 1;
 }
@@ -11530,7 +11534,30 @@ var SZENEN_EVENT_TYPES = {
    * ebenfalls keine Bilddaten — nur Status, Zaehlung und die Item-Kennung,
    * falls eine entstand.
    */
-  imageGenerationFinished: "szenen.image_generation_finished"
+  imageGenerationFinished: "szenen.image_generation_finished",
+  /**
+   * Ein Bild-Batch ist kanonisch gespeichert — Stufe 6.9.2, Gate D
+   * (D-6.9.2-6).
+   *
+   * Erscheint erst, **nachdem** jedes Bild des Batches im Bildbestand liegt
+   * (`hfUploadImage` + `image_added`, dieselbe Reihenfolge wie
+   * `hfImageLibrary.putImage`) — kein Bild gilt als vorhanden, bevor sein
+   * Upload bestätigt ist (R3). Trägt bewusst **keine Bilddaten**, nur den
+   * vollständigen Metadatennachweis, den `listBatchesForPromptRun()` /
+   * `getBatch()` ohne MySQL rekonstruieren können müssen: `item_id`,
+   * `prompt_run_id`, `generation_batch_id`, `source_kind`, je Bild
+   * `position`, `media_ref`, `asset_id`, `model`, `seed`, `width`/`height`.
+   *
+   * Additiv wie jedes Ereignis dieser Domain: ein zweiter Batch desselben
+   * Laufs ist ein **weiteres** Ereignis mit derselben `item_id`, nicht eine
+   * Änderung am ersten (D-113/D-121 — ein Lauf bleibt ein Item). Gilt für
+   * `generated_in_app` **und** `external_import` — nur `source_kind`
+   * unterscheidet die beiden Schreiber (D-116/D-117/D-120).
+   *
+   * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig); gelesen
+   * wird mit `collectImageBatches` (`imageBatchStore.ts`).
+   */
+  imageBatchPersisted: "szenen.image_batch_persisted"
 };
 function sortForReplay(events) {
   return [...events].sort((a, b) => {
@@ -12179,10 +12206,10 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
       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 (fehler3) {
+    } catch (fehler4) {
       setNotiz({
         tone: "error",
-        text: `Externe Bilder importieren: ${fehler3 instanceof Error ? fehler3.message : String(fehler3)}`
+        text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
       });
     }
     setLaeuft(false);
@@ -17492,6 +17519,559 @@ function createHfImageLibrary(options) {
   };
 }
 
+// src/lib/szenen/flowImageProvider.ts
+var FLOW_MODEL_DISPLAY_NAMES = {
+  "imagen-4.0-generate-001": "Imagen 4",
+  "flow-nano-banana-pro": "\u{1F34C} Nano Banana Pro",
+  "flow-nano-banana-2": "\u{1F34C} Nano Banana 2"
+};
+function flowImageProviderHasAccess(model) {
+  return model.callable_model_id in FLOW_MODEL_DISPLAY_NAMES;
+}
+function istNichtleererText(wert) {
+  return typeof wert === "string" && wert.trim().length > 0;
+}
+function createFlowImageProvider(generateImage) {
+  return {
+    async generate(input) {
+      const modelDisplayName = FLOW_MODEL_DISPLAY_NAMES[input.callableModelId];
+      if (!modelDisplayName) {
+        throw new Error(
+          `Der Flow-Host kennt keinen Flow-Display-Namen zu "${input.callableModelId}". Bekannt sind: ${Object.keys(FLOW_MODEL_DISPLAY_NAMES).join(", ")}. Es wird kein anderes Modell ersatzweise gerufen (D-115/D-6.9.2-3).`
+        );
+      }
+      if (istNichtleererText(input.negativePrompt)) {
+        throw new Error(
+          "Flow.generate.image kennt keinen dokumentierten Parameter f\xFCr einen negativen Prompt. Der Auftrag wird deshalb als fehlgeschlagen protokolliert, statt den negativen Prompt still zu verlieren (D-6.9.2-3)."
+        );
+      }
+      const erzeugt = [];
+      let ersterFehler = null;
+      for (let position = 0; position < input.imageCount; position++) {
+        try {
+          const antwort = await generateImage({
+            prompt: input.positivePrompt,
+            modelDisplayName,
+            ...input.aspectRatio ? { aspectRatio: input.aspectRatio } : {}
+          });
+          if (!antwort || typeof antwort.base64 !== "string" || antwort.base64.length === 0) {
+            throw new Error("Flow.generate.image hat kein Bild geliefert.");
+          }
+          erzeugt.push({
+            imageBase64: antwort.base64,
+            // Das tatsaechlich gerufene Modell, nicht der Flow-Display-Name —
+            // im Bestand soll stehen, was bezahlt wurde (wie reactImageProvider.ts).
+            model: input.callableModelId
+            // Kein Seed: weder als Eingabe dokumentiert noch als Ausgabe
+            // geliefert — nichts wird erfunden (D-107).
+          });
+        } catch (fehler4) {
+          ersterFehler = fehler4 instanceof Error ? fehler4.message : String(fehler4);
+          break;
+        }
+      }
+      if (erzeugt.length === 0) {
+        throw new Error(
+          ersterFehler ?? `Flow.generate.image hat zu ${input.callableModelId} kein verwertbares Bild geliefert.`
+        );
+      }
+      return { images: erzeugt };
+    }
+  };
+}
+
+// src/lib/szenen/imageGenerationOrderStore.ts
+function istText2(wert) {
+  return typeof wert === "string" && wert.trim().length > 0;
+}
+function collectImageGenerationOrders(events) {
+  const byBatchId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageGenerationStarted) continue;
+    const payload = event.payload;
+    if (!payload || !istText2(payload.generation_batch_id) || !istText2(payload.prompt_run_id)) continue;
+    if (byBatchId.has(payload.generation_batch_id)) continue;
+    byBatchId.set(payload.generation_batch_id, {
+      generation_batch_id: payload.generation_batch_id,
+      prompt_run_id: payload.prompt_run_id,
+      source_kind: "generated_in_app",
+      request: payload.request,
+      created_at: payload.created_at ?? "",
+      status: "started"
+    });
+  }
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageGenerationFinished) continue;
+    const payload = event.payload;
+    if (!payload || !istText2(payload.generation_batch_id)) continue;
+    const auftrag = byBatchId.get(payload.generation_batch_id);
+    if (!auftrag) continue;
+    if (auftrag.status !== "started") continue;
+    if (payload.status !== "succeeded" && payload.status !== "partial" && payload.status !== "failed") continue;
+    byBatchId.set(payload.generation_batch_id, {
+      ...auftrag,
+      status: payload.status,
+      ...payload.item_id ? { item_id: payload.item_id } : {},
+      produced_count: payload.produced_count ?? 0,
+      ...payload.diagnostic ? { diagnostic: payload.diagnostic } : {},
+      finished_at: payload.finished_at ?? ""
+    });
+  }
+  return [...byBatchId.values()];
+}
+function ordersForPromptRun(events, runId) {
+  return collectImageGenerationOrders(events).filter((o) => o.prompt_run_id === runId);
+}
+
+// src/lib/szenen/imageBatchStore.ts
+var istText3 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+function alsBilder(rohe) {
+  if (!Array.isArray(rohe)) return [];
+  return rohe.filter((b) => !!b && typeof b === "object").filter((b) => istText3(b.media_ref) && typeof b.position === "number").map((b) => ({
+    media_ref: b.media_ref,
+    position: b.position,
+    ...istText3(b.asset_id) ? { asset_id: b.asset_id } : {},
+    model: b.model ?? null,
+    seed: b.seed ?? null,
+    width: b.width ?? null,
+    height: b.height ?? null
+  }));
+}
+function collectImageBatches(events) {
+  const byItemId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageBatchPersisted) continue;
+    const payload = event.payload;
+    if (!payload || !istText3(payload.item_id) || !istText3(payload.prompt_run_id) || !istText3(payload.generation_batch_id)) continue;
+    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);
+    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,
+        title: istText3(payload.title) ? payload.title : `Batch aus Lauf ${payload.prompt_run_id}`,
+        images: bilder
+      });
+      continue;
+    }
+    byItemId.set(payload.item_id, {
+      ...bestehend,
+      generation_batch_ids: [...bestehend.generation_batch_ids, payload.generation_batch_id],
+      images: [...bestehend.images, ...bilder]
+    });
+  }
+  return [...byItemId.values()];
+}
+function batchesForPromptRun(events, runId) {
+  return collectImageBatches(events).filter((b) => b.prompt_run_id === runId);
+}
+function findImageBatch(events, batchId) {
+  return collectImageBatches(events).find((b) => b.generation_batch_ids.includes(batchId)) ?? null;
+}
+
+// src/lib/szenen/hfImageBatchHistory.ts
+function lesefehler(aktion, error) {
+  return {
+    kind: "error",
+    message: `${aktion}: ${error instanceof Error ? error.message : String(error)}`,
+    retryable: true
+  };
+}
+function createHfImageBatchHistory(options) {
+  const { channel } = options;
+  return {
+    async listBatchesForPromptRun(runId) {
+      try {
+        const events = await channel.readEvents();
+        return { kind: "ok", value: batchesForPromptRun(events, runId) };
+      } catch (error) {
+        return lesefehler(`Batches fuer Lauf ${runId} konnten nicht gelesen werden`, error);
+      }
+    },
+    async getBatch(batchId) {
+      try {
+        const events = await channel.readEvents();
+        return { kind: "ok", value: findImageBatch(events, batchId) };
+      } catch (error) {
+        return lesefehler(`Batch ${batchId} konnte nicht gelesen werden`, error);
+      }
+    },
+    async listOrdersForPromptRun(runId) {
+      try {
+        const events = await channel.readEvents();
+        return { kind: "ok", value: ordersForPromptRun(events, runId) };
+      } catch (error) {
+        return lesefehler(`Bildgenerierungsauftraege fuer Lauf ${runId} konnten nicht gelesen werden`, error);
+      }
+    }
+  };
+}
+
+// src/lib/szenen/hfImageBatchPersistence.ts
+init_hfStateService();
+init_hfEventLog();
+function fehler3(nachricht, retryable = true) {
+  return { kind: "error", message: nachricht, retryable };
+}
+async function legeBatchAb(options, input) {
+  const { namespace, token, channel } = options;
+  const newImageId = options.newImageId ?? ((batchId, position) => `${batchId}-${position}`);
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const itemId = itemIdForRun(input.runId);
+  let vorhandeneEvents;
+  try {
+    vorhandeneEvents = await channel.readEvents();
+  } catch (error) {
+    return fehler3(
+      `Bild-Batches von Lauf ${input.runId} konnten vor dem Ablegen nicht gelesen werden: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const bestehend = batchesForPromptRun(vorhandeneEvents, input.runId)[0] ?? null;
+  if (bestehend?.generation_batch_ids.includes(input.generationBatchId)) {
+    return { kind: "ok", value: bestehend };
+  }
+  const startPosition = bestehend?.images.length ?? 0;
+  const abgelegt = [];
+  for (let offset = 0; offset < input.images.length; offset++) {
+    const bild = input.images[offset];
+    const id = newImageId(input.generationBatchId, startPosition + offset);
+    try {
+      await hfUploadImage(bild.imageBase64, id, token, bild.mimeType);
+      await writeHFEvent(namespace, token, "image_added", {
+        id,
+        prompt: input.title ?? `Batch ${input.generationBatchId}`,
+        tags: [],
+        timestamp: now().getTime(),
+        mimeType: bild.mimeType
+      }, []);
+    } catch (error) {
+      return fehler3(
+        `Bild ${offset + 1}/${input.images.length} des Batches ${input.generationBatchId} konnte nicht im Bildbestand abgelegt werden: ${error instanceof Error ? error.message : String(error)}. Bereits abgelegte Bilder dieses Versuchs (${abgelegt.length}) bleiben im Bestand, geh\xF6ren aber zu keinem Batch, solange das Batch-Ereignis nicht geschrieben ist.`
+      );
+    }
+    abgelegt.push({
+      position: startPosition + offset,
+      media_ref: id,
+      asset_id: id,
+      model: bild.model ?? null,
+      seed: bild.seed ?? null,
+      width: bild.width ?? null,
+      height: bild.height ?? null
+    });
+  }
+  const titel = bestehend?.title ?? (input.title?.trim() || `Batch aus Lauf ${input.runId}`);
+  const payload = {
+    item_id: itemId,
+    prompt_run_id: input.runId,
+    generation_batch_id: input.generationBatchId,
+    source_kind: input.sourceKind,
+    title: titel,
+    images: abgelegt,
+    created_at: now().toISOString()
+  };
+  try {
+    await channel.appendEvent(SZENEN_EVENT_TYPES.imageBatchPersisted, payload);
+  } catch (error) {
+    return fehler3(
+      `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 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,
+    title: titel,
+    images: [...bestehend?.images ?? [], ...abgelegt]
+  };
+  return { kind: "ok", value: zusammengefuehrt };
+}
+function createHfImageGenerationBatchPersistence(options) {
+  return {
+    async persist(input) {
+      return legeBatchAb(options, {
+        runId: input.runId,
+        generationBatchId: input.generationBatchId,
+        sourceKind: "generated_in_app",
+        images: input.images.map((bild) => ({
+          imageBase64: bild.imageBase64,
+          // Flow liefert PNG-Base64 (bestehende Konvention, s. AvatarArchitectApp.tsx
+          // `data:image/png;base64,${base64}`); der gemeinsame Vertrag führt
+          // keinen MIME-Typ je Bild.
+          mimeType: "image/png",
+          model: bild.model ?? null,
+          seed: bild.seed ?? null,
+          width: bild.width ?? null,
+          height: bild.height ?? null
+        }))
+      });
+    }
+  };
+}
+function createHfImageBatchWrite(options) {
+  return {
+    async importBatch(input) {
+      return legeBatchAb(options, {
+        runId: input.runId,
+        generationBatchId: input.generationBatchId,
+        sourceKind: "external_import",
+        title: input.title,
+        images: input.images.map((bild) => ({
+          imageBase64: bild.imageBase64,
+          mimeType: "image/png",
+          model: bild.model ?? null,
+          seed: bild.seed ?? null,
+          width: bild.width ?? null,
+          height: bild.height ?? null
+        }))
+      });
+    },
+    async attachLibraryItem(input) {
+      let events;
+      try {
+        events = await options.channel.readEvents();
+      } catch (error) {
+        return {
+          kind: "error",
+          message: `Batches konnten nicht gelesen werden: ${error instanceof Error ? error.message : String(error)}`,
+          retryable: true
+        };
+      }
+      const item = collectImageBatches(events).find((b) => b.item_id === input.itemId);
+      if (!item) {
+        return { kind: "error", message: `Item ${input.itemId} ist unbekannt.`, retryable: false };
+      }
+      if (item.prompt_run_id !== input.runId) {
+        return {
+          kind: "conflict",
+          message: `Item ${input.itemId} geh\xF6rt bereits zu Lauf ${item.prompt_run_id}.`,
+          existingPromptRunId: item.prompt_run_id
+        };
+      }
+      return { kind: "ok", value: item };
+    }
+  };
+}
+
+// src/lib/szenen/imageGenerationCapability.ts
+var isObject9 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var IMAGE_MODEL_CATALOGUE = {
+  imagen_4: {
+    callable_model_id: "imagen-4.0-generate-001",
+    provider: "google",
+    max_images: 4,
+    aspect_ratios: ["1:1", "3:4", "4:3", "9:16", "16:9"],
+    supports_seed: true
+  },
+  imagen_3: {
+    callable_model_id: "imagen-3.0-generate-001",
+    provider: "google",
+    max_images: 4,
+    aspect_ratios: ["1:1", "3:4", "4:3", "9:16", "16:9"],
+    supports_seed: true
+  },
+  /**
+   * Stufe 6.9.2, Nachtrag — real gegen Flow geprüft (2026-08-17): Der
+   * Modellwähler im Flow-„Generieren"-Tab zeigt aktuell nur "Nano Banana Pro"
+   * und "Nano Banana 2" als wählbar an, "Imagen 4" erscheint dort ausgegraut.
+   * `provider: 'flow'` statt `'google'` ist bewusst: Diese Modelle sind nur
+   * über `Flow.generate.image` erreichbar, nicht über die direkte
+   * Google-Imagen-REST-Route, die der React-Host benutzt (`reactImageProvider.ts`)
+   * — React meldet sie deshalb korrekt als `unsupported`, ohne eine eigene
+   * Host-Verzweigung zu brauchen (D-115/R-1: `hasAccess` prüft `provider`).
+   */
+  nano_banana_pro: {
+    callable_model_id: "flow-nano-banana-pro",
+    provider: "flow",
+    max_images: 4,
+    // Flow.generate.image dokumentiert nur '1:1' | '16:9' | '9:16' (howto-flow-sdk.md).
+    aspect_ratios: ["1:1", "16:9", "9:16"],
+    // Weder als Eingabe- noch als Ausgabeparameter dokumentiert — nichts erfunden (D-107).
+    supports_seed: false
+  },
+  nano_banana_2: {
+    callable_model_id: "flow-nano-banana-2",
+    provider: "flow",
+    max_images: 4,
+    aspect_ratios: ["1:1", "16:9", "9:16"],
+    supports_seed: false
+  }
+};
+function callableImageModelFor(targetModelKey) {
+  return IMAGE_MODEL_CATALOGUE[targetModelKey] ?? null;
+}
+function targetModelKeyOf(targetModel) {
+  if (!isObject9(targetModel)) return null;
+  return typeof targetModel.key === "string" && targetModel.key.length > 0 ? targetModel.key : null;
+}
+function capabilityForTargetModel(targetModel, hasAccess) {
+  const key = targetModelKeyOf(targetModel);
+  if (!key) {
+    return {
+      kind: "unsupported",
+      target_model_key: "(unbekannt)",
+      reason: 'Der eingefrorene Lauf tr\xE4gt kein "target_model.key" \u2014 es gibt nichts zuzuordnen.'
+    };
+  }
+  const modell = callableImageModelFor(key);
+  if (!modell) {
+    return {
+      kind: "unsupported",
+      target_model_key: key,
+      reason: `F\xFCr das Zielmodell "${key}" ist in diesem Host kein Bildpfad katalogisiert.`
+    };
+  }
+  if (!hasAccess(modell)) {
+    return {
+      kind: "unsupported",
+      target_model_key: key,
+      reason: `Dieser Host hat keinen Zugang zu ${modell.callable_model_id} (${modell.provider}).`
+    };
+  }
+  return {
+    kind: "supported",
+    target_model_key: key,
+    provider: modell.provider,
+    callable_model_id: modell.callable_model_id,
+    max_images: modell.max_images,
+    aspect_ratios: modell.aspect_ratios,
+    supports_seed: modell.supports_seed
+  };
+}
+
+// src/lib/szenen/imageGenerationPort.ts
+function queryError2(error, action) {
+  return {
+    kind: "error",
+    message: `${action}: ${error instanceof Error ? error.message : String(error)}`,
+    retryable: true
+  };
+}
+function createImageGenerationPort(options) {
+  const { runs, provider, batches, events, hasAccess } = options;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  async function readRun(runId) {
+    try {
+      return await runs.getRun(runId);
+    } catch (error) {
+      return queryError2(error, `Lauf ${runId} konnte nicht gelesen werden`);
+    }
+  }
+  return {
+    async capabilityForRun(runId) {
+      const gelesen = await readRun(runId);
+      if (gelesen.kind !== "ok") return gelesen;
+      if (!gelesen.value) {
+        return { kind: "error", message: `Lauf ${runId} ist unbekannt.`, retryable: false };
+      }
+      const targetModel = gelesen.value.input_payload?.target_model;
+      return { kind: "ok", value: capabilityForTargetModel(targetModel, hasAccess) };
+    },
+    async startFromPromptRun(input) {
+      const gelesen = await readRun(input.runId);
+      if (gelesen.kind !== "ok") return { kind: "rejected", message: gelesen.message };
+      if (!gelesen.value) {
+        return { kind: "rejected", message: `Lauf ${input.runId} ist unbekannt.` };
+      }
+      const run = gelesen.value;
+      if (run.status !== "succeeded" || !run.output) {
+        return {
+          kind: "rejected",
+          message: `Lauf ${input.runId} ist nicht erfolgreich \u2014 ein Bildauftrag braucht einen eingefrorenen Prompt (D-103).`
+        };
+      }
+      const targetModel = run.input_payload?.target_model;
+      const capability = capabilityForTargetModel(targetModel, hasAccess);
+      if (capability.kind !== "supported") {
+        return { kind: "unsupported", targetModelKey: capability.target_model_key, reason: capability.reason };
+      }
+      const startedPayload = {
+        generation_batch_id: input.generationBatchId,
+        prompt_run_id: input.runId,
+        source_kind: "generated_in_app",
+        request: {
+          image_count: input.imageCount,
+          ...input.aspectRatio ? { aspect_ratio: input.aspectRatio } : {},
+          ...input.seeds ? { seeds: input.seeds } : {},
+          callable_model_id: capability.callable_model_id
+        },
+        created_at: now().toISOString()
+      };
+      try {
+        await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationStarted, startedPayload);
+      } catch (error) {
+        return {
+          kind: "failed",
+          message: `Der Auftrag ${input.generationBatchId} konnte nicht protokolliert werden: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      let produced = [];
+      let providerFehler = null;
+      try {
+        const antwort = await provider.generate({
+          callableModelId: capability.callable_model_id,
+          provider: capability.provider,
+          positivePrompt: run.output.positive,
+          negativePrompt: run.output.negative,
+          imageCount: input.imageCount,
+          ...input.aspectRatio ? { aspectRatio: input.aspectRatio } : {},
+          ...input.seeds ? { seeds: input.seeds } : {}
+        });
+        produced = antwort.images;
+      } catch (error) {
+        providerFehler = error instanceof Error ? error.message : String(error);
+      }
+      if (providerFehler || produced.length === 0) {
+        const finishedPayload2 = {
+          generation_batch_id: input.generationBatchId,
+          status: "failed",
+          produced_count: 0,
+          diagnostic: providerFehler ?? "Der Provider hat kein verwertbares Bild geliefert.",
+          finished_at: now().toISOString()
+        };
+        await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationFinished, finishedPayload2).catch(() => {
+        });
+        return {
+          kind: "failed",
+          message: finishedPayload2.diagnostic
+        };
+      }
+      const persistiert = await batches.persist({
+        runId: input.runId,
+        generationBatchId: input.generationBatchId,
+        images: produced
+      });
+      if (persistiert.kind !== "ok") {
+        const finishedPayload2 = {
+          generation_batch_id: input.generationBatchId,
+          status: "failed",
+          produced_count: 0,
+          diagnostic: persistiert.kind === "error" ? persistiert.message : `Batch ${input.generationBatchId} konnte nicht gespeichert werden (${persistiert.kind}).`,
+          finished_at: now().toISOString()
+        };
+        await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationFinished, finishedPayload2).catch(() => {
+        });
+        return { kind: "failed", message: finishedPayload2.diagnostic };
+      }
+      const istPartial = produced.length < input.imageCount;
+      const finishedPayload = {
+        generation_batch_id: input.generationBatchId,
+        status: istPartial ? "partial" : "succeeded",
+        item_id: persistiert.value.item_id,
+        produced_count: produced.length,
+        finished_at: now().toISOString()
+      };
+      await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationFinished, finishedPayload).catch(() => {
+      });
+      return istPartial ? { kind: "partial", batch: persistiert.value, requested: input.imageCount, produced: produced.length } : { kind: "succeeded", batch: persistiert.value };
+    }
+  };
+}
+
 // src/lib/szenen/flowViewPort.ts
 var defaultContext = {
   async chainFor(contextId) {
@@ -17539,8 +18119,36 @@ function createFlowSzenenViewPort(options) {
     ...options.newRunId ? { newRunId: options.newRunId } : {},
     ...options.now ? { now: options.now } : {}
   });
-  const port = { elements, context, runs, derivation };
+  const imageBatchHistory = createHfImageBatchHistory({ channel });
+  const hatHfZugangsdaten = Boolean(options.namespace?.trim() && options.token?.trim());
+  const imageBatchWrite = hatHfZugangsdaten ? createHfImageBatchWrite({
+    namespace: options.namespace,
+    token: options.token,
+    channel,
+    ...options.newBatchImageId ? { newImageId: options.newBatchImageId } : {},
+    ...options.now ? { now: options.now } : {}
+  }) : void 0;
+  const bildProvider = options.imageProvider ?? (options.generateImage ? createFlowImageProvider(options.generateImage) : void 0);
+  const imageGeneration = bildProvider && imageBatchWrite ? createImageGenerationPort({
+    runs: { async getRun(runId) {
+      return runs.getRun(runId);
+    } },
+    provider: bildProvider,
+    batches: createHfImageGenerationBatchPersistence({
+      namespace: options.namespace,
+      token: options.token,
+      channel,
+      ...options.newBatchImageId ? { newImageId: options.newBatchImageId } : {},
+      ...options.now ? { now: options.now } : {}
+    }),
+    events: channel,
+    hasAccess: options.imageProviderHasAccess ?? flowImageProviderHasAccess,
+    ...options.now ? { now: options.now } : {}
+  }) : void 0;
+  const port = { elements, context, runs, derivation, imageBatchHistory };
   if (imageLibrary) port.imageLibrary = imageLibrary;
+  if (imageBatchWrite) port.imageBatchWrite = imageBatchWrite;
+  if (imageGeneration) port.imageGeneration = imageGeneration;
   return port;
 }
 
@@ -17650,8 +18258,9 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
   const szenenPort = (0, import_react47.useMemo)(() => hfToken && effectiveNamespace ? createFlowSzenenViewPort({
     generateText: onGeneratePrompt,
     token: hfToken,
-    namespace: effectiveNamespace
-  }) : null, [hfToken, effectiveNamespace, onGeneratePrompt]);
+    namespace: effectiveNamespace,
+    generateImage: onGenerateImage
+  }) : null, [hfToken, effectiveNamespace, onGeneratePrompt, onGenerateImage]);
   const {
     state: hfState,
     isLoading: isHfRefreshing,