@rslsp1/fa-app-tools 1.3.18 → 2.0.12

package/dist/chunk-WCFXXLKN.mjs

@@ -0,0 +1,409 @@
+// src/lib/hfStateService.ts
+import JSZip from "jszip";
+
+// src/lib/hfEventTypes.ts
+var CURRENT_EVENT_VERSION = { major: 1, minor: 0 };
+
+// src/lib/hfStateService.ts
+var HF_BASE = "https://huggingface.co";
+var HF_REPO = "RolandSch/fa-app-state";
+var HF_TOKEN_KEY = "hf-token";
+function getHFToken() {
+  try {
+    return localStorage.getItem(HF_TOKEN_KEY);
+  } catch {
+    return null;
+  }
+}
+function setHFToken(token) {
+  try {
+    localStorage.setItem(HF_TOKEN_KEY, token);
+  } catch {
+  }
+}
+function treeUrl(namespace, subdir = "") {
+  const parts = [namespace.replace(/\/$/, ""), subdir].filter(Boolean).join("/");
+  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/main${parts ? "/" + parts : ""}`;
+}
+async function hfListDir(namespace, subdir, token) {
+  const res = await fetch(treeUrl(namespace, subdir), {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (res.status === 404) return [];
+  if (!res.ok) throw new Error(`HF list failed: ${res.status} ${res.statusText}`);
+  return res.json();
+}
+async function hfDownloadJsonByPath(repoPath, token) {
+  const res = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!res.ok) throw new Error(`HF download failed: ${res.status}`);
+  return res.json();
+}
+async function hfDownloadBinaryByPath(repoPath, token) {
+  const res = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!res.ok) throw new Error(`HF download binary failed: ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`) {
+  const bytes = new TextEncoder().encode(content);
+  let binary = "";
+  bytes.forEach((b) => binary += String.fromCharCode(b));
+  const b64 = btoa(binary);
+  const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: [
+      JSON.stringify({ key: "header", value: { summary, description: "" } }),
+      JSON.stringify({ key: "file", value: { path: repoPath, encoding: "base64", content: b64 } })
+    ].join("\n")
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    throw new Error(`HF upload failed: ${res.status} \u2014 ${err.slice(0, 200)}`);
+  }
+}
+async function hfBatchArchive(moves, token, summary) {
+  const lines = [
+    JSON.stringify({ key: "header", value: { summary, description: "" } }),
+    ...moves.flatMap(({ from, to, content }) => {
+      const bytes = new TextEncoder().encode(content);
+      let binary = "";
+      bytes.forEach((b) => binary += String.fromCharCode(b));
+      return [
+        JSON.stringify({ key: "file", value: { path: to, encoding: "base64", content: btoa(binary) } }),
+        JSON.stringify({ key: "deletedFile", value: { path: from } })
+      ];
+    })
+  ];
+  const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: lines.join("\n")
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    throw new Error(`HF batch archive failed: ${res.status} \u2014 ${err.slice(0, 200)}`);
+  }
+}
+function tsFromEventPath(repoPath) {
+  const filename = repoPath.split("/").pop() || "";
+  const iso = filename.replace(/_[^_]+\.json$/, "").replace(/-/g, (m, i) => i > 7 ? ":" : m);
+  const ts = Date.parse(iso.replace(/T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z/, "T$1:$2:$3.$4Z"));
+  return isNaN(ts) ? 0 : ts;
+}
+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));
+  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([
+    zip.file("metadata.json")?.async("string"),
+    zip.file("tags.json")?.async("string"),
+    zip.file("state_meta.json")?.async("string")
+  ]);
+  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)
+  };
+}
+async function loadPendingEvents(namespace, token, sinceTs) {
+  const files = await hfListDir(namespace, "events", token);
+  const pending = files.filter((f) => f.type === "file" && tsFromEventPath(f.path) > sinceTs).sort((a, b) => a.path.localeCompare(b.path));
+  const events = await Promise.all(
+    pending.map((f) => hfDownloadJsonByPath(f.path, token))
+  );
+  return events;
+}
+var SESSION_CLIENT_ID = `client-${crypto.randomUUID().slice(0, 8)}`;
+function getSessionClientId() {
+  return SESSION_CLIENT_ID;
+}
+function tsToFilename(ts) {
+  return new Date(ts).toISOString().replace(/:/g, "-").replace(".", "-");
+}
+async function writeHFEvent(namespace, token, type, payload, prevTs) {
+  const ts = Date.now();
+  const uuid = crypto.randomUUID().slice(0, 8);
+  const event = {
+    v: CURRENT_EVENT_VERSION,
+    type,
+    ts,
+    prevTs,
+    clientId: SESSION_CLIENT_ID,
+    payload
+  };
+  const filename = `${tsToFilename(ts)}_${uuid}.json`;
+  const repoPath = `${namespace}events/${filename}`;
+  await hfUploadSmallFile(repoPath, JSON.stringify(event, null, 2), token, `Event: ${type}`);
+  return event;
+}
+async function hfBootstrapFromLegacy(namespace, token, onProgress) {
+  const log = (msg) => {
+    if (onProgress) onProgress(msg);
+  };
+  log("Lese tags.json \u2026");
+  const tags = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/tags.json?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ).then((r) => r.ok ? r.json() : null).catch(() => null);
+  log("Lese metadata.json \u2026");
+  const metadata = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/metadata.json?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ).then((r) => r.ok ? r.json() : []).catch(() => []);
+  const snapshot = {
+    metadata: Array.isArray(metadata) ? metadata : [],
+    tags: tags?.by_category ? tags : { by_category: {}, all: [] },
+    meta: { consolidatedAt: Date.now(), version: 1 }
+  };
+  log(`Erstelle state.zip (${snapshot.metadata.length} Bilder, ${snapshot.tags.all?.length ?? 0} Tags) \u2026`);
+  const zip = new JSZip();
+  zip.file("metadata.json", JSON.stringify(snapshot.metadata, null, 2));
+  zip.file("tags.json", JSON.stringify(snapshot.tags, null, 2));
+  zip.file("state_meta.json", JSON.stringify(snapshot.meta, null, 2));
+  const zipBytes = await zip.generateAsync({ type: "uint8array", compression: "DEFLATE" });
+  const ts = snapshot.meta.consolidatedAt;
+  const stateFilename = `state-${new Date(ts).toISOString().replace(/:/g, "-").replace(".", "-")}.zip`;
+  const repoPath = `${namespace}${stateFilename}`;
+  let binary = "";
+  zipBytes.forEach((b) => {
+    binary += String.fromCharCode(b);
+  });
+  const b64 = btoa(binary);
+  log("Lade state.zip hoch \u2026");
+  const commitRes = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: [
+      JSON.stringify({ key: "header", value: { summary: `Bootstrap: initialer State aus Legacy-Daten`, description: "" } }),
+      JSON.stringify({ key: "file", value: { path: repoPath, encoding: "base64", content: b64 } })
+    ].join("\n")
+  });
+  if (!commitRes.ok) {
+    const err = await commitRes.text().catch(() => "");
+    throw new Error(`HF commit failed: ${commitRes.status} \u2014 ${err.slice(0, 300)}`);
+  }
+  log(`Fertig \u2014 ${stateFilename}`);
+}
+async function hfListProjects(token) {
+  const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/tree/main`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) throw new Error(`HF list failed: ${res.status} ${res.statusText}`);
+  const files = await res.json();
+  return files.filter((f) => f.type === "file" && f.path.endsWith(".zip")).map((f) => ({
+    id: f.path.replace(/\.zip$/, ""),
+    name: f.path.replace(/\.zip$/, ""),
+    path: f.path,
+    size: f.size,
+    isLfs: !!f.lfs
+  }));
+}
+async function hfDownloadProject(path, token) {
+  const res = await fetch(
+    `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${path}?download=true`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!res.ok) throw new Error(`HF download failed: ${res.status} ${res.statusText}`);
+  const blob = await res.blob();
+  return new File([blob], path, { type: "application/zip" });
+}
+async function hfUploadProject(zipBase64, name, token) {
+  const filename = name.endsWith(".zip") ? name : `${name}.zip`;
+  const binary = atob(zipBase64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", bytes);
+  const oid = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const size = bytes.length;
+  const sampleBytes = bytes.slice(0, 512);
+  let sampleBinary = "";
+  for (let i = 0; i < sampleBytes.length; i++) sampleBinary += String.fromCharCode(sampleBytes[i]);
+  const sample = btoa(sampleBinary);
+  const preRes = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/preupload/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ files: [{ path: filename, size, sample }] })
+  });
+  if (!preRes.ok) throw new Error(`HF preupload failed: ${preRes.status} ${preRes.statusText}`);
+  const preData = await preRes.json();
+  const fileInfo = preData.files?.[0];
+  if (!fileInfo?.uploadMode) throw new Error(`HF preupload kein fileInfo: ${JSON.stringify(preData)}`);
+  if (fileInfo.uploadMode === "lfs" && fileInfo.uploadUrl) {
+    let uploadStatus = 0;
+    try {
+      const uploadRes = await fetch(fileInfo.uploadUrl, {
+        method: "PUT",
+        redirect: "follow",
+        headers: { "Content-Type": "application/octet-stream", ...fileInfo.header || {} },
+        body: bytes
+      });
+      uploadStatus = uploadRes.status;
+      if (!uploadRes.ok) {
+        const uploadErr = await uploadRes.text().catch(() => "");
+        throw new Error(`HF LFS upload failed: ${uploadRes.status} \u2014 ${uploadErr.slice(0, 300)}`);
+      }
+    } catch (e) {
+      if (uploadStatus === 0) throw new Error(`HF LFS upload network error (CORS/redirect?): ${e.message}`);
+      throw e;
+    }
+    if (fileInfo.verifyUrl) {
+      const verifyRes = await fetch(fileInfo.verifyUrl, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...fileInfo.verifyHeader || {} },
+        body: JSON.stringify({ oid, size })
+      });
+      if (!verifyRes.ok) {
+        const verifyErr = await verifyRes.text().catch(() => "");
+        throw new Error(`HF LFS verify failed: ${verifyRes.status} \u2014 ${verifyErr.slice(0, 200)}`);
+      }
+    }
+  }
+  const commitRes = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: [
+      JSON.stringify({ key: "header", value: { summary: `Upload ${filename}`, description: "" } }),
+      JSON.stringify({ key: "lfsFile", value: { path: filename, algo: "sha256", oid, size } })
+    ].join("\n")
+  });
+  if (!commitRes.ok) {
+    const err = await commitRes.text();
+    throw new Error(`HF commit failed: ${commitRes.status} \u2014 ${err}`);
+  }
+  return { id: filename.replace(/\.zip$/, ""), name: filename.replace(/\.zip$/, ""), path: filename, size, isLfs: true };
+}
+async function hfUploadProjectForm(_zipBase64, _name, _token) {
+  throw new Error("hfUploadProjectForm is deprecated. Use hfUploadProject instead.");
+}
+async function hfDeleteProject(path, token) {
+  const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: [
+      JSON.stringify({ key: "header", value: { summary: `Delete ${path}`, description: "" } }),
+      JSON.stringify({ key: "deletedFile", value: { path } })
+    ].join("\n")
+  });
+  if (!res.ok) throw new Error(`HF delete failed: ${res.status} ${res.statusText}`);
+}
+async function hfSaveTags(_workspaceTags, _token) {
+  throw new Error("hfSaveTags is deprecated. Use writeHFEvent instead.");
+}
+async function hfLoadTags(token) {
+  try {
+    const res = await fetch(
+      `${HF_BASE}/datasets/${HF_REPO}/resolve/main/tags.json?download=true`,
+      { headers: { Authorization: `Bearer ${token}` } }
+    );
+    if (!res.ok) return null;
+    return res.json();
+  } catch {
+    return null;
+  }
+}
+async function hfSaveMetadata(_entries, _token) {
+  throw new Error("hfSaveMetadata is deprecated. Use writeHFEvent instead.");
+}
+async function hfLoadMetadata(token) {
+  try {
+    const res = await fetch(
+      `${HF_BASE}/datasets/${HF_REPO}/resolve/main/metadata.json?download=true`,
+      { headers: { Authorization: `Bearer ${token}` } }
+    );
+    if (!res.ok) return [];
+    return res.json();
+  } catch {
+    return [];
+  }
+}
+async function hfUploadImage(base64, id, token, mimeType = "image/jpeg") {
+  const ext = mimeType === "image/png" ? "png" : "jpg";
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", bytes);
+  const oid = Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const size = bytes.length;
+  const filename = `images/${id}.${ext}`;
+  const preRes = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/preupload/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ files: [{ path: filename, size }] })
+  });
+  if (!preRes.ok) throw new Error(`HF preupload failed: ${preRes.status}`);
+  const preData = await preRes.json();
+  const fileInfo = preData.files?.[0];
+  if (fileInfo?.uploadUrl) {
+    await fetch(fileInfo.uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": mimeType, ...fileInfo.header || {} },
+      body: bytes
+    });
+  }
+  await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
+    body: [
+      JSON.stringify({ key: "header", value: { summary: `Add image ${id}`, description: "" } }),
+      JSON.stringify({ key: "lfsFile", value: { path: filename, algo: "sha256", oid, size } })
+    ].join("\n")
+  });
+}
+async function hfLoadImageAsBase64(id, token) {
+  for (const ext of ["jpg", "png"]) {
+    try {
+      const res = await fetch(
+        `${HF_BASE}/datasets/${HF_REPO}/resolve/main/images/${id}.${ext}?download=true`,
+        { headers: { Authorization: `Bearer ${token}` } }
+      );
+      if (!res.ok) continue;
+      const blob = await res.blob();
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result.split(",")[1]);
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+      });
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+export {
+  HF_TOKEN_KEY,
+  getHFToken,
+  setHFToken,
+  hfListDir,
+  hfDownloadJsonByPath,
+  hfDownloadBinaryByPath,
+  hfUploadSmallFile,
+  hfBatchArchive,
+  tsFromEventPath,
+  loadHFState,
+  loadPendingEvents,
+  getSessionClientId,
+  writeHFEvent,
+  hfBootstrapFromLegacy,
+  hfListProjects,
+  hfDownloadProject,
+  hfUploadProject,
+  hfUploadProjectForm,
+  hfDeleteProject,
+  hfSaveTags,
+  hfLoadTags,
+  hfSaveMetadata,
+  hfLoadMetadata,
+  hfUploadImage,
+  hfLoadImageAsBase64
+};

