@rslsp1/fa-app-tools 2.0.85 → 2.0.87

package/dist/index.js

@@ -260,13 +260,19 @@ var init_project = __esm({
 });
 
 // src/lib/hfEventTypes.ts
-var HF_BASE, HF_REPO, CURRENT_EVENT_VERSION;
+function bildEndungFuer(mimeType) {
+  if (mimeType === "image/png") return "png";
+  if (mimeType === "image/webp") return "webp";
+  return "jpg";
+}
+var HF_BASE, HF_REPO, CURRENT_EVENT_VERSION, SPEICHERBARE_BILDTYPEN;
 var init_hfEventTypes = __esm({
   "src/lib/hfEventTypes.ts"() {
     "use strict";
     HF_BASE = "https://huggingface.co";
     HF_REPO = "RolandSch/fa-app-state";
     CURRENT_EVENT_VERSION = { major: 1, minor: 0 };
+    SPEICHERBARE_BILDTYPEN = ["image/png", "image/jpeg", "image/webp"];
   }
 });
 
@@ -297,8 +303,8 @@ async function mitGeduld(anfrage) {
     letzte = res;
     if (versuch === DROSSEL_VERSUCHE - 1) break;
     const angesagt = Number(res.headers.get("retry-after"));
-    const warten = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
-    await schlafen(warten);
+    const warten2 = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
+    await schlafen(warten2);
   }
   return letzte;
 }
@@ -631,7 +637,7 @@ async function hfLoadMetadata(token) {
   }
 }
 async function hfUploadImage(base64, id, token, mimeType = "image/jpeg") {
-  const ext = mimeType === "image/png" ? "png" : "jpg";
+  const ext = bildEndungFuer(mimeType);
   const binary = atob(base64);
   const bytes = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
@@ -673,7 +679,7 @@ async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeTy
     const result2 = await fetchBase64(`images/${filename}`);
     return result2 === "ABORT" ? null : result2;
   }
-  const ext = mimeType === "image/png" ? "png" : "jpg";
+  const ext = bildEndungFuer(mimeType);
   const result = await fetchBase64(`images/${id}.${ext}`);
   return result === "ABORT" ? null : result;
 }
@@ -801,7 +807,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "2.0.85";
+var version = "2.0.87";
 
 // src/hooks/useOnClickOutside.ts
 var import_react = require("react");
