@rslsp1/fa-app-tools 2.0.85 → 2.0.87

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,
@@ -7563,6 +7566,12 @@ function createHfElementStore(options) {
 var HF_BASE = "https://huggingface.co";
 var HF_REPO = "RolandSch/fa-app-state";
 var CURRENT_EVENT_VERSION = { major: 1, minor: 0 };
+var SPEICHERBARE_BILDTYPEN = ["image/png", "image/jpeg", "image/webp"];
+function bildEndungFuer(mimeType) {
+  if (mimeType === "image/png") return "png";
+  if (mimeType === "image/webp") return "webp";
+  return "jpg";
+}
 
 // src/lib/hfEventLog.ts
 function treeUrl(namespace, subdir = "") {
@@ -7595,8 +7604,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;
 }
@@ -9305,7 +9314,7 @@ async function loadHFState(namespace, 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);
@@ -9347,11 +9356,187 @@ 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;
 }
 
+// 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 }
+};
+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 fehler(nachricht, retryable = false) {
   return { kind: "error", message: nachricht, retryable };
@@ -9367,14 +9552,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;
@@ -9388,54 +9575,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 fehler(`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 fehler(
-          `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 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 }
@@ -11142,6 +11293,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,
@@ -11230,6 +11386,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 {
@@ -11248,15 +11405,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.`
@@ -11266,6 +11422,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,
@@ -11309,8 +11466,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,
@@ -11331,6 +11491,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,
@@ -11404,7 +11566,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),
@@ -11414,11 +11586,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;
@@ -11432,6 +11604,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 } : {}
     }),
@@ -12915,8 +13090,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)(
@@ -14961,6 +15136,7 @@ var SzenenView = ({
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildDerivationSystemInstruction,
   buildDerivationUserPrompt,
   buildSystemInstruction,
@@ -15016,6 +15192,7 @@ var SzenenView = ({
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createInMemoryEventChannel,
   createMemoryViewPort,
@@ -15074,6 +15251,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-MILMVOK7.mjs";
+} from "./chunk-ZVHEHQ7A.mjs";
 import {
   ContractViolation,
   STYLE_PAYLOAD,
@@ -144,7 +147,7 @@ import {
   preferredVersionId,
   resolvePreferredHead
 } from "./chunk-FUY2OCVC.mjs";
-import "./chunk-LFPOXNOZ.mjs";
+import "./chunk-NBUS7AWR.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.85",
+  "version": "2.0.87",
   "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 };