@rslsp1/fa-app-tools 2.0.81 → 2.0.83

package/dist/index.js

@@ -786,7 +786,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "2.0.81";
+var version = "2.0.83";
 
 // src/hooks/useOnClickOutside.ts
 var import_react = require("react");
@@ -3692,6 +3692,21 @@ function validateTagBaseSelection(base, userId, contextId) {
 // src/hooks/useTagBase.ts
 var USER_ID_KEY = "aa-user-id";
 var CONTEXT_ID_KEY = "aa-context-id";
+var IDENTITY_NAMESPACE_KEY = "aa-identity-namespace";
+function readStoredNamespace() {
+  try {
+    return localStorage.getItem(IDENTITY_NAMESPACE_KEY);
+  } catch {
+    return null;
+  }
+}
+function writeStoredNamespace(namespace) {
+  try {
+    if (namespace === null) localStorage.removeItem(IDENTITY_NAMESPACE_KEY);
+    else localStorage.setItem(IDENTITY_NAMESPACE_KEY, namespace);
+  } catch {
+  }
+}
 function readStoredId(key) {
   try {
     const v = localStorage.getItem(key);
@@ -3728,6 +3743,16 @@ function useTagBase(token, namespace) {
   }, [selectedContextId]);
   const load = (0, import_react19.useCallback)(async () => {
     if (!token || !namespace) return;
+    if (readStoredNamespace() !== namespace) {
+      selectedUserIdRef.current = null;
+      selectedContextIdRef.current = null;
+      setSelectedUserId(null);
+      setSelectedContextId(null);
+      writeStoredId(USER_ID_KEY, null);
+      writeStoredId(CONTEXT_ID_KEY, null);
+      writeStoredNamespace(namespace);
+      setPickerMessage(null);
+    }
     setIsLoading(true);
     setError(null);
     try {
@@ -3766,16 +3791,19 @@ function useTagBase(token, namespace) {
     setSelectedContextId(null);
     writeStoredId(USER_ID_KEY, userId);
     writeStoredId(CONTEXT_ID_KEY, null);
-  }, []);
+    writeStoredNamespace(namespace);
+  }, [namespace]);
   const selectContext = (0, import_react19.useCallback)((contextId) => {
     setSelectedContextId(contextId);
     writeStoredId(CONTEXT_ID_KEY, contextId);
-  }, []);
+    writeStoredNamespace(namespace);
+  }, [namespace]);
   const resetSelection = (0, import_react19.useCallback)(() => {
     setSelectedUserId(null);
     setSelectedContextId(null);
     writeStoredId(USER_ID_KEY, null);
     writeStoredId(CONTEXT_ID_KEY, null);
+    writeStoredNamespace(null);
     setPickerMessage(null);
   }, []);
   const validation = tagBase ? validateTagBaseSelection(tagBase, selectedUserId, selectedContextId) : { valid: false, reason: null };
