@rslsp1/fa-app-tools 6.1.0 → 7.2.0

package/dist/{chunk-GHKN2VX3.mjs → chunk-5QA6DTJ6.mjs}

@@ -4,15 +4,396 @@ import {
   preferredVersionId,
   resolvePreferredHead
 } from "./chunk-FUY2OCVC.mjs";
-import {
-  SPEICHERBARE_BILDTYPEN,
-  bildEndungFuer,
-  hfLoadImageAsBase64,
-  hfUploadImage,
-  loadHFState,
-  loadPendingEvents,
-  writeHFEvent
-} from "./chunk-NBUS7AWR.mjs";
+
+// src/lib/szenen/szenenSnapshot.ts
+var SZENEN_SNAPSHOT_SCHEMA_VERSION = 1;
+var SZENEN_SNAPSHOT_PREFIX = "szenen-state-";
+var SZENEN_SNAPSHOT_FILE = "szenen-state.json";
+function szenenSnapshotFilename(maxTs) {
+  const stamp = new Date(maxTs).toISOString().replace(/:/g, "-").replace(".", "-");
+  return `${SZENEN_SNAPSHOT_PREFIX}${stamp}.json`;
+}
+function istSzenenSnapshotDatei(name) {
+  return name.startsWith(SZENEN_SNAPSHOT_PREFIX) && name.endsWith(".json");
+}
+var maxTsOf = (events) => {
+  let max = 0;
+  for (const event of events) if (event.ts > max) max = event.ts;
+  return max;
+};
+function buildSzenenSnapshot(base, neue, neuePfade = []) {
+  const events = [...base?.events ?? [], ...neue];
+  const paths = [...base?.consumed.paths ?? [], ...neuePfade.map(basisname)];
+  return {
+    schema_version: SZENEN_SNAPSHOT_SCHEMA_VERSION,
+    consumed: { count: events.length, max_ts: maxTsOf(events), paths },
+    events
+  };
+}
+function basisname(pfad) {
+  return pfad.split("/").pop() ?? pfad;
+}
+function aufgenommeneDateien(snapshot) {
+  return new Set(snapshot ? snapshot.consumed.paths : []);
+}
+function parseSzenenSnapshot(raw, herkunft) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`Szenen-Snapshot ${herkunft}: kein Objekt, sondern ${typeof raw}.`);
+  }
+  const obj = raw;
+  if (obj.schema_version !== SZENEN_SNAPSHOT_SCHEMA_VERSION) {
+    throw new Error(
+      `Szenen-Snapshot ${herkunft}: schema_version ${String(obj.schema_version)} wird nicht gelesen, erwartet ${SZENEN_SNAPSHOT_SCHEMA_VERSION}.`
+    );
+  }
+  if (!Array.isArray(obj.events)) {
+    throw new Error(`Szenen-Snapshot ${herkunft}: "events" fehlt oder ist kein Array.`);
+  }
+  const events = obj.events;
+  for (const [i, event] of events.entries()) {
+    if (!event || typeof event.type !== "string" || typeof event.ts !== "number") {
+      throw new Error(
+        `Szenen-Snapshot ${herkunft}: Ereignis ${i} hat keinen Typ oder keinen Zeitstempel.`
+      );
+    }
+  }
+  const consumed = obj.consumed;
+  if (!consumed || typeof consumed.count !== "number" || typeof consumed.max_ts !== "number") {
+    throw new Error(`Szenen-Snapshot ${herkunft}: "consumed" fehlt oder ist unvollstaendig.`);
+  }
+  if (!Array.isArray(consumed.paths)) {
+    throw new Error(
+      `Szenen-Snapshot ${herkunft}: "consumed.paths" fehlt. Ohne die aufgenommenen Dateinamen laesst sich nicht entscheiden, welche Datei in events/ noch aussteht.`
+    );
+  }
+  if (consumed.count !== events.length) {
+    throw new Error(
+      `Szenen-Snapshot ${herkunft}: consumed.count ${consumed.count} passt nicht zu ${events.length} Ereignis(sen) in der Datei \u2014 die Datei ist unvollstaendig.`
+    );
+  }
+  const echt = maxTsOf(events);
+  if (consumed.max_ts !== echt) {
+    throw new Error(
+      `Szenen-Snapshot ${herkunft}: consumed.max_ts ${consumed.max_ts} passt nicht zum groessten Zeitstempel ${echt} in der Datei.`
+    );
+  }
+  return { schema_version: SZENEN_SNAPSHOT_SCHEMA_VERSION, consumed, events };
+}
+function mergeSnapshotAndPending(snapshot, pending, bereitsImSnapshot = 0) {
+  if (!snapshot) return { events: pending, bereitsImSnapshot };
+  return { events: [...snapshot.events, ...pending], bereitsImSnapshot };
+}
+
+// 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 warten2 = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
+    await schlafen(warten2);
+  }
+  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 findLatestSzenenSnapshotPath(namespace, token) {
+  const files = await hfListDir(namespace, "", token);
+  const treffer = files.filter((f) => f.type === "file" && istSzenenSnapshotDatei(f.path.split("/").pop() || "")).map((f) => f.path).sort((a, b) => b.localeCompare(a));
+  return treffer[0] ?? null;
+}
+async function loadLatestSzenenSnapshot(namespace, token) {
+  const pfad = await findLatestSzenenSnapshotPath(namespace, token);
+  if (!pfad) return null;
+  return parseSzenenSnapshot(await hfDownloadJsonByPath(pfad, token), pfad);
+}
+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
+import JSZip from "jszip";
+import { uploadFile } from "@huggingface/hub";
+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 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;
+}
 
 // src/lib/szenen/viewPort.ts
 function capabilitiesOf(port) {
@@ -5318,8 +5699,8 @@ async function leseBilderAusZip(datei) {
       `${name} ist ${mb(datei.size)} MB gro\xDF \u2014 die Grenze liegt bei ${UPLOAD_MAX_BYTES / 1024 / 1024} MB.`
     );
   }
