@rslsp1/fa-app-tools 6.1.0 → 7.2.0

package/dist/chunk-NBUS7AWR.mjs

@@ -1,418 +0,0 @@
-// src/lib/hfStateService.ts
-import JSZip from "jszip";
-import { uploadFile } from "@huggingface/hub";
-
-// src/lib/hfEventTypes.ts
-var HF_BASE = "https://huggingface.co";
-var HF_REPO = "RolandSch/fa-app-state";
-var CURRENT_EVENT_VERSION = { major: 1, minor: 0 };
-var SPEICHERBARE_BILDTYPEN = ["image/png", "image/jpeg", "image/webp"];
-function bildEndungFuer(mimeType) {
-  if (mimeType === "image/png") return "png";
-  if (mimeType === "image/webp") return "webp";
-  return "jpg";
-}
-
-// src/lib/hfEventLog.ts
-function treeUrl(namespace, subdir = "") {
-  const parts = [namespace.replace(/\/$/, ""), subdir].filter(Boolean).join("/");
-  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/main${parts ? "/" + parts : ""}`;
-}
-var DROSSEL_VERSUCHE = 4;
-var DROSSEL_BASIS_MS = 400;
-var schlafen = (ms) => new Promise((r) => setTimeout(r, ms));
-var HF_LESE_ZEITLIMIT_MS = 2e4;
-async function holeMitZeitlimit(url, init) {
-  const abbruch = new AbortController();
-  const timer = setTimeout(() => abbruch.abort(), HF_LESE_ZEITLIMIT_MS);
-  try {
-    return await fetch(url, { ...init, signal: abbruch.signal });
-  } catch (error) {
-    if (abbruch.signal.aborted) {
-      throw new Error(`HF-Anfrage ohne Antwort nach ${HF_LESE_ZEITLIMIT_MS}ms abgebrochen: ${url}`);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function mitGeduld(anfrage) {
-  let letzte = null;
-  for (let versuch = 0; versuch < DROSSEL_VERSUCHE; versuch += 1) {
-    const res = await anfrage();
-    if (res.status !== 429 && res.status < 500) return res;
-    letzte = res;
-    if (versuch === DROSSEL_VERSUCHE - 1) break;
-    const angesagt = Number(res.headers.get("retry-after"));
-    const warten = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
-    await schlafen(warten);
-  }
-  return letzte;
-}
-async function hfListDir(namespace, subdir, token) {
-  const res = await mitGeduld(() => holeMitZeitlimit(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 mitGeduld(() => holeMitZeitlimit(
-    `${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 mitGeduld(() => holeMitZeitlimit(
-    `${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());
-}
-function toBase64(text) {
-  const bytes = new TextEncoder().encode(text);
-  let binary = "";
-  bytes.forEach((b) => binary += String.fromCharCode(b));
-  return btoa(binary);
-}
-async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`) {
-  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: toBase64(content) } })
-    ].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 }) => [
-      JSON.stringify({ key: "file", value: { path: to, encoding: "base64", content: toBase64(content) } }),
-      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 base = filename.replace(/_[^_]+\.json$/, "");
-  const iso = base.replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
-  const ts = Date.parse(iso);
-  return isNaN(ts) ? 0 : ts;
-}
-var EVENTDOWNLOAD_PARALLELITAET = 3;
-async function mitBegrenzterParallelitaet(count, limit, task) {
-  let cursor = 0;
-  let ersterFehler;
-  let fehlerAufgetreten = false;
-  const worker = async () => {
-    while (cursor < count) {
-      const index = cursor++;
-      try {
-        await task(index);
-      } catch (error) {
-        if (!fehlerAufgetreten) {
-          fehlerAufgetreten = true;
-          ersterFehler = error;
-        }
-      }
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(limit, count) }, worker));
-  if (fehlerAufgetreten) throw ersterFehler;
-}
-async function loadPendingEvents(namespace, token, sinceTs, knownPaths) {
-  const files = await hfListDir(namespace, "events", token);
-  const pending = files.filter((f) => f.type === "file" && tsFromEventPath(f.path) > sinceTs && !knownPaths?.has(f.path)).sort((a, b) => a.path.localeCompare(b.path));
-  if (!pending.length) return [];
-  const raw = new Array(pending.length);
-  await mitBegrenzterParallelitaet(pending.length, EVENTDOWNLOAD_PARALLELITAET, async (index) => {
-    raw[index] = await hfDownloadJsonByPath(pending[index].path, token);
-  });
-  for (const f of pending) knownPaths?.add(f.path);
-  return raw.flatMap((e) => Array.isArray(e) ? e : [e]);
-}
-async function listEventPaths(namespace, token) {
-  const files = await hfListDir(namespace, "events", token);
-  return files.filter((f) => f.type === "file").map((f) => f.path).sort((a, b) => a.localeCompare(b));
-}
-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(".", "-");
-}
-var writeSeq = 0;
-var lastOrderedTs = 0;
-async function writeHFEvent(namespace, token, type, payload, prevTs, options) {
-  const wallTs = Date.now();
-  const ts = options?.ordered ? Math.max(wallTs, lastOrderedTs) : wallTs;
-  if (options?.ordered) lastOrderedTs = ts;
-  const uuid = crypto.randomUUID().slice(0, 8);
-  const event = {
-    v: CURRENT_EVENT_VERSION,
-    type,
-    ts,
-    prevTs,
-    clientId: SESSION_CLIENT_ID,
-    payload
-  };
-  const suffix = options?.ordered ? `${String(++writeSeq % 1e6).padStart(6, "0")}${uuid}` : uuid;
-  const filename = `${tsToFilename(ts)}_${suffix}.json`;
-  const repoPath = `${namespace}events/${filename}`;
-  await hfUploadSmallFile(repoPath, JSON.stringify(event, null, 2), token, `Event: ${type}`);
-  return event;
-}
-
-// src/lib/hfStateService.ts
-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 {
-  }
-}
-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, 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("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),
-    openTasks: openTasksStr ? JSON.parse(openTasksStr) : {}
-  };
-}
-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}`;
-  log("Lade state.zip hoch \u2026");
-  await uploadFile({
-    repo: { type: "dataset", name: HF_REPO },
-    credentials: { accessToken: token },
-    file: { path: repoPath, content: new Blob([zipBytes.buffer], { type: "application/zip" }) },
-    branch: "main",
-    commitTitle: `Bootstrap: initialer State aus Legacy-Daten`
-  });
-  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);
-  await uploadFile({
-    repo: { type: "dataset", name: HF_REPO },
-    credentials: { accessToken: token },
-    file: { path: filename, content: new Blob([bytes], { type: "application/zip" }) },
-    branch: "main",
-    commitTitle: `Upload ${filename}`
-  });
-  return { id: filename.replace(/\.zip$/, ""), name: filename.replace(/\.zip$/, ""), path: filename, size: bytes.length, 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 = bildEndungFuer(mimeType);
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-  await uploadFile({
-    repo: { type: "dataset", name: HF_REPO },
-    credentials: { accessToken: token },
-    file: { path: `images/${id}.${ext}`, content: new Blob([bytes], { type: mimeType }) },
-    branch: "main",
-    commitTitle: `Add image ${id}`
-  });
-}
-async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeType, hasThumb) {
-  const fetchBase64 = async (repoPath) => {
-    try {
-      const res = await fetch(
-        `${HF_BASE}/datasets/${HF_REPO}/resolve/main/${repoPath}?download=true`,
-        { headers: { Authorization: `Bearer ${token}` } }
-      );
-      if (!res.ok) {
-        if (on404 && on404()) return "ABORT";
-        return null;
-      }
-      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 {
-      return null;
-    }
-  };
-  if (filename) {
-    if (hasThumb) {
-      const thumb = await fetchBase64(`thumbs/${filename}`);
-      if (thumb && thumb !== "ABORT") return thumb;
-    }
-    const result2 = await fetchBase64(`images/${filename}`);
-    return result2 === "ABORT" ? null : result2;
-  }
-  const ext = bildEndungFuer(mimeType);
-  const result = await fetchBase64(`images/${id}.${ext}`);
-  return result === "ABORT" ? null : result;
-}
-
-export {
-  SPEICHERBARE_BILDTYPEN,
-  bildEndungFuer,
-  hfListDir,
-  hfDownloadJsonByPath,
-  hfDownloadBinaryByPath,
-  hfUploadSmallFile,
-  hfBatchArchive,
-  tsFromEventPath,
-  loadPendingEvents,
-  listEventPaths,
-  getSessionClientId,
-  writeHFEvent,
-  HF_TOKEN_KEY,
-  getHFToken,
-  setHFToken,
-  loadHFState,
-  hfBootstrapFromLegacy,
-  hfListProjects,
-  hfDownloadProject,
-  hfUploadProject,
-  hfUploadProjectForm,
-  hfDeleteProject,
-  hfSaveTags,
-  hfLoadTags,
-  hfSaveMetadata,
-  hfLoadMetadata,
-  hfUploadImage,
-  hfLoadImageAsBase64
-};

package/dist/chunk-UFXDXENC.mjs

@@ -1,218 +0,0 @@
-// src/lib/project.ts
-import JSZip from "jszip";
-
-// src/lib/metadata.ts
-var crcTable = (() => {
-  let c;
-  const table = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    c = n;
-    for (let k = 0; k < 8; k++) {
-      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
-    }
-    table[n] = c;
-  }
-  return table;
-})();
-function calculateCRC(bytes) {
-  let crc = 4294967295;
-  for (let i = 0; i < bytes.length; i++) {
-    crc = crcTable[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
-  }
-  return (crc ^ 4294967295) >>> 0;
-}
-function indexOfBytes(buffer, search, start = 0) {
-  for (let i = start; i <= buffer.length - search.length; i++) {
-    let found = true;
-    for (let j = 0; j < search.length; j++) {
-      if (buffer[i + j] !== search[j]) {
-        found = false;
-        break;
-      }
-    }
-    if (found) return i;
-  }
-  return -1;
-}
-function createXMPPacket(prompt, seed, model, id, tags = [], hierarchy) {
-  const sanitize = (str) => (str || "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-  const escPrompt = sanitize(prompt);
-  const escModel = sanitize(model || "AI Model");
-  const escHierarchy = sanitize(hierarchy || "");
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const allTags = [.../* @__PURE__ */ new Set([...tags, "Avatar Architect", escModel])];
-  const rdfTags = allTags.map((t) => `<rdf:li>${sanitize(t)}</rdf:li>`).join("");
-  const BOM = "\uFEFF";
-  return `<?xpacket begin="${BOM}" id="W5M0MpCehiHzreSzNTczkc9d"?>
-<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.6-c140">
- <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-  <rdf:Description rdf:about=""
-    xmlns:xmp="http://ns.adobe.com/xap/1.0/"
-    xmlns:dc="http://purl.org/dc/elements/1.1/"
-    xmlns:photoshop="http://ns.adobe.com/photoshop/1.0/"
-    xmlns:ai="http://ns.flow.creative/ai/1.0/">
-   <dc:format>image/png</dc:format>
-   <dc:description><rdf:Alt><rdf:li xml:lang="x-default">${escPrompt}</rdf:li></rdf:Alt></dc:description>
-   <dc:subject><rdf:Bag>${rdfTags}</rdf:Bag></dc:subject>
-   <photoshop:Instructions>Seed: ${seed} | Model: ${escModel}</photoshop:Instructions>
-   <xmp:CreateDate>${timestamp}</xmp:CreateDate>
-   <ai:prompt>${escPrompt}</ai:prompt>
-   <ai:seed>${seed ?? "0"}</ai:seed>
-   <ai:model>${escModel}</ai:model>
-   <ai:hierarchy>${escHierarchy}</ai:hierarchy>
-  </rdf:Description>
- </rdf:RDF>
-</x:xmpmeta>${" ".repeat(1024)}<?xpacket end="w"?>`;
-}
-function bytesToBase64(bytes) {
-  let binary = "";
-  const len = bytes.byteLength;
-  for (let i = 0; i < len; i++) binary += String.fromCharCode(bytes[i]);
-  return btoa(binary);
-}
-function base64ToBytes(base64) {
-  const clean = base64.includes(",") ? base64.split(",")[1] : base64.trim();
-  try {
-    const binary = atob(clean);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-    return bytes;
-  } catch (e) {
-    return new Uint8Array(0);
-  }
-}
-function injectXMPMetadata(base64, prompt, seed, model, id, tags = [], hierarchy) {
-  try {
-    const bytes = base64ToBytes(base64);
-    if (bytes.length < 8 || bytes[0] !== 137 || bytes[1] !== 80) {
-      console.warn("Metadaten-Injektion \xFCbersprungen: Datei ist kein PNG.");
-      return base64;
-    }
-    const xmpData = createXMPPacket(prompt, seed, model, id, tags, hierarchy);
-    const encoder = new TextEncoder();
-    const keyword = encoder.encode("XML:com.adobe.xmp");
-    const textBytes = encoder.encode(xmpData);
-    const chunkData = new Uint8Array(keyword.length + 5 + textBytes.length);
-    chunkData.set(keyword, 0);
-    chunkData.set(textBytes, keyword.length + 5);
-    const type = encoder.encode("iTXt");
-    const crcInput = new Uint8Array(type.length + chunkData.length);
-    crcInput.set(type, 0);
-    crcInput.set(chunkData, type.length);
-    const crc = calculateCRC(crcInput);
-    const fullChunk = new Uint8Array(4 + 4 + chunkData.length + 4);
-    const view = new DataView(fullChunk.buffer);
-    view.setUint32(0, chunkData.length);
-    fullChunk.set(type, 4);
-    fullChunk.set(chunkData, 8);
-    view.setUint32(8 + chunkData.length, crc);
-    const IDAT = encoder.encode("IDAT");
-    const idatPos = indexOfBytes(bytes, IDAT);
-    const insertPos = idatPos !== -1 ? idatPos - 4 : 8;
-    const result = new Uint8Array(bytes.length + fullChunk.length);
-    result.set(bytes.slice(0, insertPos), 0);
-    result.set(fullChunk, insertPos);
-    result.set(bytes.slice(insertPos), insertPos + fullChunk.length);
-    return bytesToBase64(result);
-  } catch (e) {
-    console.error("Fehler beim Einbetten der Metadaten:", e);
-    return base64;
-  }
-}
-
-// src/lib/project.ts
-function generateMarkdownReport(nodes, history) {
-  let md = "# Avatar Architect - Projekt Report\n\n";
-  md += `Exportiert: ${(/* @__PURE__ */ new Date()).toLocaleString()}
-
-`;
-  md += "## Hierarchie\n";
-  nodes.forEach((n) => {
-    md += `- **${n.data?.label || "Unbenannt"}**
-`;
-  });
-  md += "\n## Historie der Generationen\n";
-  history.forEach((h, i) => {
-    md += `### ${i + 1}. Generation (${h.model || "AI"})
-`;
-    md += `- **Zeitstempel**: ${new Date(h.timestamp).toLocaleString()}
-`;
-    md += `- **Seed**: ${h.seed}
-`;
-    md += `- **Prompt**:
-> ${h.prompt}
-
-`;
-  });
-  return md;
-}
-async function exportProjectToZip(nodes, edges, history, galleryItems, settings, workspaceTags, recentLabItemIds) {
-  const zip = new JSZip();
-  const projectData = {
-    nodes,
-    edges,
-    history: history.map((h) => ({ ...h, base64: void 0 })),
-    galleryItems: galleryItems.map((g) => ({ ...g, base64: void 0 })),
-    settings,
-    workspaceTags: workspaceTags || null,
-    recentLabItemIds: recentLabItemIds || [],
-    version: "1.3.0"
-  };
-  zip.file("project.json", JSON.stringify(projectData, null, 2));
-  zip.file("projekt_bericht.md", generateMarkdownReport(nodes, history));
-  const imgFolder = zip.folder("images");
-  if (imgFolder) {
-    const allItems = [...history, ...galleryItems];
-    for (const item of allItems) {
-      if (item.base64) {
-        try {
-          const cleanB64 = item.base64.includes(",") ? item.base64.split(",")[1] : item.base64;
-          const withMeta = injectXMPMetadata(cleanB64, item.prompt || "", item.seed, item.model, item.id, item.tags || []);
-          imgFolder.file(`${item.id}.png`, withMeta, { base64: true });
-        } catch (e) {
-          console.error("Fehler beim Packen eines Bildes:", e);
-        }
-      }
-    }
-  }
-  const blob = await zip.generateAsync({ type: "blob", compression: "STORE" });
-  return blobToBase64(blob);
-}
-async function blobToBase64(blob) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => {
-      const result = reader.result;
-      resolve({ base64: result.split(",")[1] });
-    };
-    reader.onerror = reject;
-    reader.readAsDataURL(blob);
-  });
-}
-async function importProjectFromZip(file) {
-  const zip = await JSZip.loadAsync(file);
-  const jsonStr = await zip.file("project.json")?.async("string");
-  if (!jsonStr) throw new Error("Keine project.json gefunden.");
-  const data = JSON.parse(jsonStr);
-  const imgFolder = zip.folder("images");
-  if (imgFolder) {
-    const loadImgs = async (items) => {
-      if (!items) return [];
-      return Promise.all(items.map(async (h) => {
-        const imgFile = zip.file(`images/${h.id}.png`);
-        if (!imgFile) return h;
-        const b64 = await imgFile.async("base64");
-        return { ...h, base64: `data:image/png;base64,${b64}` };
-      }));
-    };
-    data.history = await loadImgs(data.history || []);
-    data.galleryItems = await loadImgs(data.galleryItems || []);
-  }
-  return data;
-}
-
-export {
-  injectXMPMetadata,
-  exportProjectToZip,
-  importProjectFromZip
-};

package/dist/hfStateService-W7KO2FOH.mjs

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

package/dist/project-O4ORKXY5.mjs

@@ -1,8 +0,0 @@
-import {
-  exportProjectToZip,
-  importProjectFromZip
-} from "./chunk-UFXDXENC.mjs";
-export {
-  exportProjectToZip,
-  importProjectFromZip
-};