@rslsp1/fa-app-tools 2.0.73 → 2.0.81

package/dist/index.d.ts

@@ -1,6 +1,12 @@
 import * as React from 'react';
 import React__default, { RefObject, ReactNode } from 'react';
+import { F as FlowGenerateText, b as FlowTextGenerationOptions, S as SelectedTag } from './flowTextGenerationPort-KHjCGt_S.js';
+export { a as FlowSdk, c as buildFallbackPrompt, d as buildGenerationPrompt, e as buildImageGenerationOptions, f as buildPromptTabPayload, g as cleanAiResponse, h as createFlowServices, j as interpretSdkError, p as parsePromptResponse } from './flowTextGenerationPort-KHjCGt_S.js';
 import { Node, Edge } from '@xyflow/react';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { F as FeatureSliceId, b as SliceContract, a as PersistenceDescriptor, W as WorkspacePersistence, P as PersistedSlice, L as LoadResult, f as WriteResult, e as WorkspaceTabId, C as CommandResult, R as RequestContext, Q as QueryResult } from './contracts-DdYOMBl9.js';
+
+var version = "2.0.81";
 
 declare function useOnClickOutside(ref: RefObject<HTMLElement | null>, handler: (e: MouseEvent | TouchEvent) => void): void;
 
@@ -130,7 +136,7 @@ declare const getFormattedTimestamp: () => string;
 /**
  * Hilfskonstante für CSS-Styles (Dark Scrollbar etc.)
  */
-declare const GLOBAL_STYLES = "\n  .dark-scrollbar::-webkit-scrollbar { width: 4px; height: 4px; }\n  .dark-scrollbar::-webkit-scrollbar-track { background: transparent; }\n  .dark-scrollbar::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.1); border-radius: 10px; }\n  html, body, #root { margin: 0; padding: 0; width: 100%; height: 100%; background: #0e0e0e; font-family: 'Google Sans Text', sans-serif; overflow: hidden; }\n  @keyframes prompt-shimmer { 0% { background-position: -200% 0; } 100% { background-position: 200% 0; } }\n  .prompt-loading { background: linear-gradient(90deg, rgba(255,255,255,0.02) 25%, rgba(255,255,255,0.05) 50%, rgba(255,255,255,0.02) 75%); background-size: 200% 100%; animation: prompt-shimmer 2s infinite linear; }\n  @keyframes dropdown-enter { from { opacity: 0; transform: scale(0.95) translateY(-5px); } to { opacity: 1; transform: scale(1) translateY(0); } }\n  .animate-dropdown { animation: dropdown-enter 0.1s ease-out forwards; }\n";
+declare const GLOBAL_STYLES: string;
 
 declare function injectXMPMetadata(base64: string, prompt: string, seed?: number, model?: string, id?: string, tags?: string[], hierarchy?: string): string;
 
@@ -142,61 +148,6 @@ declare function exportProjectToZip(nodes: any[], edges: any[], history: any[],
 }>;
 declare function importProjectFromZip(file: File): Promise<any>;
 
