@rslsp1/fa-app-tools 2.0.78 → 2.0.81

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

@@ -3,64 +3,68 @@ import JSZip from "jszip";
 import { uploadFile } from "@huggingface/hub";
 
 // 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 {
-  }
-}
+var CURRENT_EVENT_VERSION = { major: 1, minor: 0 };
+
+// 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));
+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 fetch(treeUrl(namespace, subdir), {
+  const res = await mitGeduld(() => 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(
+  const res = await mitGeduld(() => 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(
+  const res = await mitGeduld(() => 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);
+function toBase64(text) {
+  const bytes = new TextEncoder().encode(text);
   let binary = "";
   bytes.forEach((b) => binary += String.fromCharCode(b));
-  const b64 = btoa(binary);
+  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: b64 } })
+      JSON.stringify({ key: "file", value: { path: repoPath, encoding: "base64", content: toBase64(content) } })
     ].join("\n")
   });
   if (!res.ok) {
@@ -71,15 +75,10 @@ async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${r
 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 } })
-      ];
-    })
+    ...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",
@@ -98,40 +97,42 @@ function tsFromEventPath(repoPath) {
   const ts = Date.parse(iso);
   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, 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) : {}
+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 = await Promise.all(
-    pending.map(async (f) => {
-      const result = await hfDownloadJsonByPath(f.path, token);
-      knownPaths?.add(f.path);
-      return result;
-    })
-  );
+  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;
@@ -139,8 +140,12 @@ function getSessionClientId() {
 function tsToFilename(ts) {
   return new Date(ts).toISOString().replace(/:/g, "-").replace(".", "-");
 }
-async function writeHFEvent(namespace, token, type, payload, prevTs) {
-  const ts = Date.now();
+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,
@@ -150,11 +155,49 @@ async function writeHFEvent(namespace, token, type, payload, prevTs) {
     clientId: SESSION_CLIENT_ID,
     payload
   };
-  const filename = `${tsToFilename(ts)}_${uuid}.json`;
+  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);
@@ -323,19 +366,20 @@ async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeTy
 }
 
 export {
-  HF_TOKEN_KEY,
-  getHFToken,
-  setHFToken,
   hfListDir,
   hfDownloadJsonByPath,
   hfDownloadBinaryByPath,
   hfUploadSmallFile,
   hfBatchArchive,
   tsFromEventPath,
-  loadHFState,
   loadPendingEvents,
+  listEventPaths,
   getSessionClientId,
   writeHFEvent,
+  HF_TOKEN_KEY,
+  getHFToken,
+  setHFToken,
+  loadHFState,
   hfBootstrapFromLegacy,
   hfListProjects,
   hfDownloadProject,

package/dist/contracts-DdYOMBl9.d.mts

@@ -0,0 +1,166 @@
+/** Was der Port zurückgeben kann. Kein stilles `undefined`. */
+type TextGenerationResult = {
+    kind: 'ok';
+    text: string;
+    model_id: string;
+    provider: string;
+} | {
+    kind: 'failed';
+    /** Fehlerklassen aus `prompt-derivation.md` §6. */
+    class: 'safety_blocked' | 'finish_reason' | 'empty_content' | 'provider_error';
+    message: string;
+    model_id: string;
+    provider: string;
+    /** Provider-Angaben **unverändert**, nicht zusammengefasst. */
+    provider_detail?: unknown;
+};
+/** Ein Bild als Modelleingabe — Daten und der Typ, unter dem sie zu lesen sind. */
+interface TextGenerationImage {
+    /** Base64, ohne `data:`-Praefix. */
+    data: string;
+    /** Der tatsaechliche Typ, etwa `image/png`. Nie geraten. */
+    mime_type: string;
+}
+interface TextGenerationRequest {
+    systemInstruction: string;
+    prompt: string;
+    /** `'json'` schaltet jede für Prosa gedachte Nachbereinigung ab (D-56). */
+    responseFormat: 'text' | 'json';
+    /**
+     * Optionale Bilder als Eingabe (D-53). Seit Stufe 6.5 mit Konsument: die
+     * Szenenrekonstruktion.
+     *
+     * Bis dahin waren es nackte Base64-Zeichenketten. Der Serveradapter musste
+     * daraus einen MIME-Typ raten und schrieb `image/jpeg` an jedes Bild — ein
+     * PNG wurde damit falsch deklariert. Der Typ gehört zum Bild, nicht zur
+     * Vermutung des Adapters.
+     */
+    images?: readonly TextGenerationImage[];
+    /** Voreinstellung bleibt die des Hosts; der Renderer hebt sie an (D-56). */
+    thinkingLevel?: 'low' | 'medium' | 'high';
+}
+/**
+ * Textgenerierung mit optionalen Bildern — die einzige Fähigkeit, die der
+ * Prompt-Lauf voraussetzt (D-53).
+ */
+interface TextGenerationPort {
+    generate(request: TextGenerationRequest): Promise<TextGenerationResult>;
+}
+/**
+ * Eine deterministische Antwort zur Renderer-Eingabe.
+ *
+ * Sie nennt **jeden** Knoten (D-21) und richtet sich nach den Fähigkeiten des
+ * Zielmodells — dadurch läuft der echte Parser- und Schemapfad, nur ohne
+ * Provider. Eine Simulation, die die Prüfungen umginge, wiese nichts nach.
+ *
+ * Sie liegt **hier**, in der Testfläche der Bibliothek, und nicht im
+ * Serveradapter. Der Unterschied ist nicht kosmetisch: Ein Produktivadapter,
+ * der bei fehlender Konfiguration selbst eine gültige Antwort erfindet, macht
+ * aus einem Konfigurationsfehler einen gespeicherten Lauf. Genau das war der
+ * Befund des Umsetzungsreviews.
+ */
+declare function simulatedAnswerFor(request: TextGenerationRequest): string | null;
+/** Kennzeichnung eines simulierten Laufs — im Bestand unverwechselbar. */
+declare const SIMULATION_PROVIDER = "simulation";
+/**
+ * Ein deterministischer Port ohne Provider.
+ *
+ * Für Tests **und** für eine ausdrücklich angeforderte Simulation in der
+ * Entwicklung. Er ist nie ein Rückfall: Wer ihn benutzt, hat ihn gewählt, und
+ * der gespeicherte Lauf trägt `provider: 'simulation'`.
+ */
+declare function createSimulationTextGenerationPort(): TextGenerationPort;
+/**
+ * Ein Port mit frei wählbarer Antwort — für Tests, die einen bestimmten
+ * Ausgang brauchen. Protokolliert, was er bekommen hat.
+ */
+declare function createFakeTextGenerationPort(antwort: TextGenerationResult | ((request: TextGenerationRequest) => TextGenerationResult)): TextGenerationPort & {
+    calls: TextGenerationRequest[];
+};
+
+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;
+};
+
+export { type CommandResult as C, type FeatureSliceId as F, type LoadResult as L, type PersistedSlice as P, type QueryResult as Q, type RequestContext as R, SIMULATION_PROVIDER as S, type TextGenerationPort as T, type WorkspacePersistence as W, type PersistenceDescriptor as a, type SliceContract as b, type TextGenerationRequest as c, type TextGenerationResult as d, type WorkspaceTabId as e, type WriteResult as f, createFakeTextGenerationPort as g, createSimulationTextGenerationPort as h, simulatedAnswerFor as s };

