@rslsp1/fa-app-tools 2.0.84 → 2.0.86

package/dist/szenen.js

@@ -59,6 +59,7 @@ __export(szenen_exports, {
   areasFor: () => areasFor,
   assessDerivationResponse: () => assessDerivationResponse,
   batchesForPromptRun: () => batchesForPromptRun,
+  bildPfad: () => bildPfad,
   buildDerivationSystemInstruction: () => buildSystemInstruction2,
   buildDerivationUserPrompt: () => buildUserPrompt2,
   buildSystemInstruction: () => buildSystemInstruction,
@@ -114,6 +115,7 @@ __export(szenen_exports, {
   createHfImageBatchWrite: () => createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence: () => createHfImageGenerationBatchPersistence,
   createHfImageLibrary: () => createHfImageLibrary,
+  createHfImageStore: () => createHfImageStore,
   createImageGenerationPort: () => createImageGenerationPort,
   createInMemoryEventChannel: () => createInMemoryEventChannel,
   createMemoryViewPort: () => createMemoryViewPort,
@@ -172,6 +174,7 @@ __export(szenen_exports, {
   showChain: () => showChain,
   simulatedAnswerFor: () => simulatedAnswerFor,
   totalModelCalls: () => totalModelCalls,
+  typAusBytes: () => typAusBytes,
   unclassifiedPublishRules: () => unclassifiedPublishRules,
   unsupportedReason: () => unsupportedReason,
   validateAgainst: () => validateAgainst,
@@ -7572,6 +7575,21 @@ function treeUrl(namespace, subdir = "") {
 var DROSSEL_VERSUCHE = 4;
 var DROSSEL_BASIS_MS = 400;
 var schlafen = (ms) => new Promise((r) => setTimeout(r, ms));
+var HF_LESE_ZEITLIMIT_MS = 2e4;
+async function holeMitZeitlimit(url, init) {
+  const abbruch = new AbortController();
+  const timer = setTimeout(() => abbruch.abort(), HF_LESE_ZEITLIMIT_MS);
+  try {
+    return await fetch(url, { ...init, signal: abbruch.signal });
+  } catch (error) {
+    if (abbruch.signal.aborted) {
+      throw new Error(`HF-Anfrage ohne Antwort nach ${HF_LESE_ZEITLIMIT_MS}ms abgebrochen: ${url}`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function mitGeduld(anfrage) {
   let letzte = null;
   for (let versuch = 0; versuch < DROSSEL_VERSUCHE; versuch += 1) {
@@ -7580,13 +7598,13 @@ 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;
 }
 async function hfListDir(namespace, subdir, token) {
-  const res = await mitGeduld(() => fetch(treeUrl(namespace, subdir), {
+  const res = await mitGeduld(() => holeMitZeitlimit(treeUrl(namespace, subdir), {
     headers: { Authorization: `Bearer ${token}` }
   }));
   if (res.status === 404) return [];
@@ -7594,7 +7612,7 @@ async function hfListDir(namespace, subdir, token) {
   return res.json();
 }
 async function hfDownloadJsonByPath(repoPath, token) {
-  const res = await mitGeduld(() => fetch(
+  const res = await mitGeduld(() => holeMitZeitlimit(
     `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
     { headers: { Authorization: `Bearer ${token}` } }
   ));
@@ -7602,7 +7620,7 @@ async function hfDownloadJsonByPath(repoPath, token) {
   return res.json();
 }
 async function hfDownloadBinaryByPath(repoPath, token) {
-  const res = await mitGeduld(() => fetch(
+  const res = await mitGeduld(() => holeMitZeitlimit(
     `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
     { headers: { Authorization: `Bearer ${token}` } }
   ));
@@ -9337,6 +9355,179 @@ async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeTy
   return result === "ABORT" ? null : result;
 }
 
+// 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/szenen/hfImageStore.ts
+var LEERER_BESTAND = {
+  metadata: [],
+  tags: { by_category: {}, all: [] },
+  meta: { consolidatedAt: 0, version: 1 }
+};
+function endungFuer(mimeType) {
+  return mimeType === "image/png" ? "png" : "jpg";
+}
+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);
+      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 fehler(nachricht, retryable = false) {
   return { kind: "error", message: nachricht, retryable };
@@ -9352,14 +9543,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;
@@ -9373,50 +9566,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) {
-          return fehler(
-            `Das Bild ${mediaRef} steht nicht im Bestand. Moeglicherweise hat der Abgleich es noch nicht uebertragen.`,
-            true
-          );
-        }
-        const base64 = await hfLoadImageAsBase64(
-          mediaRef,
-          token,
-          void 0,
-          eintrag.filename,
-          void 0,
-          eintrag.mimeType,
-          false
-        );
-        if (!base64) {
-          return fehler(`Das Bild ${mediaRef} ist im Bestand verzeichnet, aber nicht ladbar.`, true);
-        }
-        return { kind: "ok", value: { data: base64, mime_type: eintrag.mimeType || "image/jpeg" } };
+        const bild = await store.resolve(mediaRef, mimeTypeHinweis);
+        return { kind: "ok", value: { data: bild.data, mime_type: bild.mimeType } };
       } catch (error) {
-        return fehler(
-          `Das Bild ${mediaRef} konnte nicht geladen werden: ${error instanceof Error ? error.message : String(error)}`,
-          true
-        );
+        return fehler(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 }
@@ -11123,6 +11284,11 @@ function alsBilder(rohe) {
     media_ref: b.media_ref,
     position: b.position,
     ...istText4(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.
+    ...istText4(b.mime_type) ? { mime_type: b.mime_type } : {},
     model: b.model ?? null,
     seed: b.seed ?? null,
     width: b.width ?? null,
@@ -11211,6 +11377,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 {
@@ -11229,15 +11396,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.`
@@ -11247,6 +11413,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,
@@ -11290,8 +11457,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,
@@ -11312,6 +11482,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,
@@ -11385,7 +11557,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),
@@ -11395,11 +11577,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;
@@ -11413,6 +11595,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 } : {}
     }),
@@ -12896,8 +13081,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_runtime5.jsxs)("li", { "data-testid": `batchbild-${bild.media_ref}`, children: [
     phase.status === "ready" && phase.value && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
@@ -14942,6 +15127,7 @@ var SzenenView = ({
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildDerivationSystemInstruction,
   buildDerivationUserPrompt,
   buildSystemInstruction,
@@ -14997,6 +15183,7 @@ var SzenenView = ({
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createInMemoryEventChannel,
   createMemoryViewPort,
@@ -15055,6 +15242,7 @@ var SzenenView = ({
   showChain,
   simulatedAnswerFor,
   totalModelCalls,
+  typAusBytes,
   unclassifiedPublishRules,
   unsupportedReason,
   validateAgainst,

package/dist/szenen.mjs

@@ -26,6 +26,7 @@ import {
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildSystemInstruction,
   buildSystemInstruction2,
   buildUserPrompt,
@@ -75,6 +76,7 @@ import {
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createSimulationSceneDerivationPort,
   createSimulationTextGenerationPort,
@@ -123,6 +125,7 @@ import {
   scopeOfPath,
   showChain,
   simulatedAnswerFor,
+  typAusBytes,
   unclassifiedPublishRules,
   unsupportedReason,
   validateAgainst,
@@ -130,7 +133,7 @@ import {
   validateElementVersion,
   validatePayload,
   withReference
-} from "./chunk-4FOEFCKM.mjs";
+} from "./chunk-DGFMONWO.mjs";
 import {
   ContractViolation,
   STYLE_PAYLOAD,
@@ -144,7 +147,7 @@ import {
   preferredVersionId,
   resolvePreferredHead
 } from "./chunk-FUY2OCVC.mjs";
-import "./chunk-VBWQP7PO.mjs";
+import "./chunk-LFPOXNOZ.mjs";
 
 // src/lib/szenen/providerCheckStore.ts
 function collectProviderChecks(events) {
@@ -1477,6 +1480,7 @@ export {
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildSystemInstruction as buildDerivationSystemInstruction,
   buildUserPrompt as buildDerivationUserPrompt,
   buildSystemInstruction2 as buildSystemInstruction,
@@ -1532,6 +1536,7 @@ export {
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createInMemoryEventChannel,
   createMemoryViewPort,
@@ -1590,6 +1595,7 @@ export {
   showChain,
   simulatedAnswerFor,
   totalModelCalls,
+  typAusBytes,
   unclassifiedPublishRules,
   unsupportedReason,
   validateAgainst,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rslsp1/fa-app-tools",
-  "version": "2.0.84",
+  "version": "2.0.86",
   "description": "Shared tools and hooks for Fine Art flow apps",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/dist/flowTextGenerationPort-CeDUFutP.d.mts

@@ -1,73 +0,0 @@
-import { T as TextGenerationPort } from './contracts-DdYOMBl9.mjs';
-
-declare function buildGenerationPrompt(hierarchyText: string, mode?: 'literal' | 'creative'): string;
-declare function buildFallbackPrompt(hierarchyText: string): string;
-declare function cleanAiResponse(text: string): string;
-declare function buildImageGenerationOptions(prompt: string, aspectRatio: string, model: string, referenceMediaId?: string): Record<string, any>;
-interface SelectedTag {
-    label: string;
-    value: string;
-    category: string;
-}
-declare function buildPromptTabPayload(selectedTags: SelectedTag[], instructions: string, rules: string, treeText?: string): string;
-declare function parsePromptResponse(raw: string): {
-    prompt: string;
-    feedback: string | null;
-};
-interface FlowSdkImage {
-    base64: string;
-    mimeType: string;
-}
-interface FlowTextGenerationOptions {
-    images?: FlowSdkImage[];
-    systemInstruction?: string;
-    responseFormat?: 'text' | 'json';
-    thinkingLevel?: 'low' | 'medium' | 'high';
-}
-interface FlowSdk {
-    generate: {
-        image: (options: Record<string, any>) => Promise<{
-            base64: string;
-            mediaId: string;
-        }>;
-        text: (prompt: string, options?: {
-            systemInstruction?: string;
-            thinkingLevel?: string;
-            images?: FlowSdkImage[];
-        }) => Promise<{
-            text: string;
-        }>;
-    };
-    download: (args: {
-        base64: string;
-        mimeType: string;
-        filename: string;
-    }) => Promise<void>;
-    media: {
-        selectMultiple: (args: {
-            filter: string;
-        }) => Promise<any[]>;
-    };
-}
-declare function createFlowServices(Flow: FlowSdk): {
-    generateImage: (options: Record<string, any>) => Promise<{
-        base64: string;
-        mediaId: string;
-    }>;
-    generateText: (text: string, options?: FlowTextGenerationOptions) => Promise<string>;
-};
-declare function interpretSdkError(err: any): Error;
-
-type FlowGenerateText = (prompt: string, options?: FlowTextGenerationOptions) => Promise<string>;
-interface CreateFlowTextGenerationPortOptions {
-    provider?: string;
-    modelId?: string;
-}
-/**
- * Adapts the existing Flow SDK service to the host-neutral Szenen contract.
- * It deliberately does not parse or validate the response: that happens once
- * in `runPromptDerivation`, identically for every host.
- */
-declare function createFlowTextGenerationPort(generateText: FlowGenerateText, options?: CreateFlowTextGenerationPortOptions): TextGenerationPort;
-
-export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type SelectedTag as S, type FlowSdk as a, type FlowTextGenerationOptions as b, buildFallbackPrompt as c, buildGenerationPrompt as d, buildImageGenerationOptions as e, buildPromptTabPayload as f, cleanAiResponse as g, createFlowServices as h, createFlowTextGenerationPort as i, interpretSdkError as j, parsePromptResponse as p };