-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 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?: {
-        images?: FlowSdkImage[];
-        systemInstruction?: string;
-    }) => Promise<string>;
-};
-declare function interpretSdkError(err: any): Error;
-
 interface ExtractedCharacter {
     name: string;
     prompts: {
@@ -265,6 +216,8 @@ interface TagBaseUser {
     id: number;
     username: string;
     active_context_id?: number;
+    /** Exakte Context-Zugriffe wie Context.listForUser (explizit + Eigentum). */
+    context_ids: number[];
 }
 interface TagBaseContext {
     id: number;
@@ -426,39 +379,29 @@ interface AvatarArchitectAppProps {
         base64: string;
         mediaId?: string;
     }>;
-    onGeneratePrompt: (text: string, options?: {
-        images?: {
-            base64: string;
-            mimeType: string;
-        }[];
-        systemInstruction?: string;
-    }) => Promise<string>;
+    onGeneratePrompt: FlowGenerateText;
     onDownload: (base64: string, mimeType: string, filename: string) => Promise<void>;
     onSelectMedia: () => Promise<MediaItem[]>;
     buildInfo?: string;
     initialHfToken?: string;
     hfNamespace?: string;
     allowDevNamespace?: boolean;
+    /** Flow-Host verlangt vor der App dieselbe User-/Context-Auswahl wie React. */
+    requireWorkspaceSelection?: boolean;
     serverBaseUrl?: string;
     onFetchServerProjects?: () => Promise<ProjectMeta[]>;
     onServerSave?: (zipBase64: string, name: string) => Promise<ProjectMeta>;
     onServerLoad?: (id: string) => Promise<File>;
     onServerDelete?: (id: string) => Promise<void>;
 }
-declare function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onSelectMedia, buildInfo, initialHfToken, hfNamespace, allowDevNamespace, serverBaseUrl, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete }: AvatarArchitectAppProps): React__default.JSX.Element;
+declare function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onSelectMedia, buildInfo, initialHfToken, hfNamespace, allowDevNamespace, requireWorkspaceSelection, serverBaseUrl, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete }: AvatarArchitectAppProps): React__default.JSX.Element;
 
 interface FaAppProps {
     onGenerateImage: (params: Record<string, any>) => Promise<{
         base64: string;
         mediaId?: string;
     }>;
-    onGeneratePrompt: (prompt: string, options?: {
-        images?: {
-            base64: string;
-            mimeType: string;
-        }[];
-        systemInstruction?: string;
-    }) => Promise<{
+    onGeneratePrompt: (prompt: string, options?: FlowTextGenerationOptions) => Promise<{
         text: string;
     }>;
     onGenerateVideo?: (params: Record<string, any>) => Promise<{
@@ -487,6 +430,20 @@ interface FaAppProps {
 }
 declare function FaApp({ onGenerateImage, onGeneratePrompt, onGenerateVideo: _onGenerateVideo, onDownload, onSelectMedia, onFlowSave: _onFlowSave, onFlowUpload: _onFlowUpload, onFlowMediaUpload: _onFlowMediaUpload, libToken, allowDevNamespace, serverBaseUrl, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete, buildInfo, }: FaAppProps): React.JSX.Element;
 
+interface FlowWorkspacePickerProps {
+    tagBase: TagBase;
+    selectedUserId: number | null;
+    message?: string | null;
+    onSelectUser: (userId: number) => void;
+    onSelectContext: (contextId: number) => void;
+}
+/**
+ * Flow-Einstieg wie in React: zuerst User, danach genau einer seiner Contexts.
+ * Die Zuordnung kommt aus der Server-generierten Tag-Base; die UI leitet
+ * weder Rechte aus owner_id ab noch zeigt sie pauschal alle Contexts.
+ */
+declare function FlowWorkspacePicker({ tagBase, selectedUserId, message, onSelectUser, onSelectContext, }: FlowWorkspacePickerProps): React.JSX.Element;
+
 interface CollapsibleCardProps {
     title: string;
     icon?: ReactNode;
@@ -563,6 +520,338 @@ interface TagManagerPanelProps {
 }
 declare function TagManagerPanel({ workspaceTags, onTagCreate, onTagUpdate, onTagDelete, onTagReorder, onTagMove }: TagManagerPanelProps): React__default.JSX.Element;
 
+type SaveState = 'idle' | 'saving' | 'restoring' | 'conflict';
+interface SliceMeta {
+    revision: number;
+    dirty: boolean;
+    saveState: SaveState;
+    conflict: PersistedSlice<unknown> | null;
+    loadRequestId: string | null;
+}
+interface FaStoreState {
+    workspaceId: string;
+    slices: Partial<Record<FeatureSliceId, unknown>>;
+    meta: Partial<Record<FeatureSliceId, SliceMeta>>;
+    loadSlice(sliceId: FeatureSliceId, signal?: AbortSignal, requestId?: string): Promise<LoadResult<unknown>>;
+    updateSlice<T>(sliceId: FeatureSliceId, updater: (current: T) => T): void;
+    saveSlice(sliceId: FeatureSliceId, signal?: AbortSignal): Promise<WriteResult<unknown>>;
+    resetSlice(sliceId: FeatureSliceId, signal?: AbortSignal, options?: {
+        confirmed?: boolean;
+    }): Promise<WriteResult<unknown>>;
+    acceptRemote(sliceId: FeatureSliceId): void;
+    overwriteRemote(sliceId: FeatureSliceId, signal?: AbortSignal): Promise<WriteResult<unknown>>;
+}
+interface CreateFaStoreOptions {
+    contracts: Partial<Record<FeatureSliceId, SliceContract<unknown>>>;
+    descriptors: Partial<Record<FeatureSliceId, PersistenceDescriptor>>;
+    persistence: WorkspacePersistence;
+    workspaceId: string;
+}
+type FaStore = ReturnType<typeof createFaStore>;
+declare function createFaStore({ contracts, descriptors, persistence, workspaceId }: CreateFaStoreOptions): zustand_vanilla.StoreApi<FaStoreState>;
+
+interface InMemoryWorkspacePersistence extends WorkspacePersistence {
+    /** Nur für Tests: rohen Persistenz-Eintrag lesen, ohne Kopie-Semantik zu brechen. */
+    peek(workspaceId: string, tabId: WorkspaceTabId): PersistedSlice<unknown> | undefined;
+}
+declare function createInMemoryWorkspacePersistence(now?: () => number): InMemoryWorkspacePersistence;
+
+declare function useFaSlice<T>(store: FaStore, sliceId: FeatureSliceId): T;
+declare function useFaSliceMeta(store: FaStore, sliceId: FeatureSliceId): SliceMeta | undefined;
+
+interface CreatePersistenceCoordinatorOptions {
+    store: FaStore;
+    /**
+     * Muss derselbe Adapter sein, der in den Store injiziert wurde. Der
+     * Coordinator ruft die Persistenz nicht direkt auf (alle IO-Aktionen
+     * laufen über die Store-Actions); der Parameter macht die Kopplung an
+     * der Konstruktionsstelle sichtbar und ist für spätere Direktzugriffe
+     * (z.B. Batch-Restore) reserviert.
+     */
+    persistence: WorkspacePersistence;
+    debounceMs?: number;
+    now?: () => number;
+    requestId?: () => string;
+}
+interface PersistenceCoordinator {
+    load(sliceId: FeatureSliceId): Promise<LoadResult<unknown>>;
+    scheduleSave(sliceId: FeatureSliceId): void;
+    flush(sliceId: FeatureSliceId): Promise<void>;
+    retry(sliceId: FeatureSliceId): Promise<void>;
+    dispose(): void;
+}
+declare function createPersistenceCoordinator({ store, debounceMs, requestId, }: CreatePersistenceCoordinatorOptions): PersistenceCoordinator;
+
+type LegacySourceResult<S> = {
+    kind: 'found';
+    value: S;
+    version: number;
+} | {
+    kind: 'notFound';
+};
+type LegacyMigrationResult = {
+    kind: 'migrated';
+} | {
+    kind: 'alreadyMigrated';
+} | {
+    kind: 'markedExistingTarget';
+} | {
+    kind: 'nothingToMigrate';
+} | {
+    kind: 'unsupportedVersion';
+    found: number;
+    supported: number[];
+};
+interface LegacyMigrationOptions<S, T> {
+    migrationId: string;
+    readSource(): Promise<LegacySourceResult<S>>;
+    transform(source: S, version: number): T;
+    writeTarget(value: T): Promise<void>;
+    readMarker(): Promise<boolean>;
+    writeMarker(): Promise<void>;
+    /** Optional: Ziel lesen, um teilweise erfolgte Läufe zu erkennen und das Ergebnis zu validieren. */
+    readTarget?(): Promise<T | undefined>;
+    /** Optional: wirft bei ungültigem Ziel; Default akzeptiert jeden Wert ungleich undefined. */
+    validateTarget?(value: unknown): T;
+    /** Zulässige Quellversionen; Default [1]. */
+    supportedVersions?: number[];
+}
+declare function runLegacyMigration<S, T>(options: LegacyMigrationOptions<S, T>): Promise<LegacyMigrationResult>;
+
+interface LibraryWorkspaceState {
+    filterTagIds: string[];
+    filterMode: 'and' | 'or';
+    selectedItemId: string | null;
+    galleryIndex: number;
+    /** Zuletzt umgeschaltete Filter-Tags (max 5, jüngster zuerst). */
+    recentFilterTagIds: string[];
+}
+declare const LIBRARY_SLICE_SCHEMA_VERSION = 1;
+declare function createLibraryDefault(): LibraryWorkspaceState;
+declare const libraryContract: SliceContract<LibraryWorkspaceState>;
+declare const libraryReactDescriptor: PersistenceDescriptor<'library'>;
+declare const LIBRARY_CUTOVER_MARKER = "cutover.library.v1";
+interface LibraryLegacySource {
+    /** Rohwert von localStorage 'libraryFilterTags' (JSON) oder null. */
+    filterTagsRaw: string | null;
+    /** Rohwert von localStorage 'libraryFilterMode' oder null. */
+    filterModeRaw: string | null;
+    /** Rohwert von localStorage 'fineart_recent_filters' (JSON) oder null. */
+    recentFiltersRaw?: string | null;
+}
+interface RunLibraryLegacyImportOptions {
+    readLocalStorage(key: string): string | null;
+    /** IDs/Labels der tatsächlich existierenden Tags — nur diese werden übernommen. */
+    knownTagIds: Set<string>;
+    readTarget(): Promise<LibraryWorkspaceState | undefined>;
+    writeTarget(value: LibraryWorkspaceState): Promise<void>;
+    readMarker(): Promise<boolean>;
+    writeMarker(): Promise<void>;
+}
+declare function parseLegacyLibraryFilters(source: LibraryLegacySource, knownTagIds: Set<string>): LibraryWorkspaceState | null;
+declare function runLibraryLegacyImport(options: RunLibraryLegacyImportOptions): Promise<LegacyMigrationResult>;
+
+interface LibraryViewTag {
+    label: string;
+    category?: string;
+    inherited?: boolean;
+}
+interface LibraryViewItem {
+    /** Stabile Host-Referenz (Library-ID bzw. Gruppen-Repräsentant). */
+    id: string;
+    title: string;
+    timestamp: number;
+    rating?: number;
+    notes?: string;
+    tags: LibraryViewTag[];
+    /** Fertige Thumb-Quelle (URL oder data:-URI); Auflösung ist Host-Sache. */
+    thumbUrl?: string | null;
+    /** Anzahl Bilder der Gruppe/Galerie (Badge ab 2). */
+    galleryCount?: number;
+}
+interface LibraryListQuery {
+    filterTagIds: string[];
+    filterMode: 'and' | 'or';
+    sortBy: 'rating' | 'timestamp' | 'title';
+    sortOrder: 'asc' | 'desc';
+    limit: number;
+}
+interface LibraryPage {
+    items: LibraryViewItem[];
+    /** Gesamtzahl nach Filter (für "weitere laden"). */
+    total: number;
+}
+interface LibraryDataSource {
+    listLibraryItems(query: LibraryListQuery, ctx: RequestContext): Promise<QueryResult<LibraryPage>>;
+}
+type LabSlotId = 'A' | 'B';
+/** Optionale Commands; jeder fehlende Key ist eine im Host nicht vorhandene Capability. */
+interface LibraryCommands {
+    deleteItem?: (item: LibraryViewItem) => Promise<CommandResult<void>>;
+    setCover?: (item: LibraryViewItem) => Promise<CommandResult<void>>;
+    assignToLab?: (slot: LabSlotId, item: LibraryViewItem) => Promise<CommandResult<void>>;
+    editMetadata?: (item: LibraryViewItem) => Promise<CommandResult<void>>;
+}
+type LibraryCommandName = keyof LibraryCommands;
+/**
+ * In-Memory-DataSource über bereits geladene Items: wendet Tag-Filter,
+ * Sortierung und Limit deterministisch an. Für Hosts, die ihre Items selbst
+ * beschaffen (React: Server-Fetch im Host; Flow: HF-Snapshot/Projekt).
+ */
+declare function createInMemoryLibraryDataSource(getItems: () => LibraryViewItem[]): LibraryDataSource;
+
+interface LibraryViewProps {
+    dataSource: LibraryDataSource;
+    query: LibraryListQuery;
+    onQueryChange: (next: LibraryListQuery) => void;
+    commands?: LibraryCommands;
+    onSelectItem?: (item: LibraryViewItem) => void;
+    selectedItemId?: string | null;
+    /** Aktuelle Lab-Slot-Belegung (Item-IDs) zur Markierung von A/B. */
+    labAssignments?: Partial<Record<LabSlotId, string>>;
+    layout?: 'list' | 'grid';
+    emptyText?: string;
+    /** Host-gerenderte Zusatzaktionen je Item (z.B. Flow-Referenzgenerierung). */
+    renderItemExtras?: (item: LibraryViewItem) => React__default.ReactNode;
+    /** Host-Datenversion: Änderung erzwingt Re-Query (z.B. nach Reload/Import). */
+    dataVersion?: number;
+    /** Schrittweite für "weitere laden" (Default 20). */
+    pageStep?: number;
+}
+declare const LibraryView: React__default.FC<LibraryViewProps>;
+
+/** Kanonischer flacher Tag (Server = Master; Flow-TagBase trägt dieselben Felder). */
+interface TagEntry {
+    id: string;
+    context_id: string | null;
+    category: string;
+    label: string;
+    value: string;
+    ord: number;
+    enabled: boolean;
+}
+/**
+ * Eingabeform für den Selector: flache Rows aus /api/v2/tags bzw. TagBase.
+ * `id` ist Pflicht (fehlend → Selector wirft); Zusatzfelder wie
+ * `is_inherited`/`context_name` reicht die Ableitung durch.
+ */
+interface TagEntryInput {
+    id?: string | number | null;
+    category?: string | null;
+    label?: string | null;
+    value?: string | null;
+    ord?: number;
+    enabled?: boolean;
+    is_inherited?: boolean;
+    context_name?: string;
+}
+interface TagViewOption {
+    /** Pflicht-ID (Entscheidung Nr. 4: Fail fast statt „Cannot move tag"). */
+    id: string;
+    l: string;
+    v: string;
+    /** Originale DB-Kategorie (mit Prefix) für Edit/Clone/Move. */
+    cat: string;
+    is_inherited?: boolean;
+    context_name?: string;
+}
+interface TagViewCategory {
+    title: string;
+    type: 'multi' | 'single';
+    options: TagViewOption[];
+}
+type TagViewScope = Record<string, TagViewCategory>;
+type TagViewModel = Record<string, TagViewScope>;
+interface TagQueries {
+    listTags(ctx: RequestContext): Promise<QueryResult<TagEntry[]>>;
+}
+interface TagUpdateDelta {
+    label?: string;
+    value?: string;
+    category?: string;
+    ord?: number;
+    enabled?: boolean;
+}
+/**
+ * Optionale Commands; fehlender Key = Capability im Host nicht vorhanden.
+ * React-Adapter schreibt `/api/v2/tags` (Master), Flow-Adapter schreibt
+ * Workspace-Tags bzw. Vorschlags-Events (Follower, HF_TAG_SYNC.md) — der
+ * Vertrag ist identisch, die Schreibwege liegen im jeweiligen Host.
+ */
+interface TagCommands {
+    createTag?: (input: {
+        category: string;
+        label: string;
+        value: string;
+    }) => Promise<CommandResult<void>>;
+    updateTag?: (id: string, delta: TagUpdateDelta) => Promise<CommandResult<void>>;
+    deleteTag?: (id: string) => Promise<CommandResult<void>>;
+    moveTag?: (id: string, targetCategory: string) => Promise<CommandResult<void>>;
+    reorderTags?: (category: string, orderedIds: string[]) => Promise<CommandResult<void>>;
+}
+type TagCommandName = keyof TagCommands;
+
+interface TagManagerSelection {
+    scopeKey: string | null;
+    categoryKey: string | null;
+}
+interface TagManagerProps {
+    tags: TagEntryInput[];
+    commands?: TagCommands;
+    /** Optional kontrollierte Auswahl (Host bindet sie an den tags-Slice). */
+    selection?: TagManagerSelection;
+    onSelectionChange?: (next: TagManagerSelection) => void;
+    emptyText?: string;
+    /**
+     * Wenn gesetzt, bietet das Create-Formular ein „Neue Kategorie"-Feld an;
+     * der Host bestimmt das DB-Kategorie-Format (React: `${scope}:${name}`).
+     */
+    newCategoryName?: (scopeKey: string, name: string) => string;
+    /** Diese Scopes sind immer als Tab wählbar, auch ohne vorhandene Tags. */
+    ensureScopes?: string[];
+}
+declare const TagManager: React__default.FC<TagManagerProps>;
+
+/** DB-Kategorien (Subkategorien) → App-Scopes. Nicht gemappte Kategorien sind selbst Scope. */
+declare const SCOPE_MAP: Record<string, string>;
+declare function deriveTagViewModel(tags: TagEntryInput[]): TagViewModel;
+/** Flache Kategorie-Liste eines View-Models (für Kategorie-Auswahl im Manager). */
+declare function listCategories(model: TagViewModel): {
+    scopeKey: string;
+    categoryKey: string;
+    title: string;
+    dbCategory: string | null;
+}[];
+
+interface TagsWorkspaceState {
+    /** Aktiver Scope-Tab im Manager (null = erster verfügbarer). */
+    selectedScopeKey: string | null;
+    /** Aktive Kategorie im Scope (null = erste verfügbare). */
+    selectedCategoryKey: string | null;
+    /** Zuletzt vergebene Tags als ID-Referenzliste (max 10, jüngste zuerst). */
+    recentAssignedTagIds: string[];
+}
+declare const TAGS_SLICE_SCHEMA_VERSION = 1;
+declare function createTagsDefault(): TagsWorkspaceState;
+declare const tagsContract: SliceContract<TagsWorkspaceState>;
+declare const tagsReactDescriptor: PersistenceDescriptor<'tags'>;
+declare const TAGS_CUTOVER_MARKER = "cutover.tags.v1";
+interface LegacyRecentTagRef {
+    label: string;
+    category: string | null;
+}
+declare function parseLegacyRecentTags(raw: string | null): LegacyRecentTagRef[];
+interface RunTagsLegacyImportOptions {
+    readLocalStorage(key: string): string | null;
+    /** Label(+Kategorie) → existierende Tag-ID; null = nicht auflösbar (fällt weg). */
+    resolveTagId(ref: LegacyRecentTagRef): string | null;
+    readTarget(): Promise<TagsWorkspaceState | undefined>;
+    writeTarget(value: TagsWorkspaceState): Promise<void>;
+    readMarker(): Promise<boolean>;
+    writeMarker(): Promise<void>;
+}
+declare function runTagsLegacyImport(options: RunTagsLegacyImportOptions): Promise<LegacyMigrationResult>;
+
 interface LabsTabProps {
     services: LabServices;
     onResult?: (item: LabItem) => void;
@@ -665,6 +954,7 @@ interface HFStateSnapshot {
     metadata: HFMetadataEntry[];
     tags: WorkspaceTags;
     meta: HFStateMeta;
+    openTasks?: Record<string, TaskRequestedPayload>;
 }
 interface HFFileInfo$1 {
     type: 'file' | 'directory';
@@ -672,6 +962,7 @@ interface HFFileInfo$1 {
     size: number;
 }
 interface ImageAddedPayload extends HFMetadataEntry {
+    taskId?: string;
 }
 interface TagUpsertedPayload {
     category: string;
@@ -684,16 +975,21 @@ interface MetadataUpdatedPayload {
     id: string;
     delta: Partial<HFMetadataEntry>;
 }
-
-declare function getHFToken(): string | null;
-declare function setHFToken(token: string): void;
-interface HFProjectMeta {
-    id: string;
-    name: string;
-    path: string;
-    size: number;
-    isLfs: boolean;
+interface TaskRequestedPayload {
+    taskId: string;
+    taskType: string;
+    params: {
+        prompt: string;
+        tags?: string[];
+        book?: string;
+        kapitel?: string;
+        ankerId?: string;
+        promptVersion?: number;
+        [key: string]: any;
+    };
+    expiresAt?: number;
 }
+
 interface HFFileInfo {
     type: 'file' | 'directory';
     path: string;
@@ -707,10 +1003,28 @@ declare function hfBatchArchive(moves: Array<{
     content: string;
 }>, token: string, summary: string): Promise<void>;
 declare function tsFromEventPath(repoPath: string): number;
-declare function loadHFState(namespace: string, token: string): Promise<HFStateSnapshot | null>;
 declare function loadPendingEvents(namespace: string, token: string, sinceTs: number, knownPaths?: Set<string>): Promise<HFEvent[]>;
 declare function getSessionClientId(): string;
-declare function writeHFEvent<P>(namespace: string, token: string, type: string, payload: P, prevTs: number[]): Promise<HFEvent<P>>;
+declare function writeHFEvent<P>(namespace: string, token: string, type: string, payload: P, prevTs: number[], options?: {
+    /**
+     * Schreibreihenfolge innerhalb einer Millisekunde erhalten.
+     *
+     * Vorgabe `false` — der Dateiname bleibt dann Byte für Byte der bisherige.
+     * Domains, für die die Logreihenfolge fachlich zählt, schalten es ein.
+     */
+    ordered?: boolean;
+}): Promise<HFEvent<P>>;
+
+declare function getHFToken(): string | null;
+declare function setHFToken(token: string): void;
+interface HFProjectMeta {
+    id: string;
+    name: string;
+    path: string;
+    size: number;
+    isLfs: boolean;
+}
+declare function loadHFState(namespace: string, token: string): Promise<HFStateSnapshot | null>;
 declare function hfBootstrapFromLegacy(namespace: string, token: string, onProgress?: (msg: string) => void): Promise<void>;
 declare function hfListProjects(token: string): Promise<HFProjectMeta[]>;
 declare function hfDownloadProject(path: string, token: string): Promise<File>;
@@ -743,23 +1057,6 @@ interface HFStateResult {
 }
 declare function useHFState(token: string, namespace: string): HFStateResult;
 
-declare function applyEvent(state: HFStateSnapshot, event: HFEvent): HFStateSnapshot;
-declare function applyEvents(state: HFStateSnapshot, events: HFEvent[]): HFStateSnapshot;
-
-interface DagNode {
-    event: HFEvent;
-    children: number[];
-}
-interface DagFork {
-    parentTs: number;
-    childTs: number[];
-}
-type Dag = Map<number, DagNode>;
-declare function buildDag(events: HFEvent[]): Dag;
-declare function findTips(dag: Dag): number[];
-declare function findForks(dag: Dag): DagFork[];
-declare function topoSort(events: HFEvent[]): HFEvent[];
-
 interface UseTagBaseResult {
     tagBase: TagBase | null;
     isLoading: boolean;
@@ -783,6 +1080,4 @@ interface UseTagBaseResult {
 }
 declare function useTagBase(token: string, namespace: string): UseTagBaseResult;
 
-declare const LIB_VERSION = "2.0.73";
-
-export { AvatarArchitectApp, type AvatarArchitectAppProps, CURRENT_TAG_EVENT_VERSION, CollapsibleCard, CompactDropdown, type DagFork, type ExtractedCharacter, FaApp, type FaAppProps, FaToolsBadge, type FlowSdk, GLOBAL_STYLES, type Generation, type HFEvent, type HFEventVersion, type HFFileInfo$1 as HFFileInfo, type HFMetadataEntry, type HFStateMeta, type HFStateResult, type HFStateSnapshot, HistoryPanel, type ImageAddedPayload, InspectPanel, LIB_VERSION, LabBlend, LabCompare, type LabFrame, LabFrameExtractor, type LabFrameExtractorProps, LabImagePicker, type LabItem, LabLoop, LabRemix, type LabServices, LabsTab, ListView, type MediaItem, MediaLibrary, type MetadataUpdatedPayload, PillButton, type ProjectMeta, type ProjectSettings, ProjectSyncTab, PromptTab, SectionLabel, type SelectedLabImage, type SelectedTag, type SelectionValidation, ServerTab, SetupPanel, type SyncDiff, type TagBase, type TagBaseContext, type TagBaseEvent, type TagBaseMeta, TagBaseSection, type TagBaseSectionProps, type TagBaseTagEntry, type TagBaseTagOption, type TagBaseUser, type TagBaseWorkspaceTags, type TagCreatedEvent, type TagCreatedPayload, TagManagerPanel, type TagOption, type TagUpdatedDelta, type TagUpdatedEvent, type TagUpdatedPayload, type TagUpsertedPayload, type UseTagBaseResult, type WorkspaceTags, applyEvent, applyEvents, autoLabel, buildBlendInstruction, buildCompareInstruction, buildDag, buildFallbackPrompt, buildGenerationPrompt, buildImageGenerationOptions, buildLoopInstruction, buildPromptTabPayload, buildReferenceImageMediaIds, buildRemixInstruction, buildScanInstruction, cleanAiResponse, createFlowServices, createTagCreatedEvent, createTagUpdatedEvent, deriveTagBaseWorkspaceTags, exportProjectToZip, findForks, findTips, formatTreeToMarkdown, frameToGeneration, getFormattedTimestamp, getHFToken, getSessionClientId, groupGenerationsToLabItems, hfBatchArchive, hfBootstrapFromLegacy, hfDeleteProject, hfDownloadProject, hfListDir, hfListProjects, hfLoadImageAsBase64, hfUploadImage, hfUploadProjectForm, hfUploadSmallFile, importProjectFromZip, injectXMPMetadata, interpretSdkError, loadHFState, loadPendingEvents, loadTagBase, parsePromptFile, parsePromptResponse, setHFToken, topoSort, tsFromEventPath, useHFState, useKeyboardNavigation, useOnClickOutside, useTagBase, validateTagBaseSelection, writeHFEvent, writeTagEvent };
+export { AvatarArchitectApp, type AvatarArchitectAppProps, CURRENT_TAG_EVENT_VERSION, CollapsibleCard, CommandResult, CompactDropdown, type CreateFaStoreOptions, type CreatePersistenceCoordinatorOptions, type ExtractedCharacter, FaApp, type FaAppProps, type FaStore, type FaStoreState, FaToolsBadge, FeatureSliceId, FlowTextGenerationOptions, FlowWorkspacePicker, type FlowWorkspacePickerProps, GLOBAL_STYLES, type Generation, type HFEvent, type HFEventVersion, type HFFileInfo$1 as HFFileInfo, type HFMetadataEntry, type HFStateMeta, type HFStateResult, type HFStateSnapshot, HistoryPanel, type ImageAddedPayload, type InMemoryWorkspacePersistence, InspectPanel, LIBRARY_CUTOVER_MARKER, LIBRARY_SLICE_SCHEMA_VERSION, version as LIB_VERSION, LabBlend, LabCompare, type LabFrame, LabFrameExtractor, type LabFrameExtractorProps, LabImagePicker, type LabItem, LabLoop, LabRemix, type LabServices, type LabSlotId, LabsTab, type LegacyMigrationOptions, type LegacyMigrationResult, type LegacyRecentTagRef, type LegacySourceResult, type LibraryCommandName, type LibraryCommands, type LibraryDataSource, type LibraryLegacySource, type LibraryListQuery, type LibraryPage, LibraryView, type LibraryViewItem, type LibraryViewProps, type LibraryViewTag, type LibraryWorkspaceState, ListView, LoadResult, type MediaItem, MediaLibrary, type MetadataUpdatedPayload, PersistedSlice, type PersistenceCoordinator, PersistenceDescriptor, PillButton, type ProjectMeta, type ProjectSettings, ProjectSyncTab, PromptTab, QueryResult, RequestContext, type RunLibraryLegacyImportOptions, type RunTagsLegacyImportOptions, SCOPE_MAP, type SaveState, SectionLabel, type SelectedLabImage, SelectedTag, type SelectionValidation, ServerTab, SetupPanel, SliceContract, type SliceMeta, type SyncDiff, TAGS_CUTOVER_MARKER, TAGS_SLICE_SCHEMA_VERSION, type TagBase, type TagBaseContext, type TagBaseEvent, type TagBaseMeta, TagBaseSection, type TagBaseSectionProps, type TagBaseTagEntry, type TagBaseTagOption, type TagBaseUser, type TagBaseWorkspaceTags, type TagCommandName, type TagCommands, type TagCreatedEvent, type TagCreatedPayload, type TagEntry, type TagEntryInput, TagManager, TagManagerPanel, type TagManagerProps, type TagManagerSelection, type TagOption, type TagQueries, type TagUpdateDelta, type TagUpdatedDelta, type TagUpdatedEvent, type TagUpdatedPayload, type TagUpsertedPayload, type TagViewCategory, type TagViewModel, type TagViewOption, type TagViewScope, type TagsWorkspaceState, type UseTagBaseResult, WorkspacePersistence, WorkspaceTabId, type WorkspaceTags, WriteResult, autoLabel, buildBlendInstruction, buildCompareInstruction, buildLoopInstruction, buildReferenceImageMediaIds, buildRemixInstruction, buildScanInstruction, createFaStore, createInMemoryLibraryDataSource, createInMemoryWorkspacePersistence, createLibraryDefault, createPersistenceCoordinator, createTagCreatedEvent, createTagUpdatedEvent, createTagsDefault, deriveTagBaseWorkspaceTags, deriveTagViewModel, exportProjectToZip, formatTreeToMarkdown, frameToGeneration, getFormattedTimestamp, getHFToken, getSessionClientId, groupGenerationsToLabItems, hfBatchArchive, hfBootstrapFromLegacy, hfDeleteProject, hfDownloadProject, hfListDir, hfListProjects, hfLoadImageAsBase64, hfUploadImage, hfUploadProjectForm, hfUploadSmallFile, importProjectFromZip, injectXMPMetadata, libraryContract, libraryReactDescriptor, listCategories, loadHFState, loadPendingEvents, loadTagBase, parseLegacyLibraryFilters, parseLegacyRecentTags, parsePromptFile, runLegacyMigration, runLibraryLegacyImport, runTagsLegacyImport, setHFToken, tagsContract, tagsReactDescriptor, tsFromEventPath, useFaSlice, useFaSliceMeta, useHFState, useKeyboardNavigation, useOnClickOutside, useTagBase, validateTagBaseSelection, writeHFEvent, writeTagEvent };