@rslsp1/fa-app-tools 2.0.82 → 2.0.84

package/dist/szenen.js

@@ -38,6 +38,7 @@ __export(szenen_exports, {
   ContractViolation: () => ContractViolation,
   DERIVABLE_TYPES: () => DERIVABLE_TYPES,
   ELEMENT_VERSION_SCHEMA_FILE: () => ELEMENT_VERSION_SCHEMA_FILE,
+  FLOW_MODEL_DISPLAY_NAMES: () => FLOW_MODEL_DISPLAY_NAMES,
   PROBE_VERSION_ID: () => PROBE_VERSION_ID,
   REFERENCE_FIELD: () => REFERENCE_FIELD,
   RULES_WITHOUT_CAPABILITY_EFFECT: () => RULES_WITHOUT_CAPABILITY_EFFECT,
@@ -57,6 +58,7 @@ __export(szenen_exports, {
   VersionDagError: () => VersionDagError,
   areasFor: () => areasFor,
   assessDerivationResponse: () => assessDerivationResponse,
+  batchesForPromptRun: () => batchesForPromptRun,
   buildDerivationSystemInstruction: () => buildSystemInstruction2,
   buildDerivationUserPrompt: () => buildUserPrompt2,
   buildSystemInstruction: () => buildSystemInstruction,
@@ -89,6 +91,7 @@ __export(szenen_exports, {
   checkSzenenBatchOrigin: () => checkSzenenBatchOrigin,
   checkTitle: () => checkTitle,
   checkWriteDraftInput: () => checkWriteDraftInput,
+  collectImageBatches: () => collectImageBatches,
   collectImageGenerationOrders: () => collectImageGenerationOrders,
   collectPromptRuns: () => collectPromptRuns,
   collectProviderChecks: () => collectProviderChecks,
@@ -102,10 +105,14 @@ __export(szenen_exports, {
   createEventLogDerivationPersistence: () => createEventLogDerivationPersistence,
   createEventLogRunPersistence: () => createEventLogRunPersistence,
   createFakeTextGenerationPort: () => createFakeTextGenerationPort,
+  createFlowImageProvider: () => createFlowImageProvider,
   createFlowSzenenViewPort: () => createFlowSzenenViewPort,
   createFlowTextGenerationPort: () => createFlowTextGenerationPort,
   createHfElementStore: () => createHfElementStore,
   createHfEventChannel: () => createHfEventChannel,
+  createHfImageBatchHistory: () => createHfImageBatchHistory,
+  createHfImageBatchWrite: () => createHfImageBatchWrite,
+  createHfImageGenerationBatchPersistence: () => createHfImageGenerationBatchPersistence,
   createHfImageLibrary: () => createHfImageLibrary,
   createImageGenerationPort: () => createImageGenerationPort,
   createInMemoryEventChannel: () => createInMemoryEventChannel,
@@ -119,12 +126,14 @@ __export(szenen_exports, {
   differentialSteps: () => differentialSteps,
   draftRevisionOf: () => draftRevisionOf,
   elementStoreContractChecks: () => elementStoreContractChecks,
+  findImageBatch: () => findImageBatch,
   findImageGenerationOrder: () => findImageGenerationOrder,
   findPromptRun: () => findPromptRun,
   findProviderCheck: () => findProviderCheck,
   findSceneDerivation: () => findSceneDerivation,
   findSceneDerivationRecovery: () => findSceneDerivationRecovery,
   firstError: () => firstError,
+  flowImageProviderHasAccess: () => flowImageProviderHasAccess,
   formatSchemaErrors: () => formatSchemaErrors,
   freezeDraftChain: () => freezeDraftChain,
   getSzenenSchemas: () => getSzenenSchemas,
@@ -5327,7 +5336,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) => {
@@ -9415,6 +9447,32 @@ var IMAGE_MODEL_CATALOGUE = {
     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) {
@@ -10996,6 +11054,299 @@ function createClientRunPort(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/imageBatchStore.ts
+var istText4 = (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) => istText4(b.media_ref) && typeof b.position === "number").map((b) => ({
+    media_ref: b.media_ref,
+    position: b.position,
+    ...istText4(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 || !istText4(payload.item_id) || !istText4(payload.prompt_run_id) || !istText4(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: istText4(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
+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/flowViewPort.ts
 var defaultContext = {
   async chainFor(contextId) {
@@ -11043,8 +11394,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;
 }
 
@@ -11172,7 +11551,7 @@ var PFLICHTFELDER = [
   "system_prompt",
   "created_at"
 ];
-function istText4(wert) {
+function istText5(wert) {
   return typeof wert === "string" && wert.trim().length > 0;
 }
 function isObject10(wert) {
@@ -11186,7 +11565,7 @@ function pruefeLaufherkunft(quelle) {
   }
   if (quelle.kind === "published") {
     for (const feld of VERSIONSFELDER) {
-      if (!istText4(quelle[feld])) {
+      if (!istText5(quelle[feld])) {
         return { ok: false, message: `"source.${feld}" fehlt oder ist leer.` };
       }
     }
@@ -11198,7 +11577,7 @@ function pruefeLaufherkunft(quelle) {
       message: `"source.kind" ist unbekannt: ${JSON.stringify(quelle.kind)}. Erlaubt: published, draft_chain.`
     };
   }
-  if (!istText4(quelle.chain_id)) {
+  if (!istText5(quelle.chain_id)) {
     return { ok: false, message: '"source.chain_id" fehlt oder ist leer.' };
   }
   if (!Array.isArray(quelle.nodes) || quelle.nodes.length === 0) {
@@ -11217,7 +11596,7 @@ function pruefeLaufherkunft(quelle) {
         message: `"source.nodes[${index}].type" ist unbekannt: ${JSON.stringify(knoten.type)}.`
       };
     }
-    if (!istText4(knoten.element_id) || !istText4(knoten.draft_id)) {
+    if (!istText5(knoten.element_id) || !istText5(knoten.draft_id)) {
       return {
         ok: false,
         message: `"source.nodes[${index}]" braucht element_id und draft_id.`
@@ -11230,10 +11609,10 @@ function pruefeLaufherkunft(quelle) {
       };
     }
   }
-  if (quelle.derivation_run_id !== void 0 && !istText4(quelle.derivation_run_id)) {
+  if (quelle.derivation_run_id !== void 0 && !istText5(quelle.derivation_run_id)) {
     return { ok: false, message: '"source.derivation_run_id" ist gesetzt, aber leer.' };
   }
-  if (quelle.derivation_recovery_id !== void 0 && !istText4(quelle.derivation_recovery_id)) {
+  if (quelle.derivation_recovery_id !== void 0 && !istText5(quelle.derivation_recovery_id)) {
     return { ok: false, message: '"source.derivation_recovery_id" ist gesetzt, aber leer.' };
   }
   return { ok: true };
@@ -11254,13 +11633,13 @@ function checkPromptRunRecord(candidate) {
   }
   const pflicht = ausKette ? PFLICHTFELDER.filter((f) => !VERSIONSFELDER.includes(f)) : PFLICHTFELDER;
   for (const feld of pflicht) {
-    if (!istText4(record[feld])) {
+    if (!istText5(record[feld])) {
       return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
     }
   }
   if (ausKette) {
     for (const feld of VERSIONSFELDER) {
-      if (istText4(record[feld])) {
+      if (istText5(record[feld])) {
         return {
           ok: false,
           message: `"${feld}" ist bei einem Lauf aus einer Draft-Kette gesetzt. Dort gibt es keine Versionen, und erfundene sind unzulaessig (D-98).`
@@ -11298,7 +11677,7 @@ function checkPromptRunRecord(candidate) {
         message: `"failure.class" ist unbekannt: ${JSON.stringify(failure.class)}. Erlaubt sind ${FAILURE_CLASSES.join(", ")}.`
       };
     }
-    if (!istText4(failure.message)) {
+    if (!istText5(failure.message)) {
       return { ok: false, message: '"failure.message" fehlt oder ist leer.' };
     }
     return { ok: true };
@@ -11340,7 +11719,7 @@ function checkSceneDerivationRecord(candidate) {
   }
   const record = candidate;
   for (const feld of DERIVATION_PFLICHTFELDER) {
-    if (!istText4(record[feld])) {
+    if (!istText5(record[feld])) {
       return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
     }
   }
@@ -11395,13 +11774,13 @@ function checkSceneDerivationRecord(candidate) {
       return { ok: false, message: '"follows" muss ein Objekt sein.' };
     }
     const f = folgt;
-    if (!istText4(f.run_id)) {
+    if (!istText5(f.run_id)) {
       return { ok: false, message: '"follows.run_id" fehlt oder ist leer.' };
     }
     if (f.run_id === record.run_id) {
       return { ok: false, message: '"follows.run_id" zeigt auf den Lauf selbst.' };
     }
-    if (!istText4(f.note)) {
+    if (!istText5(f.note)) {
       return {
         ok: false,
         message: '"follows.note" fehlt oder ist leer \u2014 ohne Beanstandung ist ein Folgelauf nicht nachvollziehbar (D-89).'
@@ -11415,7 +11794,7 @@ function checkSceneDerivationRecord(candidate) {
     }
   }
   const reply = record.reply;
-  if (reply !== void 0 && !istText4(reply)) {
+  if (reply !== void 0 && !istText5(reply)) {
     return {
       ok: false,
       message: `"reply" ist unbrauchbar: erwartet wird eine nicht leere Zeichenkette, angekommen ist ${JSON.stringify(reply)}. Ohne "reply" einreichen ist zulaessig.`
@@ -11435,7 +11814,7 @@ function checkSceneDerivationRecord(candidate) {
         message: `"failure.class" ist unbekannt: ${JSON.stringify(failure.class)}. Erlaubt sind ${FAILURE_CLASSES.join(", ")}.`
       };
     }
-    if (!istText4(failure.message)) {
+    if (!istText5(failure.message)) {
       return { ok: false, message: '"failure.message" fehlt oder ist leer.' };
     }
     if (Array.isArray(record.proposals) && record.proposals.length > 0) {
@@ -11490,7 +11869,7 @@ function checkSceneDerivationRecord(candidate) {
         };
       }
       for (const [gapIndex, luecke] of gaps.entries()) {
-        if (!luecke || typeof luecke !== "object" || !istText4(luecke.pointer) || !istText4(luecke.reason)) {
+        if (!luecke || typeof luecke !== "object" || !istText5(luecke.pointer) || !istText5(luecke.reason)) {
           return {
             ok: false,
             message: `"proposals[${index}].gaps[${gapIndex}]" braucht pointer und reason.`
@@ -11516,7 +11895,7 @@ function checkSceneDerivationRecoveryRecord(candidate) {
   }
   const record = candidate;
   for (const feld of ["recovery_id", "run_id", "created_at"]) {
-    if (!istText4(record[feld])) {
+    if (!istText5(record[feld])) {
       return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
     }
   }
@@ -11543,7 +11922,7 @@ function checkSceneDerivationRecoveryRecord(candidate) {
     return { ok: false, message: '"diagnostics" muss ein Array sein (auch ein leeres).' };
   }
   for (const [index, befund] of record.diagnostics.entries()) {
-    if (!befund || typeof befund !== "object" || !istText4(befund.code) || !istText4(befund.message)) {
+    if (!befund || typeof befund !== "object" || !istText5(befund.code) || !istText5(befund.message)) {
       return {
         ok: false,
         message: `"diagnostics[${index}]" braucht code und message.`
@@ -11595,7 +11974,7 @@ function checkSceneDerivationRecoveryRecord(candidate) {
     }
     if (Array.isArray(gaps)) {
       for (const [gapIndex, luecke] of gaps.entries()) {
-        if (!luecke || typeof luecke !== "object" || !istText4(luecke.pointer) || !istText4(luecke.reason)) {
+        if (!luecke || typeof luecke !== "object" || !istText5(luecke.pointer) || !istText5(luecke.reason)) {
           return {
             ok: false,
             message: `"proposals[${index}].gaps[${gapIndex}]" braucht pointer und reason.`
@@ -11692,13 +12071,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}`)
@@ -12204,7 +12583,7 @@ var ERKLAERUNG = {
 };
 var CapabilityPanel = ({ port, elementId, setupPayload }) => {
   const [bericht, setBericht] = (0, import_react4.useState)(null);
-  const [fehler3, setFehler] = (0, import_react4.useState)(null);
+  const [fehler4, setFehler] = (0, import_react4.useState)(null);
   (0, import_react4.useEffect)(() => {
     let abgemeldet = false;
     setBericht(null);
@@ -12226,10 +12605,10 @@ var CapabilityPanel = ({ port, elementId, setupPayload }) => {
       abgemeldet = true;
     };
   }, [port, elementId, setupPayload]);
-  if (fehler3) {
+  if (fehler4) {
     return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("p", { "data-testid": "capability-fehler", role: "alert", children: [
       "F\xE4higkeitsbericht nicht erstellbar: ",
-      fehler3
+      fehler4
     ] });
   }
   if (!bericht) return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { "data-testid": "capability-laden", children: "F\xE4higkeitsbericht wird erstellt \u2026" });
@@ -12731,10 +13110,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);
@@ -14542,6 +14921,7 @@ var SzenenView = ({
   ContractViolation,
   DERIVABLE_TYPES,
   ELEMENT_VERSION_SCHEMA_FILE,
+  FLOW_MODEL_DISPLAY_NAMES,
   PROBE_VERSION_ID,
   REFERENCE_FIELD,
   RULES_WITHOUT_CAPABILITY_EFFECT,
@@ -14561,6 +14941,7 @@ var SzenenView = ({
   VersionDagError,
   areasFor,
   assessDerivationResponse,
+  batchesForPromptRun,
   buildDerivationSystemInstruction,
   buildDerivationUserPrompt,
   buildSystemInstruction,
@@ -14593,6 +14974,7 @@ var SzenenView = ({
   checkSzenenBatchOrigin,
   checkTitle,
   checkWriteDraftInput,
+  collectImageBatches,
   collectImageGenerationOrders,
   collectPromptRuns,
   collectProviderChecks,
@@ -14606,10 +14988,14 @@ var SzenenView = ({
   createEventLogDerivationPersistence,
   createEventLogRunPersistence,
   createFakeTextGenerationPort,
+  createFlowImageProvider,
   createFlowSzenenViewPort,
   createFlowTextGenerationPort,
   createHfElementStore,
   createHfEventChannel,
+  createHfImageBatchHistory,
+  createHfImageBatchWrite,
+  createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
   createImageGenerationPort,
   createInMemoryEventChannel,
@@ -14623,12 +15009,14 @@ var SzenenView = ({
   differentialSteps,
   draftRevisionOf,
   elementStoreContractChecks,
+  findImageBatch,
   findImageGenerationOrder,
   findPromptRun,
   findProviderCheck,
   findSceneDerivation,
   findSceneDerivationRecovery,
   firstError,
+  flowImageProviderHasAccess,
   formatSchemaErrors,
   freezeDraftChain,
   getSzenenSchemas,