package/dist/contracts-DdYOMBl9.d.ts

@@ -0,0 +1,166 @@
+/** Was der Port zurückgeben kann. Kein stilles `undefined`. */
+type TextGenerationResult = {
+    kind: 'ok';
+    text: string;
+    model_id: string;
+    provider: string;
+} | {
+    kind: 'failed';
+    /** Fehlerklassen aus `prompt-derivation.md` §6. */
+    class: 'safety_blocked' | 'finish_reason' | 'empty_content' | 'provider_error';
+    message: string;
+    model_id: string;
+    provider: string;
+    /** Provider-Angaben **unverändert**, nicht zusammengefasst. */
+    provider_detail?: unknown;
+};
+/** Ein Bild als Modelleingabe — Daten und der Typ, unter dem sie zu lesen sind. */
+interface TextGenerationImage {
+    /** Base64, ohne `data:`-Praefix. */
+    data: string;
+    /** Der tatsaechliche Typ, etwa `image/png`. Nie geraten. */
+    mime_type: string;
+}
+interface TextGenerationRequest {
+    systemInstruction: string;
+    prompt: string;
+    /** `'json'` schaltet jede für Prosa gedachte Nachbereinigung ab (D-56). */
+    responseFormat: 'text' | 'json';
+    /**
+     * Optionale Bilder als Eingabe (D-53). Seit Stufe 6.5 mit Konsument: die
+     * Szenenrekonstruktion.
+     *
+     * Bis dahin waren es nackte Base64-Zeichenketten. Der Serveradapter musste
+     * daraus einen MIME-Typ raten und schrieb `image/jpeg` an jedes Bild — ein
+     * PNG wurde damit falsch deklariert. Der Typ gehört zum Bild, nicht zur
+     * Vermutung des Adapters.
+     */
+    images?: readonly TextGenerationImage[];
+    /** Voreinstellung bleibt die des Hosts; der Renderer hebt sie an (D-56). */
+    thinkingLevel?: 'low' | 'medium' | 'high';
+}
+/**
+ * Textgenerierung mit optionalen Bildern — die einzige Fähigkeit, die der
+ * Prompt-Lauf voraussetzt (D-53).
+ */
+interface TextGenerationPort {
+    generate(request: TextGenerationRequest): Promise<TextGenerationResult>;
+}
+/**
+ * Eine deterministische Antwort zur Renderer-Eingabe.
+ *
+ * Sie nennt **jeden** Knoten (D-21) und richtet sich nach den Fähigkeiten des
+ * Zielmodells — dadurch läuft der echte Parser- und Schemapfad, nur ohne
+ * Provider. Eine Simulation, die die Prüfungen umginge, wiese nichts nach.
+ *
+ * Sie liegt **hier**, in der Testfläche der Bibliothek, und nicht im
+ * Serveradapter. Der Unterschied ist nicht kosmetisch: Ein Produktivadapter,
+ * der bei fehlender Konfiguration selbst eine gültige Antwort erfindet, macht
+ * aus einem Konfigurationsfehler einen gespeicherten Lauf. Genau das war der
+ * Befund des Umsetzungsreviews.
+ */
+declare function simulatedAnswerFor(request: TextGenerationRequest): string | null;
+/** Kennzeichnung eines simulierten Laufs — im Bestand unverwechselbar. */
+declare const SIMULATION_PROVIDER = "simulation";
+/**
+ * Ein deterministischer Port ohne Provider.
+ *
+ * Für Tests **und** für eine ausdrücklich angeforderte Simulation in der
+ * Entwicklung. Er ist nie ein Rückfall: Wer ihn benutzt, hat ihn gewählt, und
+ * der gespeicherte Lauf trägt `provider: 'simulation'`.
+ */
+declare function createSimulationTextGenerationPort(): TextGenerationPort;
+/**
+ * Ein Port mit frei wählbarer Antwort — für Tests, die einen bestimmten
+ * Ausgang brauchen. Protokolliert, was er bekommen hat.
+ */
+declare function createFakeTextGenerationPort(antwort: TextGenerationResult | ((request: TextGenerationRequest) => TextGenerationResult)): TextGenerationPort & {
+    calls: TextGenerationRequest[];
+};
+
+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;
+};
+
+export { type CommandResult as C, type FeatureSliceId as F, type LoadResult as L, type PersistedSlice as P, type QueryResult as Q, type RequestContext as R, SIMULATION_PROVIDER as S, type TextGenerationPort as T, type WorkspacePersistence as W, type PersistenceDescriptor as a, type SliceContract as b, type TextGenerationRequest as c, type TextGenerationResult as d, type WorkspaceTabId as e, type WriteResult as f, createFakeTextGenerationPort as g, createSimulationTextGenerationPort as h, simulatedAnswerFor as s };

