@rslsp1/fa-app-tools 2.0.72 → 2.0.78

package/dist/{chunk-VVLKEBHL.mjs → chunk-BYD4RMYM.mjs}

@@ -100,20 +100,23 @@ function tsFromEventPath(repoPath) {
 }
 async function loadHFState(namespace, token) {
   const files = await hfListDir(namespace, "", token);
-  const stateFiles = files.filter((f) => f.type === "file" && /state-[\dT\-]+Z\.zip$/.test(f.path.split("/").pop() || "")).sort((a, b) => b.path.localeCompare(a.path));
+  const stateFiles = files.filter((f) => f.type === "file" && /^state-[\dT\-]+Z\.zip$/.test(f.path.split("/").pop() || "")).sort((a, b) => b.path.localeCompare(a.path));
   if (!stateFiles.length) return null;
   const zipBytes = await hfDownloadBinaryByPath(stateFiles[0].path, token);
   const zip = await JSZip.loadAsync(zipBytes);
-  const [metadataStr, tagsStr, metaStr] = await Promise.all([
+  const [metadataStr, tagsStr, metaStr, openTasksStr] = await Promise.all([
     zip.file("metadata.json")?.async("string"),
     zip.file("tags.json")?.async("string"),
-    zip.file("state_meta.json")?.async("string")
+    zip.file("state_meta.json")?.async("string"),
+    zip.file("open_tasks.json")?.async("string")
+    // optional — ältere Snapshots haben es nicht
   ]);
   if (!metadataStr || !tagsStr || !metaStr) throw new Error("state.zip: fehlende Pflicht-Dateien");
   return {
     metadata: JSON.parse(metadataStr),
     tags: JSON.parse(tagsStr),
-    meta: JSON.parse(metaStr)
+    meta: JSON.parse(metaStr),
+    openTasks: openTasksStr ? JSON.parse(openTasksStr) : {}
   };
 }
 async function loadPendingEvents(namespace, token, sinceTs, knownPaths) {

package/dist/{hfStateService-PHK6676C.mjs → hfStateService-JKEVTY66.mjs}

@@ -24,7 +24,7 @@ import {
   setHFToken,
   tsFromEventPath,
   writeHFEvent
-} from "./chunk-VVLKEBHL.mjs";
+} from "./chunk-BYD4RMYM.mjs";
 export {
   HF_TOKEN_KEY,
   getHFToken,

package/dist/index.d.mts

@@ -1,6 +1,9 @@
 import * as React from 'react';
 import React__default, { RefObject, ReactNode } from 'react';
 import { Node, Edge } from '@xyflow/react';
+import * as zustand_vanilla from 'zustand/vanilla';
+
+var version = "2.0.78";
 
 declare function useOnClickOutside(ref: RefObject<HTMLElement | null>, handler: (e: MouseEvent | TouchEvent) => void): void;
 
@@ -563,6 +566,423 @@ interface TagManagerPanelProps {
 }
 declare function TagManagerPanel({ workspaceTags, onTagCreate, onTagUpdate, onTagDelete, onTagReorder, onTagMove }: TagManagerPanelProps): React__default.JSX.Element;
 
+type FeatureSliceId = 'library' | 'tags' | 'prompt.builder' | 'prompt.negative' | 'labs.compare' | 'labs.remix' | 'labs.loop' | 'labs.blend' | 'labs.frameExtractor';
+type WorkspaceTabId = `react.${string}` | `flow.${string}`;
+interface PersistenceDescriptor<I extends FeatureSliceId = FeatureSliceId> {
+    sliceId: I;
+    tabId: WorkspaceTabId;
+    schemaVersion: number;
+}
+interface PersistedSlice<T> {
+    workspaceId: string;
+    tabId: WorkspaceTabId;
+    schemaVersion: number;
+    revision: number;
+    data: T;
+    updatedAt: number;
+    resetAt?: number;
+}
+type LoadResult<T> = {
+    kind: 'loaded';
+    slice: PersistedSlice<T>;
+} | {
+    kind: 'notFound';
+} | {
+    kind: 'invalidVersion';
+    found: number;
+    supported: number;
+} | {
+    kind: 'transportError';
+    message: string;
+    retryable: boolean;
+};
+type WriteResult<T> = {
+    kind: 'saved';
+    slice: PersistedSlice<T>;
+} | {
+    kind: 'conflict';
+    expectedRevision: number;
+    current: PersistedSlice<T>;
+} | {
+    kind: 'notFound';
+} | {
+    kind: 'invalidVersion';
+    found: number;
+    supported: number;
+} | {
+    kind: 'transportError';
+    message: string;
+    retryable: boolean;
+};
+interface WorkspacePersistence {
+    load<T>(workspaceId: string, descriptor: PersistenceDescriptor, signal: AbortSignal): Promise<LoadResult<T>>;
+    save<T>(slice: PersistedSlice<T>, expectedRevision: number, signal: AbortSignal): Promise<WriteResult<T>>;
+    reset<T>(sliceWithDefault: PersistedSlice<T>, expectedRevision: number, signal: AbortSignal): Promise<WriteResult<T>>;
+}
+interface SliceContract<T> {
+    id: FeatureSliceId;
+    schemaVersion: number;
+    createDefault(): T;
+    serialize(value: T): unknown;
+    validate(value: unknown): T;
+    migrate(fromVersion: number, value: unknown): T;
+}
+interface RequestContext {
+    requestId: string;
+    signal: AbortSignal;
+}
+type QueryResult<T> = {
+    kind: 'ok';
+    value: T;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+type CommandResult<T> = {
+    kind: 'ok';
+    value: T;
+} | {
+    kind: 'unsupported';
+    capability: string;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+
+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 +1085,7 @@ interface HFStateSnapshot {
     metadata: HFMetadataEntry[];
     tags: WorkspaceTags;
     meta: HFStateMeta;
+    openTasks?: Record<string, TaskRequestedPayload>;
 }
 interface HFFileInfo$1 {
     type: 'file' | 'directory';
@@ -672,6 +1093,7 @@ interface HFFileInfo$1 {
     size: number;
 }
 interface ImageAddedPayload extends HFMetadataEntry {
+    taskId?: string;
 }
 interface TagUpsertedPayload {
     category: string;
@@ -684,6 +1106,20 @@ 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;
+}
 
 declare function getHFToken(): string | null;
 declare function setHFToken(token: string): void;
@@ -743,23 +1179,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 +1202,4 @@ interface UseTagBaseResult {
 }
 declare function useTagBase(token: string, namespace: string): UseTagBaseResult;
 
-declare const LIB_VERSION = "2.0.72";
-
-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, type CommandResult, CompactDropdown, type CreateFaStoreOptions, type CreatePersistenceCoordinatorOptions, type ExtractedCharacter, FaApp, type FaAppProps, type FaStore, type FaStoreState, FaToolsBadge, type FeatureSliceId, 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, 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, type LoadResult, type MediaItem, MediaLibrary, type MetadataUpdatedPayload, type PersistedSlice, type PersistenceCoordinator, type PersistenceDescriptor, PillButton, type ProjectMeta, type ProjectSettings, ProjectSyncTab, PromptTab, type QueryResult, type RequestContext, type RunLibraryLegacyImportOptions, type RunTagsLegacyImportOptions, SCOPE_MAP, type SaveState, SectionLabel, type SelectedLabImage, type SelectedTag, type SelectionValidation, ServerTab, SetupPanel, type 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, type WorkspacePersistence, type WorkspaceTabId, type WorkspaceTags, type WriteResult, autoLabel, buildBlendInstruction, buildCompareInstruction, buildFallbackPrompt, buildGenerationPrompt, buildImageGenerationOptions, buildLoopInstruction, buildPromptTabPayload, buildReferenceImageMediaIds, buildRemixInstruction, buildScanInstruction, cleanAiResponse, createFaStore, createFlowServices, 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, interpretSdkError, libraryContract, libraryReactDescriptor, listCategories, loadHFState, loadPendingEvents, loadTagBase, parseLegacyLibraryFilters, parseLegacyRecentTags, parsePromptFile, parsePromptResponse, runLegacyMigration, runLibraryLegacyImport, runTagsLegacyImport, setHFToken, tagsContract, tagsReactDescriptor, tsFromEventPath, useFaSlice, useFaSliceMeta, useHFState, useKeyboardNavigation, useOnClickOutside, useTagBase, validateTagBaseSelection, writeHFEvent, writeTagEvent };