-  const { default: JSZip } = await import("jszip");
-  const archiv = await JSZip.loadAsync(datei).catch((fehler4) => {
+  const { default: JSZip2 } = await import("jszip");
+  const archiv = await JSZip2.loadAsync(datei).catch((fehler4) => {
     throw new Error(
       `${name} konnte nicht als ZIP gelesen werden: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
     );
@@ -13409,11 +13790,20 @@ function createHfElementStore(options) {
 
 // src/lib/szenen/hfEventChannel.ts
 function createHfEventChannel(options) {
-  const { namespace, token, sinceTs = 0 } = options;
+  const { namespace, token, sinceTs = 0, ohneSnapshot = false } = options;
   const knownPaths = /* @__PURE__ */ new Set();
   let cachedRawEvents = [];
   let syncInFlight = null;
+  let snapshot = null;
+  let snapshotGeladen = ohneSnapshot;
   const refresh = async () => {
+    if (!snapshotGeladen) {
+      snapshot = await loadLatestSzenenSnapshot(namespace, token);
+      snapshotGeladen = true;
+      for (const name of aufgenommeneDateien(snapshot)) {
+        knownPaths.add(`${namespace}events/${name}`);
+      }
+    }
     const neue = await loadPendingEvents(namespace, token, sinceTs, knownPaths);
     if (neue.length) cachedRawEvents = [...cachedRawEvents, ...neue];
   };
@@ -13428,12 +13818,13 @@ function createHfEventChannel(options) {
   return {
     async readEvents() {
       await sync();
-      return cachedRawEvents.filter((event) => typeof event.type === "string" && event.type.startsWith(SZENEN_EVENT_PREFIX)).map((event) => ({
+      const pending = cachedRawEvents.filter((event) => typeof event.type === "string" && event.type.startsWith(SZENEN_EVENT_PREFIX)).map((event) => ({
         type: event.type,
         payload: event.payload,
         clientId: event.clientId,
         ts: event.ts
       }));
+      return mergeSnapshotAndPending(snapshot, pending).events;
     },
     async appendEvent(type, payload) {
       if (!type.startsWith(SZENEN_EVENT_PREFIX)) {
@@ -15099,7 +15490,7 @@ function createHfImageStore(options) {
   const now = options.now ?? (() => Date.now());
   const versuche = options.leseVersuche ?? 4;
   const basisMs = options.leseBasisMs ?? 400;
-  const schlafen = options.schlafen ?? warten;
+  const schlafen2 = options.schlafen ?? warten;
   const abgelegt = /* @__PURE__ */ new Map();
   const vorschauen = /* @__PURE__ */ new Map();
   const bekanntePfade = /* @__PURE__ */ new Set();
@@ -15196,7 +15587,7 @@ function createHfImageStore(options) {
       }
       const pfadTyp = typ ?? "image/png";
       for (let versuch = 0; versuch < versuche; versuch += 1) {
-        if (versuch > 0) await schlafen(basisMs * 2 ** (versuch - 1));
+        if (versuch > 0) await schlafen2(basisMs * 2 ** (versuch - 1));
         const base64 = await hfLoadImageAsBase64(
           id,
           token,
@@ -16021,6 +16412,28 @@ function createFlowSzenenViewPort(options) {
 }
 
 export {
+  SZENEN_SNAPSHOT_SCHEMA_VERSION,
+  SZENEN_SNAPSHOT_PREFIX,
+  SZENEN_SNAPSHOT_FILE,
+  szenenSnapshotFilename,
+  istSzenenSnapshotDatei,
+  buildSzenenSnapshot,
+  parseSzenenSnapshot,
+  mergeSnapshotAndPending,
+  hfListDir,
+  hfDownloadBinaryByPath,
+  hfUploadSmallFile,
+  hfBatchArchive,
+  tsFromEventPath,
+  loadPendingEvents,
+  getSessionClientId,
+  writeHFEvent,
+  getHFToken,
+  setHFToken,
+  loadHFState,
+  hfBootstrapFromLegacy,
+  hfUploadImage,
+  hfLoadImageAsBase64,
   applyEvents,
   capabilitiesOf,
   unsupportedReason,

package/dist/{hfEventTypes-Dkfrcd_t.d.mts → hfEventTypes-BUztJySs.d.mts}

@@ -43,16 +43,6 @@ interface ProjectSettings {
     seed: number;
     seedMode: 'random' | 'fixed';
 }
-interface ProjectMeta {
-    id: string;
-    name: string;
-    saved_at: string;
-    size: number;
-}
-interface SyncDiff {
-    localOnly: Generation[];
-    serverOnly: Generation[];
-}
 interface LabFrame {
     id: string;
     base64: string;
@@ -238,4 +228,4 @@ interface TaskRequestedPayload {
     expiresAt?: number;
 }
 
-export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type Generation as G, type HFEvent as H, type ImageAddedPayload as I, type LabFrame as L, type MetadataUpdatedPayload as M, type ProjectMeta as P, type SelectedLabImage as S, type TagOption as T, type WorkspaceTags as W, type FlowSdk as a, type FlowTextGenerationOptions as b, type HFEventVersion as c, type HFFileInfo as d, type HFMetadataEntry as e, type HFStateMeta as f, type HFStateSnapshot as g, type LabItem as h, type LabServices as i, type ProjectSettings as j, type SelectedTag as k, type SyncDiff as l, type TagUpsertedPayload as m, buildFallbackPrompt as n, buildGenerationPrompt as o, buildImageGenerationOptions as p, buildPromptTabPayload as q, cleanAiResponse as r, createFlowServices as s, createFlowTextGenerationPort as t, interpretSdkError as u, parsePromptResponse as v };
+export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type Generation as G, type HFEvent as H, type ImageAddedPayload as I, type LabFrame as L, type MetadataUpdatedPayload as M, type ProjectSettings as P, type SelectedLabImage as S, type TagOption as T, type WorkspaceTags as W, type FlowSdk as a, type FlowTextGenerationOptions as b, type HFEventVersion as c, type HFFileInfo as d, type HFMetadataEntry as e, type HFStateMeta as f, type HFStateSnapshot as g, type LabItem as h, type LabServices as i, type SelectedTag as j, type TagUpsertedPayload as k, buildFallbackPrompt as l, buildGenerationPrompt as m, buildImageGenerationOptions as n, buildPromptTabPayload as o, cleanAiResponse as p, createFlowServices as q, createFlowTextGenerationPort as r, interpretSdkError as s, parsePromptResponse as t };

package/dist/{hfEventTypes-C_PX6RFR.d.ts → hfEventTypes-fAdA-0A9.d.ts}

@@ -43,16 +43,6 @@ interface ProjectSettings {
     seed: number;
     seedMode: 'random' | 'fixed';
 }
-interface ProjectMeta {
-    id: string;
-    name: string;
-    saved_at: string;
-    size: number;
-}
-interface SyncDiff {
-    localOnly: Generation[];
-    serverOnly: Generation[];
-}
 interface LabFrame {
     id: string;
     base64: string;
@@ -238,4 +228,4 @@ interface TaskRequestedPayload {
     expiresAt?: number;
 }
 
-export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type Generation as G, type HFEvent as H, type ImageAddedPayload as I, type LabFrame as L, type MetadataUpdatedPayload as M, type ProjectMeta as P, type SelectedLabImage as S, type TagOption as T, type WorkspaceTags as W, type FlowSdk as a, type FlowTextGenerationOptions as b, type HFEventVersion as c, type HFFileInfo as d, type HFMetadataEntry as e, type HFStateMeta as f, type HFStateSnapshot as g, type LabItem as h, type LabServices as i, type ProjectSettings as j, type SelectedTag as k, type SyncDiff as l, type TagUpsertedPayload as m, buildFallbackPrompt as n, buildGenerationPrompt as o, buildImageGenerationOptions as p, buildPromptTabPayload as q, cleanAiResponse as r, createFlowServices as s, createFlowTextGenerationPort as t, interpretSdkError as u, parsePromptResponse as v };
+export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type Generation as G, type HFEvent as H, type ImageAddedPayload as I, type LabFrame as L, type MetadataUpdatedPayload as M, type ProjectSettings as P, type SelectedLabImage as S, type TagOption as T, type WorkspaceTags as W, type FlowSdk as a, type FlowTextGenerationOptions as b, type HFEventVersion as c, type HFFileInfo as d, type HFMetadataEntry as e, type HFStateMeta as f, type HFStateSnapshot as g, type LabItem as h, type LabServices as i, type SelectedTag as j, type TagUpsertedPayload as k, buildFallbackPrompt as l, buildGenerationPrompt as m, buildImageGenerationOptions as n, buildPromptTabPayload as o, cleanAiResponse as p, createFlowServices as q, createFlowTextGenerationPort as r, interpretSdkError as s, parsePromptResponse as t };