@@ -12007,8 +12013,8 @@ var BestandsBild = ({ port, mediaRef }) => {
 };
 var BatchBild = ({ port, bild }) => {
   const [phase] = usePortQuery(
-    () => port.imageLibrary ? port.imageLibrary.resolveImage(bild.media_ref) : Promise.resolve({ kind: "ok", value: null }),
-    [port, bild.media_ref]
+    () => port.imageLibrary ? port.imageLibrary.resolveImage(bild.media_ref, bild.mime_type ?? null) : Promise.resolve({ kind: "ok", value: null }),
+    [port, bild.media_ref, bild.mime_type]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)("li", { "data-testid": `batchbild-${bild.media_ref}`, children: [
     phase.status === "ready" && phase.value && /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
@@ -17438,9 +17444,117 @@ function createClientRunPort(options) {
   };
 }
 
-// src/lib/szenen/hfImageLibrary.ts
+// src/lib/szenen/hfImageStore.ts
 init_hfStateService();
 init_hfEventLog();
+init_hfEventTypes();
+var LEERER_BESTAND = {
+  metadata: [],
+  tags: { by_category: {}, all: [] },
+  meta: { consolidatedAt: 0, version: 1 }
+};
+var endungFuer = bildEndungFuer;
+function bildPfad(id, mimeType) {
+  return `images/${id}.${endungFuer(mimeType)}`;
+}
+function typAusBytes(base64, vorgabe = "image/png") {
+  const kopf = base64.slice(0, 16);
+  if (kopf.startsWith("iVBORw0KGgo")) return "image/png";
+  if (kopf.startsWith("/9j/")) return "image/jpeg";
+  if (kopf.startsWith("UklGR")) return "image/webp";
+  if (kopf.startsWith("R0lGOD")) return "image/gif";
+  return vorgabe;
+}
+var warten = (ms) => new Promise((r) => setTimeout(r, ms));
+function createHfImageStore(options) {
+  const { namespace, token } = options;
+  const now = options.now ?? (() => Date.now());
+  const versuche = options.leseVersuche ?? 4;
+  const basisMs = options.leseBasisMs ?? 400;
+  const schlafen2 = options.schlafen ?? warten;
+  const abgelegt = /* @__PURE__ */ new Map();
+  const bekanntePfade = /* @__PURE__ */ new Set();
+  let gefalteterBestand = null;
+  let laufenderAbgleich = null;
+  async function bestandLesen() {
+    const grundlage = gefalteterBestand ?? await loadHFState(namespace, token) ?? LEERER_BESTAND;
+    const neue = await loadPendingEvents(
+      namespace,
+      token,
+      grundlage.meta.consolidatedAt,
+      bekanntePfade
+    );
+    const danach = neue.filter((e) => e.ts > grundlage.meta.consolidatedAt);
+    gefalteterBestand = danach.length ? applyEvents(grundlage, danach) : grundlage;
+    return gefalteterBestand;
+  }
+  function bestandAbgleichen() {
+    if (!laufenderAbgleich) {
+      laufenderAbgleich = bestandLesen().finally(() => {
+        laufenderAbgleich = null;
+      });
+    }
+    return laufenderAbgleich;
+  }
+  return {
+    bestand: bestandAbgleichen,
+    async putWithId(id, base64, mimeType, titel) {
+      const echterTyp = typAusBytes(base64, mimeType);
+      if (!SPEICHERBARE_BILDTYPEN.includes(echterTyp)) {
+        throw new Error(
+          `Das Bild ${id} ist ${echterTyp}; der Bildbestand kann nur ${SPEICHERBARE_BILDTYPEN.join(", ")} wahrheitsgemaess ablegen. Es wurde nichts geschrieben.`
+        );
+      }
+      await hfUploadImage(base64, id, token, echterTyp);
+      await writeHFEvent(namespace, token, "image_added", {
+        id,
+        prompt: titel ?? id,
+        tags: [],
+        timestamp: now(),
+        mimeType: echterTyp
+      }, []);
+      abgelegt.set(id, { data: base64, mimeType: echterTyp });
+    },
+    async resolve(id, mimeType) {
+      const eben = abgelegt.get(id);
+      if (eben) return eben;
+      const zustand = await bestandAbgleichen();
+      const eintrag = zustand.metadata.find((e) => e.id === id);
+      const typ = eintrag?.mimeType || mimeType || null;
+      if (eintrag) {
+        const base64 = await hfLoadImageAsBase64(
+          id,
+          token,
+          void 0,
+          eintrag.filename,
+          void 0,
+          eintrag.mimeType,
+          false
+        );
+        if (base64) return { data: base64, mimeType: eintrag.mimeType || "image/jpeg" };
+      }
+      const pfadTyp = typ ?? "image/png";
+      for (let versuch = 0; versuch < versuche; versuch += 1) {
+        if (versuch > 0) await schlafen2(basisMs * 2 ** (versuch - 1));
+        const base64 = await hfLoadImageAsBase64(
+          id,
+          token,
+          void 0,
+          void 0,
+          void 0,
+          pfadTyp,
+          false
+        );
+        if (base64) return { data: base64, mimeType: pfadTyp };
+      }
+      throw new Error(
+        `Das Bild ${id} ist auf HF nicht auffindbar. Geprueft: ${bildPfad(id, pfadTyp)} in ${versuche} Versuchen` + (eintrag ? " (im Bestand verzeichnet, aber nicht ladbar)." : " (nicht im Bestand verzeichnet).")
+      );
+    }
+  };
+}
+
+// src/lib/szenen/hfImageLibrary.ts
 function fehler2(nachricht, retryable = false) {
   return { kind: "error", message: nachricht, retryable };
 }
@@ -17455,14 +17569,16 @@ function alsBild(eintrag) {
   };
 }
 function createHfImageLibrary(options) {
-  const { namespace, token } = options;
   const newImageId = options.newImageId ?? (() => crypto.randomUUID());
-  const now = options.now ?? (() => Date.now());
-  const frisch = /* @__PURE__ */ new Map();
+  const store = options.store ?? createHfImageStore({
+    namespace: options.namespace,
+    token: options.token,
+    ...options.now ? { now: options.now } : {}
+  });
   return {
     async listImages(query) {
       try {
-        const zustand = await loadHFState(namespace, token);
+        const zustand = await store.bestand();
         const eintraege = zustand?.metadata ?? [];
         const gesucht = query?.search?.trim().toLowerCase();
         const gefiltert = gesucht ? eintraege.filter((e) => (e.prompt ?? "").toLowerCase().includes(gesucht) || e.id.toLowerCase().includes(gesucht)) : eintraege;
@@ -17476,54 +17592,18 @@ function createHfImageLibrary(options) {
         );
       }
     },
-    async resolveImage(mediaRef) {
-      const eben = frisch.get(mediaRef);
-      if (eben) return { kind: "ok", value: { data: eben.data, mime_type: eben.mimeType } };
+    async resolveImage(mediaRef, mimeTypeHinweis) {
       try {
-        const zustand = await loadHFState(namespace, token);
-        const eintrag = (zustand?.metadata ?? []).find((e) => e.id === mediaRef);
-        if (eintrag) {
-          const base64 = await hfLoadImageAsBase64(
-            mediaRef,
-            token,
-            void 0,
-            eintrag.filename,
-            void 0,
-            eintrag.mimeType,
-            false
-          );
-          if (!base64) {
-            return fehler2(`Das Bild ${mediaRef} ist im Bestand verzeichnet, aber nicht ladbar.`, true);
-          }
-          return { kind: "ok", value: { data: base64, mime_type: eintrag.mimeType || "image/jpeg" } };
-        }
-        for (const mimeType of ["image/png", "image/jpeg"]) {
-          const base64 = await hfLoadImageAsBase64(mediaRef, token, void 0, void 0, void 0, mimeType, false);
-          if (base64) return { kind: "ok", value: { data: base64, mime_type: mimeType } };
-        }
-        return fehler2(
-          `Das Bild ${mediaRef} steht nicht im Bestand. Moeglicherweise hat der Abgleich es noch nicht uebertragen.`,
-          true
-        );
+        const bild = await store.resolve(mediaRef, mimeTypeHinweis);
+        return { kind: "ok", value: { data: bild.data, mime_type: bild.mimeType } };
       } catch (error) {
-        return fehler2(
-          `Das Bild ${mediaRef} konnte nicht geladen werden: ${error instanceof Error ? error.message : String(error)}`,
-          true
-        );
+        return fehler2(error instanceof Error ? error.message : String(error), true);
       }
     },
     async putImage(input) {
       const id = newImageId();
       try {
-        await hfUploadImage(input.data, id, token, input.mime_type);
-        await writeHFEvent(namespace, token, "image_added", {
-          id,
-          prompt: input.title,
-          tags: [],
-          timestamp: now(),
-          mimeType: input.mime_type
-        }, []);
-        frisch.set(id, { mimeType: input.mime_type, data: input.data });
+        await store.putWithId(id, input.data, input.mime_type, input.title);
         return {
           kind: "ok",
           value: { mediaRef: id, title: input.title, mimeType: input.mime_type, thumbUrl: null }
@@ -17650,6 +17730,11 @@ function alsBilder(rohe) {
     media_ref: b.media_ref,
     position: b.position,
     ...istText3(b.asset_id) ? { asset_id: b.asset_id } : {},
+    // Der bestätigte MIME-Typ (Review 2026-08-18 §5 P2) muss durch das
+    // Rücklesen hindurch: Genau hier braucht ihn der Lesepfad, um den
+    // Dateipfad `images/<id>.<ext>` zu bilden, statt ihn zu erraten. Nur
+    // gesetzt, wenn er im Ereignis steht — ältere Batches tragen ihn nicht.
+    ...istText3(b.mime_type) ? { mime_type: b.mime_type } : {},
     model: b.model ?? null,
     seed: b.seed ?? null,
     width: b.width ?? null,
@@ -17731,8 +17816,6 @@ function createHfImageBatchHistory(options) {
 }
 
 // src/lib/szenen/hfImageBatchPersistence.ts
-init_hfStateService();
-init_hfEventLog();
 function fehler3(nachricht, retryable = true) {
   return { kind: "error", message: nachricht, retryable };
 }
@@ -17740,6 +17823,7 @@ 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 store = options.store ?? createHfImageStore({ namespace, token });
   const itemId = itemIdForRun(input.runId);
   let vorhandeneEvents;
   try {
@@ -17758,15 +17842,14 @@ async function legeBatchAb(options, input) {
   for (let offset = 0; offset < input.images.length; offset++) {
     const bild = input.images[offset];
     const id = newImageId(input.generationBatchId, startPosition + offset);
+    const echterTyp = typAusBytes(bild.imageBase64, bild.mimeType);
     try {
-      await hfUploadImage(bild.imageBase64, id, token, bild.mimeType);
-      await writeHFEvent(namespace, token, "image_added", {
+      await store.putWithId(
         id,
-        prompt: input.title ?? `Batch ${input.generationBatchId}`,
-        tags: [],
-        timestamp: now().getTime(),
-        mimeType: bild.mimeType
-      }, []);
+        bild.imageBase64,
+        echterTyp,
+        input.title ?? `Batch ${input.generationBatchId}`
+      );
     } 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.`
@@ -17776,6 +17859,7 @@ async function legeBatchAb(options, input) {
       position: startPosition + offset,
       media_ref: id,
       asset_id: id,
+      mime_type: echterTyp,
       model: bild.model ?? null,
       seed: bild.seed ?? null,
       width: bild.width ?? null,
@@ -17819,8 +17903,11 @@ function createHfImageGenerationBatchPersistence(options) {
         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.
+          // `data:image/png;base64,${base64}`), und der gemeinsame Vertrag führt
+          // keinen MIME-Typ je Bild. Das ist deshalb nur die **Vorgabe**:
+          // Entschieden wird nach den echten Bytes (Review §5 P2) — ein künftig
+          // anders kodiertes Bild läge sonst unter einer Endung, unter der es
+          // niemand sucht.
           mimeType: "image/png",
           model: bild.model ?? null,
           seed: bild.seed ?? null,
@@ -17841,6 +17928,8 @@ function createHfImageBatchWrite(options) {
         title: input.title,
         images: input.images.map((bild) => ({
           imageBase64: bild.imageBase64,
+          // Vorgabe, kein Urteil — der Import bringt beliebig kodierte Bilder
+          // mit, und der Typ wird aus den Bytes bestimmt (Review §5 P2).
           mimeType: "image/png",
           model: bild.model ?? null,
           seed: bild.seed ?? null,
@@ -18129,7 +18218,17 @@ function createFlowSzenenViewPort(options) {
     ...options.newRunId ? { newRunId: options.newRunId } : {},
     ...options.now ? { now: options.now } : {}
   });
-  const imageLibrary = options.imageLibrary ?? (options.namespace?.trim() && options.token?.trim() ? createHfImageLibrary({ namespace: options.namespace, token: options.token }) : void 0);
+  const hatHfZugangsdaten = Boolean(options.namespace?.trim() && options.token?.trim());
+  const bildSpeicher = hatHfZugangsdaten ? createHfImageStore({
+    namespace: options.namespace,
+    token: options.token,
+    ...options.now ? { now: () => options.now().getTime() } : {}
+  }) : void 0;
+  const imageLibrary = options.imageLibrary ?? (bildSpeicher ? createHfImageLibrary({
+    namespace: options.namespace,
+    token: options.token,
+    store: bildSpeicher
+  }) : void 0);
   const derivation = createClientDerivationPort({
     store: elements,
     derivations: createEventLogDerivationPersistence(channel),
@@ -18139,11 +18238,11 @@ function createFlowSzenenViewPort(options) {
     ...options.now ? { now: options.now } : {}
   });
   const imageBatchHistory = createHfImageBatchHistory({ channel });
-  const hatHfZugangsdaten = Boolean(options.namespace?.trim() && options.token?.trim());
-  const imageBatchWrite = hatHfZugangsdaten ? createHfImageBatchWrite({
+  const imageBatchWrite = bildSpeicher ? createHfImageBatchWrite({
     namespace: options.namespace,
     token: options.token,
     channel,
+    store: bildSpeicher,
     ...options.newBatchImageId ? { newImageId: options.newBatchImageId } : {},
     ...options.now ? { now: options.now } : {}
   }) : void 0;
@@ -18157,6 +18256,9 @@ function createFlowSzenenViewPort(options) {
       namespace: options.namespace,
       token: options.token,
       channel,
+      // Dieselbe Instanz wie der Bildbestand — sonst wäre das gerade
+      // erzeugte Bild in der Laufansicht wieder unauffindbar (R1).
+      store: bildSpeicher,
       ...options.newBatchImageId ? { newImageId: options.newBatchImageId } : {},
       ...options.now ? { now: options.now } : {}
     }),

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import {
   SzenenView,
+  applyEvents,
   createFlowSzenenViewPort
-} from "./chunk-MILMVOK7.mjs";
+} from "./chunk-ZVHEHQ7A.mjs";
 import "./chunk-FUY2OCVC.mjs";
 import {
   exportProjectToZip,
@@ -27,10 +28,10 @@ import {
   setHFToken,
   tsFromEventPath,
   writeHFEvent
-} from "./chunk-LFPOXNOZ.mjs";
+} from "./chunk-NBUS7AWR.mjs";
 
 // package.json
-var version = "2.0.85";
+var version = "2.0.87";
 
 // src/hooks/useOnClickOutside.ts
 import { useEffect } from "react";
@@ -2308,7 +2309,7 @@ var ProjectSyncTab = ({
           {
             onClick: async () => {
               try {
-                const { hfDownloadProject: hfDownloadProject2 } = await import("./hfStateService-PZH2IDKF.mjs");
+                const { hfDownloadProject: hfDownloadProject2 } = await import("./hfStateService-W7KO2FOH.mjs");
                 const file = await hfDownloadProject2(p.path, hfToken);
                 onHfLoad(file);
               } catch (e) {
@@ -2532,75 +2533,6 @@ function toPromptImages(images) {
 // src/hooks/useHFState.ts
 import { useState as useState11, useEffect as useEffect7, useRef as useRef8, useCallback } from "react";
 
-// src/lib/hfReducer.ts
-function applyEvent(state, event) {
-  if (event.v.major > 1) return state;
-  switch (event.type) {
-    // SPEZ: image_added (state/spez/hf-state.spez.yaml)
-    case "image_added": {
-      const p = event.payload;
-      if (state.metadata.some((m) => m.id === p.id)) return state;
-      return { ...state, metadata: [...state.metadata, p] };
-    }
-    // SPEZ: task_requested (global/spez/task-queue.spez.yaml)
-    case "task_requested": {
-      const p = event.payload;
-      if (p.expiresAt && p.expiresAt < event.ts) return state;
-      const openTasks = { ...state.openTasks || {} };
-      openTasks[p.taskId] = p;
-      return { ...state, openTasks };
-    }
-    // SPEZ: task_completed (global/spez/task-queue.spez.yaml)
-    case "task_completed": {
-      const p = event.payload;
-      if (!state.openTasks || !state.openTasks[p.taskId]) return state;
-      const openTasks = { ...state.openTasks };
-      delete openTasks[p.taskId];
-      return { ...state, openTasks };
-    }
-    // SPEZ: tag_upserted (state/spez/hf-state.spez.yaml) — Legacy, wird nicht mehr erzeugt
-    case "tag_upserted": {
-      const p = event.payload;
-      const tags = state.tags;
-      const cat = tags.by_category[p.category] || [];
-      const existing = cat.find((t) => t.value === p.value);
-      const updated = { label: p.label, value: p.value, is_user_created: p.is_user_created, is_deleted: p.is_deleted };
-      const newCat = existing ? cat.map((t) => t.value === p.value ? { ...t, ...updated } : t) : [...cat, updated];
-      const newAll = tags.all.some((t) => t.value === p.value && t.category === p.category) ? tags.all.map((t) => t.value === p.value && t.category === p.category ? { ...t, ...updated, category: p.category } : t) : [...tags.all, { ...updated, category: p.category }];
-      return { ...state, tags: { by_category: { ...tags.by_category, [p.category]: newCat }, all: newAll } };
-    }
-    // SPEZ: thumb_added (state/spez/hf-state.spez.yaml)
-    case "thumb_added": {
-      const p = event.payload;
-      return {
-        ...state,
-        metadata: state.metadata.map((m) => m.id === p.id ? { ...m, hasThumb: true } : m)
-      };
-    }
-    // SPEZ: metadata_updated (state/spez/hf-state.spez.yaml)
-    case "metadata_updated": {
-      const p = event.payload;
-      return {
-        ...state,
-        metadata: state.metadata.map((m) => m.id === p.id ? { ...m, ...p.delta } : m)
-      };
-    }
-    // SPEZ: title_set (state/spez/hf-state.spez.yaml)
-    case "title_set": {
-      const p = event.payload;
-      return {
-        ...state,
-        metadata: state.metadata.map((m) => m.id === p.id ? { ...m, titleTs: event.ts } : m)
-      };
-    }
-    default:
-      return state;
-  }
-}
-function applyEvents(state, events) {
-  return events.reduce(applyEvent, state);
-}
-
 // src/lib/hfDag.ts
 function buildDag(events) {
   const dag = /* @__PURE__ */ new Map();
@@ -6856,7 +6788,7 @@ function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onS
             onClick: async () => {
               setIsLoadingFromHF(true);
               try {
-                const { hfListProjects: hfListProjects2, hfDownloadProject: hfDownloadProject2 } = await import("./hfStateService-PZH2IDKF.mjs");
+                const { hfListProjects: hfListProjects2, hfDownloadProject: hfDownloadProject2 } = await import("./hfStateService-W7KO2FOH.mjs");
                 const projects = await hfListProjects2(hfToken);
                 if (projects.length > 0) {
                   const file = await hfDownloadProject2(projects[0].path, hfToken);