package/dist/hfStateService-6YYT6ATO.mjs

@@ -0,0 +1,54 @@
+import {
+  HF_TOKEN_KEY,
+  getHFToken,
+  getSessionClientId,
+  hfBatchArchive,
+  hfBootstrapFromLegacy,
+  hfDeleteProject,
+  hfDownloadBinaryByPath,
+  hfDownloadJsonByPath,
+  hfDownloadProject,
+  hfListDir,
+  hfListProjects,
+  hfLoadImageAsBase64,
+  hfLoadMetadata,
+  hfLoadTags,
+  hfSaveMetadata,
+  hfSaveTags,
+  hfUploadImage,
+  hfUploadProject,
+  hfUploadProjectForm,
+  hfUploadSmallFile,
+  loadHFState,
+  loadPendingEvents,
+  setHFToken,
+  tsFromEventPath,
+  writeHFEvent
+} from "./chunk-WCFXXLKN.mjs";
+export {
+  HF_TOKEN_KEY,
+  getHFToken,
+  getSessionClientId,
+  hfBatchArchive,
+  hfBootstrapFromLegacy,
+  hfDeleteProject,
+  hfDownloadBinaryByPath,
+  hfDownloadJsonByPath,
+  hfDownloadProject,
+  hfListDir,
+  hfListProjects,
+  hfLoadImageAsBase64,
+  hfLoadMetadata,
+  hfLoadTags,
+  hfSaveMetadata,
+  hfSaveTags,
+  hfUploadImage,
+  hfUploadProject,
+  hfUploadProjectForm,
+  hfUploadSmallFile,
+  loadHFState,
+  loadPendingEvents,
+  setHFToken,
+  tsFromEventPath,
+  writeHFEvent
+};

