@rslsp1/fa-app-tools 2.0.85 → 2.0.86

package/dist/{chunk-MILMVOK7.mjs → chunk-DGFMONWO.mjs}

@@ -6468,8 +6468,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__ */ jsxs5("li", { "data-testid": `batchbild-${bild.media_ref}`, children: [
     phase.status === "ready" && phase.value && /* @__PURE__ */ jsx5(
@@ -11067,6 +11067,179 @@ function createClientRunPort(options) {
   };
 }
 
+// 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 schlafen = 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 schlafen(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 };
@@ -11082,14 +11255,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;
@@ -11103,54 +11278,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 }
@@ -11280,6 +11419,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,
@@ -11368,6 +11512,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 {
@@ -11386,15 +11531,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.`
@@ -11404,6 +11548,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,
@@ -11447,8 +11592,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,
@@ -11469,6 +11617,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,
@@ -11757,7 +11907,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),
@@ -11767,11 +11927,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;
@@ -11785,6 +11945,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 } : {}
     }),
@@ -11800,6 +11963,7 @@ function createFlowSzenenViewPort(options) {
 }
 
 export {
+  applyEvents,
   capabilitiesOf,
   unsupportedReason,
   callOptional,
@@ -11914,6 +12078,9 @@ export {
   runPromptDerivation,
   createEventLogRunPersistence,
   createClientRunPort,
+  bildPfad,
+  typAusBytes,
+  createHfImageStore,
   createHfImageLibrary,
   FLOW_MODEL_DISPLAY_NAMES,
   flowImageProviderHasAccess,

package/dist/hfEventTypes-C_PX6RFR.d.ts

@@ -0,0 +1,241 @@
+import { T as TextGenerationPort } from './contracts-DdYOMBl9.js';
+
+interface TagOption {
+    label: string;
+    value: string;
+    is_user_created?: boolean;
+    is_deleted?: boolean;
+}
+interface WorkspaceTags {
+    by_category: Record<string, TagOption[]>;
+    all: Array<TagOption & {
+        category: string;
+    }>;
+}
+interface Generation {
+    id: string;
+    nodeId: string;
+    base64?: string;
+    fullBase64?: string;
+    mediaId?: string;
+    prompt?: string;
+    hierarchy?: string;
+    seed?: number;
+    model?: string;
+    timestamp: number;
+    status: 'processing' | 'done' | 'error';
+    step?: string;
+    tags: string[];
+    type?: 'generation' | 'import';
+    error?: {
+        message: string;
+        details?: string;
+    };
+    selectedForExport?: boolean;
+    filename?: string;
+    hasThumb?: boolean;
+    mimeType?: string;
+    titleTs?: number;
+}
+interface ProjectSettings {
+    aspectRatio: string;
+    selectedModel: string;
+    seed: number;
+    seedMode: 'random' | 'fixed';
+}
+interface ProjectMeta {
+    id: string;
+    name: string;
+    saved_at: string;
+    size: number;
+}
+interface SyncDiff {
+    localOnly: Generation[];
+    serverOnly: Generation[];
+}
+interface LabFrame {
+    id: string;
+    base64: string;
+    mediaId?: string;
+    seed?: number;
+    model?: string;
+    aspectRatio?: string;
+    width?: number;
+    height?: number;
+    source?: 'generated' | 'flow-gallery' | 'zip-import' | 'db-library';
+}
+interface LabItem {
+    id: string;
+    prompt: string;
+    label?: string;
+    tags?: string[];
+    frames: LabFrame[];
+}
+interface SelectedLabImage {
+    item: LabItem;
+    frame: LabFrame;
+    label: string;
+    roleForPrompt?: string;
+    roleForImage?: string;
+    sendToPromptAI: boolean;
+    sendToImageGen: boolean;
+}
+interface LabServices {
+    availableItems: LabItem[];
+    recentItems: LabItem[];
+    onItemUsed: (item: LabItem) => void;
+    generateText: (text: string, options?: {
+        images?: {
+            base64: string;
+            mimeType: string;
+        }[];
+        systemInstruction?: string;
+    }) => Promise<string>;
+    generateImage: (options: Record<string, any>) => Promise<{
+        base64: string;
+        mediaId?: string;
+    }>;
+    saveResult?: (item: LabItem) => Promise<void>;
+    workspaceTags?: WorkspaceTags;
+}
+interface HFMetadataEntry {
+    id: string;
+    prompt?: string;
+    seed?: number;
+    model?: string;
+    tags: string[];
+    timestamp: number;
+    mimeType: string;
+    size?: number;
+    filename?: string;
+    hasThumb?: boolean;
+    titleTs?: number;
+}
+
+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;
+
+interface HFEventVersion {
+    major: number;
+    minor: number;
+}
+interface HFEvent<P = unknown> {
+    v: HFEventVersion;
+    type: string;
+    ts: number;
+    prevTs: number[];
+    clientId: string;
+    payload: P;
+}
+interface HFStateMeta {
+    consolidatedAt: number;
+    version: number;
+}
+interface HFStateSnapshot {
+    metadata: HFMetadataEntry[];
+    tags: WorkspaceTags;
+    meta: HFStateMeta;
+    openTasks?: Record<string, TaskRequestedPayload>;
+}
+interface HFFileInfo {
+    type: 'file' | 'directory';
+    path: string;
+    size: number;
+}
+interface ImageAddedPayload extends HFMetadataEntry {
+    taskId?: string;
+}
+interface TagUpsertedPayload {
+    category: string;
+    label: string;
+    value: string;
+    is_user_created?: boolean;
+    is_deleted?: boolean;
+}
+interface MetadataUpdatedPayload {
+    id: string;
+    delta: Partial<HFMetadataEntry>;
+}
+interface TaskRequestedPayload {
+    taskId: string;
+    taskType: string;
+    params: {
+        prompt: string;
+        tags?: string[];
+        book?: string;
+        kapitel?: string;
+        ankerId?: string;
+        promptVersion?: number;
+        [key: string]: any;
+    };
+    expiresAt?: number;
+}
+
+export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type Generation as G, type HFEvent as H, type ImageAddedPayload as I, type LabFrame as L, type MetadataUpdatedPayload as M, type ProjectMeta as P, type SelectedLabImage as S, type TagOption as T, type WorkspaceTags as W, type FlowSdk as a, type FlowTextGenerationOptions as b, type HFEventVersion as c, type HFFileInfo as d, type HFMetadataEntry as e, type HFStateMeta as f, type HFStateSnapshot as g, type LabItem as h, type LabServices as i, type ProjectSettings as j, type SelectedTag as k, type SyncDiff as l, type TagUpsertedPayload as m, buildFallbackPrompt as n, buildGenerationPrompt as o, buildImageGenerationOptions as p, buildPromptTabPayload as q, cleanAiResponse as r, createFlowServices as s, createFlowTextGenerationPort as t, interpretSdkError as u, parsePromptResponse as v };