@@ -6565,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}`)
@@ -11266,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);
@@ -11288,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" });
@@ -11401,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;
 }
@@ -11502,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) => {
@@ -12151,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);
@@ -17464,6 +17519,531 @@ function createHfImageLibrary(options) {
   };
 }
 
+// src/lib/szenen/flowImageProvider.ts
+var FLOW_MODEL_DISPLAY_NAMES = {
+  "imagen-4.0-generate-001": "Imagen 4"
+};
+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
+  }
+};
+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) {
@@ -17511,11 +18091,90 @@ 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;
 }
 
+// src/lib/flowBootstrapTarget.ts
+var PROD_NAMESPACE = "app.art-by-rolands.de/";
+var DEV_NAMESPACE = "dev-app.art-by-rolands.de/";
+var SELECTABLE_NAMESPACES = [PROD_NAMESPACE, DEV_NAMESPACE];
+var DEFAULT_NAMESPACE = PROD_NAMESPACE;
+function environmentForNamespace(namespace) {
+  if (!namespace) return null;
+  if (namespace === DEV_NAMESPACE) return "dev";
+  if (namespace === PROD_NAMESPACE) return "prod";
+  return null;
+}
+function normalizeSelectableNamespace(namespace) {
+  return namespace && SELECTABLE_NAMESPACES.includes(namespace) ? namespace : DEFAULT_NAMESPACE;
+}
+function resolveBootstrapTarget(input) {
+  const { hostNamespace, serverNamespace, isProbingServer = false } = input;
+  if (hostNamespace) {
+    return {
+      source: "host",
+      phase: "ready",
+      ready: true,
+      namespace: hostNamespace,
+      environment: environmentForNamespace(hostNamespace)
+    };
+  }
+  if (serverNamespace) {
+    return {
+      source: "server",
+      phase: "ready",
+      ready: true,
+      namespace: serverNamespace,
+      environment: environmentForNamespace(serverNamespace)
+    };
+  }
+  if (isProbingServer) {
+    return { source: "server", phase: "probing", ready: false, namespace: null, environment: null };
+  }
+  const { selectedNamespace, isStartDialogOpen = false } = input;
+  if (isStartDialogOpen) {
+    return { source: "dialog", phase: "awaiting-choice", ready: false, namespace: null, environment: null };
+  }
+  const namespace = normalizeSelectableNamespace(selectedNamespace);
+  return {
+    source: "dialog",
+    phase: "ready",
+    ready: true,
+    namespace,
+    environment: environmentForNamespace(namespace)
+  };
+}
+
 // src/components/AvatarArchitectApp.tsx
 var import_jsx_runtime45 = require("react/jsx-runtime");
 function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onSelectMedia, buildInfo, initialHfToken, hfNamespace, allowDevNamespace, requireWorkspaceSelection = false, serverBaseUrl, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete }) {
@@ -17542,31 +18201,38 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
   const [hfTokenInput, setHfTokenInput] = (0, import_react47.useState)(initialHfToken || "");
   const [isLoadingFromHF, setIsLoadingFromHF] = (0, import_react47.useState)(false);
   const [hfNamespaceLocal, setHfNamespaceLocal] = (0, import_react47.useState)(() => {
-    const KNOWN = ["app.art-by-rolands.de/", "dev-app.art-by-rolands.de/"];
-    const DEFAULT = "app.art-by-rolands.de/";
     try {
-      const stored = localStorage.getItem("aa-hf-namespace");
-      if (stored && KNOWN.includes(stored)) return stored;
-      localStorage.setItem("aa-hf-namespace", DEFAULT);
-      return DEFAULT;
+      return normalizeSelectableNamespace(localStorage.getItem("aa-hf-namespace"));
     } catch {
-      return DEFAULT;
+      return DEFAULT_NAMESPACE;
     }
   });
   const [hfNamespaceFromServer, setHfNamespaceFromServer] = (0, import_react47.useState)(null);
+  const [serverProbeFailed, setServerProbeFailed] = (0, import_react47.useState)(false);
   (0, import_react47.useEffect)(() => {
     if (hfNamespace !== void 0 || !serverBaseUrl) return;
     fetch(`${serverBaseUrl}/api/status`).then((r) => r.json()).then((d) => {
       if (typeof d.hfNamespace === "string" && d.hfNamespace) setHfNamespaceFromServer(d.hfNamespace);
-    }).catch(() => {
-    });
+      else setServerProbeFailed(true);
+    }).catch(() => setServerProbeFailed(true));
   }, [hfNamespace, serverBaseUrl]);
-  const effectiveNamespace = hfNamespace ?? hfNamespaceFromServer ?? hfNamespaceLocal;
-  const szenenPort = (0, import_react47.useMemo)(() => hfToken ? createFlowSzenenViewPort({
+  const [targetConfirmed, setTargetConfirmed] = (0, import_react47.useState)(false);
+  const isDialogTarget = hfNamespace === void 0 && hfNamespaceFromServer === null && (!serverBaseUrl || serverProbeFailed);
+  const isProbingServer = hfNamespace === void 0 && !!serverBaseUrl && hfNamespaceFromServer === null && !serverProbeFailed;
+  const bootstrapTarget = resolveBootstrapTarget({
+    hostNamespace: hfNamespace,
+    serverNamespace: hfNamespaceFromServer,
+    isProbingServer,
+    selectedNamespace: hfNamespaceLocal,
+    isStartDialogOpen: isDialogTarget && !targetConfirmed
+  });
+  const effectiveNamespace = bootstrapTarget.namespace ?? "";
+  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,
@@ -17640,6 +18306,7 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
     } catch {
     }
     setLayoutChoice(choice);
+    setTargetConfirmed(true);
     setShowStart(false);
   };
   const [nodes, setNodes] = (0, import_react47.useState)([{ id: "1", type: "custom", position: { x: 0, y: 0 }, data: { label: "Fine Art Project", placeholder: "Name..." } }]);
@@ -18401,45 +19068,6 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
     const all = Object.entries(merged).flatMap(([cat, tags]) => tags.map((t) => ({ ...t, category: cat })));
     return { by_category: merged, all };
   };
-  if (requireWorkspaceSelection) {
-    if (!hfToken) {
-      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("section", { className: "flow-workspace-picker__card", role: "alert", children: "HF-Token fehlt \u2014 User und Context koennen nicht aus der Tag-Base geladen werden." }) });
-    }
-    if (tagBaseResult.isLoading) {
-      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("section", { className: "flow-workspace-picker__card", children: [
-        "Lade User und Contexts aus ",
-        effectiveNamespace,
-        "\u2026"
-      ] }) });
-    }
-    if (tagBaseResult.error) {
-      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("section", { className: "flow-workspace-picker__card", role: "alert", children: [
-        "Tag-Base ",
-        effectiveNamespace,
-        " konnte nicht geladen werden: ",
-        tagBaseResult.error
-      ] }) });
-    }
-    if (!tagBaseResult.tagBase) {
-      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("section", { className: "flow-workspace-picker__card", role: "alert", children: [
-        "Im Namespace ",
-        effectiveNamespace,
-        " fehlt tags-state-*.zip. Der Server muss zuerst die Tag-Base erzeugen."
-      ] }) });
-    }
-    if (tagBaseResult.needsPicker) {
-      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(
-        FlowWorkspacePicker,
-        {
-          tagBase: tagBaseResult.tagBase,
-          selectedUserId: tagBaseResult.selectedUserId,
-          message: tagBaseResult.pickerMessage,
-          onSelectUser: tagBaseResult.selectUser,
-          onSelectContext: tagBaseResult.selectContext
-        }
-      );
-    }
-  }
   if (isFullscreen && currentResult?.base64) {
     const fsRaw = currentResult.fullBase64 || currentResult.base64;
     const fsBase64 = fsRaw.startsWith("data:") ? fsRaw : `data:image/png;base64,${fsRaw}`;
@@ -18583,7 +19211,7 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
             }
           )
         ] }),
-        !hfNamespace && /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("div", { className: "flex items-center gap-3 w-full", children: [
+        isDialogTarget && /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("div", { className: "flex items-center gap-3 w-full", children: [
           /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("span", { className: "text-white/25 text-[10px] uppercase tracking-widest font-bold flex-shrink-0", children: "State:" }),
           ["app.art-by-rolands.de/", "dev-app.art-by-rolands.de/"].map((ns, i) => /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(
             "button",
@@ -18668,7 +19296,7 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
           "button",
           {
             type: "button",
-            disabled: !szenenPort,
+            disabled: !szenenPort || !bootstrapTarget.ready,
             onClick: () => setShowSzenen(true),
             children: [
               /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("span", { className: "material-symbols-outlined", children: "movie" }),
@@ -18703,6 +19331,48 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
       ] })
     ] });
   }
+  if (requireWorkspaceSelection) {
+    if (!bootstrapTarget.ready) {
+      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("section", { className: "flow-workspace-picker__card", children: "Zielraum wird bestimmt\u2026" }) });
+    }
+    if (!hfToken) {
+      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("section", { className: "flow-workspace-picker__card", role: "alert", children: "HF-Token fehlt \u2014 User und Context koennen nicht aus der Tag-Base geladen werden." }) });
+    }
+    if (tagBaseResult.isLoading) {
+      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("section", { className: "flow-workspace-picker__card", children: [
+        "Lade User und Contexts aus ",
+        effectiveNamespace,
+        "\u2026"
+      ] }) });
+    }
+    if (tagBaseResult.error) {
+      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("section", { className: "flow-workspace-picker__card", role: "alert", children: [
+        "Tag-Base ",
+        effectiveNamespace,
+        " konnte nicht geladen werden: ",
+        tagBaseResult.error
+      ] }) });
+    }
+    if (!tagBaseResult.tagBase) {
+      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)("main", { className: "flow-workspace-picker", children: /* @__PURE__ */ (0, import_jsx_runtime45.jsxs)("section", { className: "flow-workspace-picker__card", role: "alert", children: [
+        "Im Namespace ",
+        effectiveNamespace,
+        " fehlt tags-state-*.zip. Der Server muss zuerst die Tag-Base erzeugen."
+      ] }) });
+    }
+    if (tagBaseResult.needsPicker) {
+      return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(
+        FlowWorkspacePicker,
+        {
+          tagBase: tagBaseResult.tagBase,
+          selectedUserId: tagBaseResult.selectedUserId,
+          message: tagBaseResult.pickerMessage,
+          onSelectUser: tagBaseResult.selectUser,
+          onSelectContext: tagBaseResult.selectContext
+        }
+      );
+    }
+  }
   if (layoutChoice === "mobile" || layoutChoice === "mobile-desktop") {
     const mdMode = layoutChoice === "mobile-desktop";
     const mdScale = mdMode ? window.innerWidth / 430 : 1;