package/dist/index.d.mts

@@ -310,12 +310,14 @@ interface AvatarArchitectAppProps {
     onSelectMedia: () => Promise<MediaItem[]>;
     buildInfo?: string;
     initialHfToken?: string;
+    hfNamespace?: string;
+    allowDevNamespace?: boolean;
     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, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete }: AvatarArchitectAppProps): react_jsx_runtime.JSX.Element;
+declare function AvatarArchitectApp({ onGenerateImage, onGeneratePrompt, onDownload, onSelectMedia, buildInfo, initialHfToken, hfNamespace, allowDevNamespace, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete }: AvatarArchitectAppProps): react_jsx_runtime.JSX.Element;
 
 interface FaAppProps {
     onGenerateImage: (params: Record<string, any>) => Promise<{
@@ -347,13 +349,15 @@ interface FaAppProps {
         mediaId: string;
     }>;
     libToken?: string;
+    allowDevNamespace?: boolean;
+    serverBaseUrl?: string;
     onFetchServerProjects?: () => Promise<ProjectMeta[]>;
     onServerSave?: (zipBase64: string, name: string) => Promise<ProjectMeta>;
     onServerLoad?: (id: string) => Promise<File>;
     onServerDelete?: (id: string) => Promise<void>;
     buildInfo?: string;
 }
-declare function FaApp({ onGenerateImage, onGeneratePrompt, onGenerateVideo: _onGenerateVideo, onDownload, onSelectMedia, onFlowSave: _onFlowSave, onFlowUpload: _onFlowUpload, onFlowMediaUpload: _onFlowMediaUpload, libToken, onFetchServerProjects, onServerSave, onServerLoad, onServerDelete, buildInfo, }: FaAppProps): react_jsx_runtime.JSX.Element;
+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_runtime.JSX.Element;
 
 interface CollapsibleCardProps {
     title: string;
@@ -394,6 +398,7 @@ interface PromptTabProps {
 declare const PromptTab: React.FC<PromptTabProps>;
 
 interface ProjectSyncTabProps {
+    topSlot?: React.ReactNode;
     onProjectExport?: () => Promise<void>;
     onProjectImport?: (file: File) => Promise<void>;
     onWorkspaceImport?: (file: File) => void;
@@ -498,6 +503,46 @@ declare function buildLoopInstruction(rounds: Array<{
 declare function autoLabel(index: number): string;
 declare function buildReferenceImageMediaIds(images: SelectedLabImage[]): string[];
 
+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;
+}
+interface HFFileInfo$1 {
+    type: 'file' | 'directory';
+    path: string;
+    size: number;
+}
+interface ImageAddedPayload extends HFMetadataEntry {
+}
+interface TagUpsertedPayload {
+    category: string;
+    label: string;
+    value: string;
+    is_user_created?: boolean;
+    is_deleted?: boolean;
+}
+interface MetadataUpdatedPayload {
+    id: string;
+    delta: Partial<HFMetadataEntry>;
+}
+
 declare function getHFToken(): string | null;
 declare function setHFToken(token: string): void;
 interface HFProjectMeta {
@@ -507,17 +552,66 @@ interface HFProjectMeta {
     size: number;
     isLfs: boolean;
 }
+interface HFFileInfo {
+    type: 'file' | 'directory';
+    path: string;
+    size: number;
+}
+declare function hfListDir(namespace: string, subdir: string, token: string): Promise<HFFileInfo[]>;
+declare function hfUploadSmallFile(repoPath: string, content: string, token: string, summary?: string): Promise<void>;
+declare function hfBatchArchive(moves: Array<{
+    from: string;
+    to: string;
+    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): 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 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>;
-declare function hfUploadProjectForm(zipBase64: string, name: string, token: string): Promise<HFProjectMeta>;
+declare function hfUploadProjectForm(_zipBase64: string, _name: string, _token: string): Promise<HFProjectMeta>;
 declare function hfDeleteProject(path: string, token: string): Promise<void>;
-declare function hfSaveTags(workspaceTags: any, token: string): Promise<void>;
-declare function hfLoadTags(token: string): Promise<any | null>;
-declare function hfSaveMetadata(entries: any[], token: string): Promise<void>;
-declare function hfLoadMetadata(token: string): Promise<any[]>;
 declare function hfUploadImage(base64: string, id: string, token: string, mimeType?: string): Promise<void>;
 declare function hfLoadImageAsBase64(id: string, token: string): Promise<string | null>;
 
-declare const LIB_VERSION = "1.3.18";
+interface HFStateResult {
+    state: HFStateSnapshot | null;
+    isLoading: boolean;
+    error: string | null;
+    pendingBufferCount: number;
+    eventCount: number;
+    forks: Array<{
+        parentTs: number;
+        childTs: number[];
+    }>;
+    allEvents: HFEvent[];
+    writeEvent: (type: string, payload: any) => Promise<void>;
+    refresh: () => Promise<void>;
+    lastEventTs: number;
+    hasStateZip: boolean;
+}
+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[];
+
+declare const LIB_VERSION = "2.0.12";
 
-export { AvatarArchitectApp, type AvatarArchitectAppProps, CollapsibleCard, CompactDropdown, type ExtractedCharacter, FaApp, type FaAppProps, FaToolsBadge, type FlowSdk, GLOBAL_STYLES, type Generation, type HFMetadataEntry, HistoryPanel, InspectPanel, LIB_VERSION, LabBlend, LabCompare, type LabFrame, LabImagePicker, type LabItem, LabLoop, LabRemix, type LabServices, LabsTab, ListView, type MediaItem, MediaLibrary, PillButton, type ProjectMeta, type ProjectSettings, ProjectSyncTab, PromptTab, SectionLabel, type SelectedLabImage, type SelectedTag, SetupPanel, type SyncDiff, TagManagerPanel, type TagOption, type WorkspaceTags, autoLabel, buildBlendInstruction, buildCompareInstruction, buildFallbackPrompt, buildGenerationPrompt, buildImageGenerationOptions, buildLoopInstruction, buildPromptTabPayload, buildReferenceImageMediaIds, buildRemixInstruction, buildScanInstruction, cleanAiResponse, createFlowServices, exportProjectToZip, formatTreeToMarkdown, frameToGeneration, getFormattedTimestamp, getHFToken, groupGenerationsToLabItems, hfDeleteProject, hfDownloadProject, hfListProjects, hfLoadImageAsBase64, hfLoadMetadata, hfLoadTags, hfSaveMetadata, hfSaveTags, hfUploadImage, hfUploadProjectForm, importProjectFromZip, injectXMPMetadata, interpretSdkError, parsePromptFile, parsePromptResponse, setHFToken, useKeyboardNavigation, useOnClickOutside };
+export { AvatarArchitectApp, type AvatarArchitectAppProps, 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, 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, SetupPanel, type SyncDiff, TagManagerPanel, type TagOption, type TagUpsertedPayload, type WorkspaceTags, applyEvent, applyEvents, autoLabel, buildBlendInstruction, buildCompareInstruction, buildDag, buildFallbackPrompt, buildGenerationPrompt, buildImageGenerationOptions, buildLoopInstruction, buildPromptTabPayload, buildReferenceImageMediaIds, buildRemixInstruction, buildScanInstruction, cleanAiResponse, createFlowServices, exportProjectToZip, findForks, findTips, formatTreeToMarkdown, frameToGeneration, getFormattedTimestamp, getHFToken, getSessionClientId, groupGenerationsToLabItems, hfBatchArchive, hfBootstrapFromLegacy, hfDeleteProject, hfDownloadProject, hfListDir, hfListProjects, hfLoadImageAsBase64, hfUploadImage, hfUploadProjectForm, hfUploadSmallFile, importProjectFromZip, injectXMPMetadata, interpretSdkError, loadHFState, loadPendingEvents, parsePromptFile, parsePromptResponse, setHFToken, topoSort, tsFromEventPath, useHFState, useKeyboardNavigation, useOnClickOutside, writeHFEvent };