package/dist/flowTextGenerationPort-CeDUFutP.d.mts

@@ -0,0 +1,73 @@
+import { T as TextGenerationPort } from './contracts-DdYOMBl9.mjs';
+
+declare function buildGenerationPrompt(hierarchyText: string, mode?: 'literal' | 'creative'): string;
+declare function buildFallbackPrompt(hierarchyText: string): string;
+declare function cleanAiResponse(text: string): string;
+declare function buildImageGenerationOptions(prompt: string, aspectRatio: string, model: string, referenceMediaId?: string): Record<string, any>;
+interface SelectedTag {
+    label: string;
+    value: string;
+    category: string;
+}
+declare function buildPromptTabPayload(selectedTags: SelectedTag[], instructions: string, rules: string, treeText?: string): string;
+declare function parsePromptResponse(raw: string): {
+    prompt: string;
+    feedback: string | null;
+};
+interface FlowSdkImage {
+    base64: string;
+    mimeType: string;
+}
+interface FlowTextGenerationOptions {
+    images?: FlowSdkImage[];
+    systemInstruction?: string;
+    responseFormat?: 'text' | 'json';
+    thinkingLevel?: 'low' | 'medium' | 'high';
+}
+interface FlowSdk {
+    generate: {
+        image: (options: Record<string, any>) => Promise<{
+            base64: string;
+            mediaId: string;
+        }>;
+        text: (prompt: string, options?: {
+            systemInstruction?: string;
+            thinkingLevel?: string;
+            images?: FlowSdkImage[];
+        }) => Promise<{
+            text: string;
+        }>;
+    };
+    download: (args: {
+        base64: string;
+        mimeType: string;
+        filename: string;
+    }) => Promise<void>;
+    media: {
+        selectMultiple: (args: {
+            filter: string;
+        }) => Promise<any[]>;
+    };
+}
+declare function createFlowServices(Flow: FlowSdk): {
+    generateImage: (options: Record<string, any>) => Promise<{
+        base64: string;
+        mediaId: string;
+    }>;
+    generateText: (text: string, options?: FlowTextGenerationOptions) => Promise<string>;
+};
+declare function interpretSdkError(err: any): Error;
+
+type FlowGenerateText = (prompt: string, options?: FlowTextGenerationOptions) => Promise<string>;
+interface CreateFlowTextGenerationPortOptions {
+    provider?: string;
+    modelId?: string;
+}
+/**
+ * Adapts the existing Flow SDK service to the host-neutral Szenen contract.
+ * It deliberately does not parse or validate the response: that happens once
+ * in `runPromptDerivation`, identically for every host.
+ */
+declare function createFlowTextGenerationPort(generateText: FlowGenerateText, options?: CreateFlowTextGenerationPortOptions): TextGenerationPort;
+
+export { type CreateFlowTextGenerationPortOptions as C, type FlowGenerateText as F, type SelectedTag as S, type FlowSdk as a, type FlowTextGenerationOptions as b, buildFallbackPrompt as c, buildGenerationPrompt as d, buildImageGenerationOptions as e, buildPromptTabPayload as f, cleanAiResponse as g, createFlowServices as h, createFlowTextGenerationPort as i, interpretSdkError as j, parsePromptResponse as p };