@rslsp1/fa-app-tools 7.0.1 → 7.4.0

package/dist/szenen.js

@@ -40,6 +40,7 @@ __export(szenen_exports, {
   DERIVABLE_TYPES: () => DERIVABLE_TYPES,
   ELEMENT_VERSION_SCHEMA_FILE: () => ELEMENT_VERSION_SCHEMA_FILE,
   FLOW_EXECUTION_PATH: () => FLOW_EXECUTION_PATH,
+  MCP_CLIENT_PROVIDER: () => MCP_CLIENT_PROVIDER,
   PROBE_VERSION_ID: () => PROBE_VERSION_ID,
   PROMPT_RULE_EFFECT: () => PROMPT_RULE_EFFECT,
   REFERENCE_FIELD: () => REFERENCE_FIELD,
@@ -54,8 +55,12 @@ __export(szenen_exports, {
   SZENEN_EVENT_TYPES: () => SZENEN_EVENT_TYPES,
   SZENEN_ITEM_PREFIX: () => SZENEN_ITEM_PREFIX,
   SZENEN_SCHEMAS: () => SZENEN_SCHEMAS,
+  SZENEN_SNAPSHOT_FILE: () => SZENEN_SNAPSHOT_FILE,
+  SZENEN_SNAPSHOT_PREFIX: () => SZENEN_SNAPSHOT_PREFIX,
+  SZENEN_SNAPSHOT_SCHEMA_VERSION: () => SZENEN_SNAPSHOT_SCHEMA_VERSION,
   SzenenView: () => SzenenView,
   UNCHECKED_PUBLISH_RULES: () => UNCHECKED_PUBLISH_RULES,
+  UNVERIFIED_MODEL_ID: () => UNVERIFIED_MODEL_ID,
   UPLOAD_MAX_BYTES: () => UPLOAD_MAX_BYTES,
   UnsupportedSchemaError: () => UnsupportedSchemaError,
   VersionDagError: () => VersionDagError,
@@ -66,6 +71,7 @@ __export(szenen_exports, {
   buildDerivationSystemInstruction: () => buildSystemInstruction2,
   buildDerivationUserPrompt: () => buildUserPrompt2,
   buildSystemInstruction: () => buildSystemInstruction,
+  buildSzenenSnapshot: () => buildSzenenSnapshot,
   buildUserPrompt: () => buildUserPrompt,
   buildVersionDag: () => buildVersionDag,
   callOptional: () => callOptional,
@@ -96,14 +102,18 @@ __export(szenen_exports, {
   checkSzenenBatchOrigin: () => checkSzenenBatchOrigin,
   checkTitle: () => checkTitle,
   checkWriteDraftInput: () => checkWriteDraftInput,
+  claimWon: () => claimWon,
   collectImageBatches: () => collectImageBatches,
   collectImageGenerationOrders: () => collectImageGenerationOrders,
+  collectImageJobs: () => collectImageJobs,
+  collectPromptOperations: () => collectPromptOperations,
   collectPromptRuns: () => collectPromptRuns,
   collectProviderChecks: () => collectProviderChecks,
   collectSceneDerivationRecoveries: () => collectSceneDerivationRecoveries,
   collectSceneDerivations: () => collectSceneDerivations,
   collectVersionRefs: () => collectVersionRefs2,
   compileSchemas: () => compileSchemas,
+  completePromptOperation: () => completePromptOperation,
   createBrowserTextGenerationPort: () => createBrowserTextGenerationPort,
   createClientDerivationPort: () => createClientDerivationPort,
   createClientRunPort: () => createClientRunPort,
@@ -121,6 +131,7 @@ __export(szenen_exports, {
   createHfImageLibrary: () => createHfImageLibrary,
   createHfImageStore: () => createHfImageStore,
   createImageGenerationPort: () => createImageGenerationPort,
+  createImageJobPort: () => createImageJobPort,
   createInMemoryEventChannel: () => createInMemoryEventChannel,
   createMemoryViewPort: () => createMemoryViewPort,
   createSimulationSceneDerivationPort: () => createSimulationSceneDerivationPort,
@@ -139,6 +150,8 @@ __export(szenen_exports, {
   findExecutableImageModel: () => findExecutableImageModel,
   findImageBatch: () => findImageBatch,
   findImageGenerationOrder: () => findImageGenerationOrder,
+  findImageJob: () => findImageJob,
+  findPromptOperation: () => findPromptOperation,
   findPromptRun: () => findPromptRun,
   findProviderCheck: () => findProviderCheck,
   findSceneDerivation: () => findSceneDerivation,
@@ -148,6 +161,7 @@ __export(szenen_exports, {
   formatSeedListe: () => formatSeedListe,
   freezeDraftChain: () => freezeDraftChain,
   freezeSceneWorkingState: () => freezeSceneWorkingState,
+  generationBatchIdOf: () => generationBatchIdOf,
   gesamtHerkunft: () => gesamtHerkunft,
   getSzenenSchemas: () => getSzenenSchemas,
   gruppiereZuItems: () => gruppiereZuItems,
@@ -156,14 +170,20 @@ __export(szenen_exports, {
   isOk: () => isOk,
   isProjectionCurrent: () => isProjectionCurrent,
   isSzenenItemId: () => isSzenenItemId,
+  istSzenenSnapshotDatei: () => istSzenenSnapshotDatei,
   istZipDatei: () => istZipDatei,
   itemIdForRun: () => itemIdForRun,
+  itemsAusBestand: () => itemsAusBestand,
+  jobsForPromptRun: () => jobsForPromptRun,
   ladeVorschauen: () => ladeVorschauen,
   leseBilderAusZip: () => leseBilderAusZip,
   linkFor: () => linkFor,
+  locatorAus: () => locatorAus,
   locatorTeile: () => locatorTeile,
   logRevisionOf: () => logRevisionOf,
+  mergeSnapshotAndPending: () => mergeSnapshotAndPending,
   mergeSzenenBatchOrigin: () => mergeSzenenBatchOrigin,
+  mimeTypAus: () => mimeTypAus,
   mitDefaultVorlage: () => mitDefaultVorlage,
   noticeFor: () => noticeFor,
   ordersForPromptRun: () => ordersForPromptRun,
@@ -171,8 +191,10 @@ __export(szenen_exports, {
   parseDerivationResponse: () => parseDerivationResponse,
   parseRunResponse: () => parseRunResponse,
   parseSeedListe: () => parseSeedListe,
+  parseSzenenSnapshot: () => parseSzenenSnapshot,
   preferredHeadRevisionOf: () => preferredHeadRevisionOf,
   preferredVersionId: () => preferredVersionId,
+  preparePromptOperation: () => preparePromptOperation,
   promptDiagnosticsOf: () => promptDiagnosticsOf,
   publishedHeadsOf: () => publishedHeadsOf,
   recoveriesForRun: () => recoveriesForRun,
@@ -185,19 +207,23 @@ __export(szenen_exports, {
   resolveShotPayload: () => resolveShotPayload,
   resolveTargetModelOver: () => resolveTargetModelOver,
   resolverFromQueries: () => resolverFromQueries,
+  responseContractOf: () => responseContractOf,
   roundOfRun: () => roundOfRun,
   rulesWithoutPromptEffect: () => rulesWithoutPromptEffect,
   runElementStoreContract: () => runElementStoreContract,
+  runOfOperation: () => runOfOperation,
   runPromptDerivation: () => runPromptDerivation,
   runPublishChecks: () => runPublishChecks,
   runSceneDerivation: () => runSceneDerivation,
   runStoreDifferential: () => runStoreDifferential,
+  sameResponseAs: () => sameResponseAs,
   sceneOnlyCapabilities: () => sceneOnlyCapabilities,
   scopeOfPath: () => scopeOfPath,
   seedFehlerText: () => seedFehlerText,
   selectableTargetModels: () => selectableTargetModels,
   showChain: () => showChain,
   simulatedAnswerFor: () => simulatedAnswerFor,
+  szenenSnapshotFilename: () => szenenSnapshotFilename,
   totalModelCalls: () => totalModelCalls,
   typAusBytes: () => typAusBytes,
   unclassifiedPublishRules: () => unclassifiedPublishRules,
@@ -4798,11 +4824,11 @@ async function resolveShotPayload(input) {
     };
   }
   const shot = shotPayload;
-  for (const fehler4 of ohneKettenReferenz(
+  for (const fehler5 of ohneKettenReferenz(
     validatePayload("shot", shotPayload).errors,
     chain ? "scene_setup_ref" : null
   )) {
-    diagnostics.push(diagnosticOfSchemaError(fehler4, `Shot ${shotElementId}`));
+    diagnostics.push(diagnosticOfSchemaError(fehler5, `Shot ${shotElementId}`));
   }
   let setup = null;
   let report = null;
@@ -4914,8 +4940,8 @@ async function resolveScenePayload(input) {
     "Kein Scene Setup, kein Shot: Der Lauf entsteht aus der Szene allein. Bildaufbau, Kamera und Zielmodell wurden nicht ergaenzt, sondern sind nicht vorhanden (D-135)."
   ];
   const diagnostics = [];
-  for (const fehler4 of validatePayload("scene", scenePayload).errors) {
-    diagnostics.push(diagnosticOfSchemaError(fehler4, `Szene ${sceneElementId}`));
+  for (const fehler5 of validatePayload("scene", scenePayload).errors) {
+    diagnostics.push(diagnosticOfSchemaError(fehler5, `Szene ${sceneElementId}`));
   }
   const faehig = sceneOnlyCapabilities(scenePayload);
   return komponiere({
@@ -5805,7 +5831,60 @@ var SZENEN_EVENT_TYPES = {
    * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig); gelesen
    * wird mit `collectImageBatches` (`imageBatchStore.ts`).
    */
-  imageBatchPersisted: "szenen.image_batch_persisted"
+  imageBatchPersisted: "szenen.image_batch_persisted",
+  /**
+   * Ein vorbereiteter Promptvorgang — der Durchstich „Szene → ChatGPT → Lauf".
+   *
+   * Der bestehende Promptpfad ruft das Modell selbst
+   * (`runPromptDerivation()`); ein aufrufendes Chatmodell formuliert dagegen
+   * **zwischen** zwei Werkzeugaufrufen. Damit zerfaellt der eine Vorgang in
+   * zwei, und der zweite braucht genau den Stand, den der erste eingefroren
+   * hat — sonst loeste der Abschluss die inzwischen geaenderte Szene neu auf
+   * und der Lauf behauptete eine Herkunft, die er nicht hat (D-22).
+   *
+   * Deshalb ein eigenes Ereignis und **kein** fluechtiger Prozesszustand: Der
+   * Snapshot ueberlebt Neustart, Hostwechsel und Sitzungsende, weil er im
+   * selben autoritativen Log liegt wie der Lauf, der daraus entsteht.
+   *
+   * Der Elementreducer ignoriert diesen Typ (`default:`-Zweig); gelesen wird
+   * mit `collectPromptOperations` (`scenePromptOperation.ts`).
+   */
+  promptOperationPrepared: "szenen.prompt_operation_prepared",
+  /**
+   * Ein Bildauftrag wartet auf einen ausfuehrenden Flow-Host.
+   *
+   * Die vorhandene Auftragshistorie (`imageGenerationStarted`) beginnt
+   * **unmittelbar vor** dem Provideraufruf und kennt deshalb keinen wartenden
+   * Auftrag. Genau der entsteht hier: Ein Chatmodell beauftragt ueber MCP ein
+   * Bild, der Auftrag wird dauerhaft abgelegt, und der Werkzeugaufruf endet
+   * sofort mit seiner Kennung — er haelt keine Antwort minutenlang offen.
+   *
+   * Traegt **keinen** Prompt: Der steht im referenzierten Lauf, und ihn hier
+   * zu kopieren waere eine zweite Wahrheit ueber denselben eingefrorenen Text
+   * (D-103).
+   */
+  imageJobRequested: "szenen.image_job_requested",
+  /**
+   * Ein Flow-Host beansprucht einen wartenden Bildauftrag.
+   *
+   * Ein append-only Log kennt kein Lock: Zwei Tabs koennen beide anhaengen.
+   * Deshalb ist die Uebernahme **nicht** der Append, sondern das Ergebnis
+   * einer deterministischen Schiedsregel darueber (`winningClaimOf`) — der
+   * erste Anspruch in Logreihenfolge gewinnt, und jeder Host liest nach
+   * seinem Append erneut, bevor er einen bezahlten Provideraufruf startet.
+   * Ein unterlegener Anspruch bleibt sichtbar stehen; er wird nicht geloescht,
+   * weil das Log das nicht kann und weil der Versuch ein Beleg ist.
+   */
+  imageJobClaimed: "szenen.image_job_claimed",
+  /**
+   * Der Bildauftrag ist erledigt — mit dem Ausgang, den der Host gesehen hat.
+   *
+   * Getrennt von `imageGenerationFinished`: Jenes gehoert zum bezahlten
+   * Provideraufruf, dieses zur Zustellung. Ein Auftrag kann fehlschlagen,
+   * **bevor** ein Provider gerufen wurde (abgelehntes Profil), und dann gibt
+   * es kein `imageGenerationFinished`, das den Wartenden erloesen wuerde.
+   */
+  imageJobSettled: "szenen.image_job_settled"
 };
 function sortForReplay(events) {
   return [...events].sort((a, b) => {
@@ -8291,10 +8370,89 @@ function bildEndungFuer(mimeType) {
   return "jpg";
 }
 
+// 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/hfEventLog.ts
-function treeUrl(namespace, subdir = "") {
+function treeUrl(namespace, subdir = "", revision = "main") {
   const parts = [namespace.replace(/\/$/, ""), subdir].filter(Boolean).join("/");
-  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/main${parts ? "/" + parts : ""}`;
+  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/${encodeURIComponent(revision)}${parts ? "/" + parts : ""}`;
 }
 var DROSSEL_VERSUCHE = 4;
 var DROSSEL_BASIS_MS = 400;
@@ -8327,8 +8485,8 @@ async function mitGeduld(anfrage) {
   }
   return letzte;
 }
-async function hfListDir(namespace, subdir, token) {
-  const res = await mitGeduld(() => holeMitZeitlimit(treeUrl(namespace, subdir), {
+async function hfListDir(namespace, subdir, token, revision = "main") {
+  const res = await mitGeduld(() => holeMitZeitlimit(treeUrl(namespace, subdir, revision), {
     headers: { Authorization: `Bearer ${token}` }
   }));
   if (res.status === 404) return [];
@@ -8357,17 +8515,46 @@ function toBase64(text) {
   bytes.forEach((b) => binary += String.fromCharCode(b));
   return btoa(binary);
 }
-async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`) {
+var HfPreconditionFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HfPreconditionFailed";
+  }
+};
+async function hfRepoHead(token, revision = "main") {
+  const res = await mitGeduld(() => holeMitZeitlimit(
+    `${HF_BASE}/api/datasets/${HF_REPO}/revision/${encodeURIComponent(revision)}`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ));
+  if (!res.ok) {
+    throw new Error(`HF revision failed: ${res.status} ${res.statusText} (${revision})`);
+  }
+  const daten = await res.json();
+  if (typeof daten.sha !== "string" || daten.sha.length === 0) {
+    throw new Error(
+      `HF revision ${revision}: die Antwort traegt kein "sha". Erhaltene Felder: ${Object.keys(daten || {}).join(", ") || "(keine)"}.`
+    );
+  }
+  return daten.sha;
+}
+async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`, options) {
+  const kopf = { summary, description: "" };
+  if (options?.parentCommit) kopf.parentCommit = options.parentCommit;
   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: "header", value: kopf }),
       JSON.stringify({ key: "file", value: { path: repoPath, encoding: "base64", content: toBase64(content) } })
     ].join("\n")
   });
   if (!res.ok) {
     const err = await res.text().catch(() => "");
+    if (options?.parentCommit && (res.status === 412 || res.status === 409)) {
+      throw new HfPreconditionFailedError(
+        `HF commit abgelehnt: Der Branch hat sich seit ${options.parentCommit} bewegt (${res.status}). Es wurde nichts geschrieben.`
+      );
+    }
     throw new Error(`HF upload failed: ${res.status} \u2014 ${err.slice(0, 200)}`);
   }
 }
@@ -8399,8 +8586,8 @@ async function mitBegrenzterParallelitaet(count, limit, task) {
   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);
+async function loadPendingEvents(namespace, token, sinceTs, knownPaths, revision = "main") {
+  const files = await hfListDir(namespace, "events", token, revision);
   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);
@@ -8410,6 +8597,16 @@ async function loadPendingEvents(namespace, token, sinceTs, knownPaths) {
   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 tsToFilename(ts) {
   return new Date(ts).toISOString().replace(/:/g, "-").replace(".", "-");
@@ -8432,18 +8629,33 @@ async function writeHFEvent(namespace, token, type, payload, prevTs, options) {
   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}`);
+  await hfUploadSmallFile(
+    repoPath,
+    JSON.stringify(event, null, 2),
+    token,
+    `Event: ${type}`,
+    options?.parentCommit ? { parentCommit: options.parentCommit } : void 0
+  );
   return event;
 }
 
 // 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;
-  const refresh = async () => {
-    const neue = await loadPendingEvents(namespace, token, sinceTs, knownPaths);
+  let snapshot = null;
+  let snapshotGeladen = ohneSnapshot;
+  const refresh = async (revision = "main") => {
+    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, revision);
     if (neue.length) cachedRawEvents = [...cachedRawEvents, ...neue];
   };
   const sync = () => {
@@ -8454,15 +8666,34 @@ function createHfEventChannel(options) {
     }
     return syncInFlight;
   };
+  const sicht = () => {
+    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;
+  };
   return {
     async readEvents() {
       await sync();
-      return 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 sicht();
+    },
+    async readHead() {
+      return hfRepoHead(token);
+    },
+    async readEventsAt(revision) {
+      await refresh(revision);
+      return sicht();
+    },
+    async appendEventAt(type, payload, parentCommit) {
+      if (!type.startsWith(SZENEN_EVENT_PREFIX)) {
+        throw new Error(
+          `Event-Typ "${type}" gehoert nicht zur Domain szenen. Der geteilte Kanal wird ueber das Praefix "${SZENEN_EVENT_PREFIX}" getrennt.`
+        );
+      }
+      await writeHFEvent(namespace, token, type, payload, [], { ordered: true, parentCommit });
     },
     async appendEvent(type, payload) {
       if (!type.startsWith(SZENEN_EVENT_PREFIX)) {
@@ -8478,6 +8709,7 @@ function createHfEventChannel(options) {
 // src/lib/szenen/inMemoryEventChannel.ts
 function createInMemoryEventChannel(options = {}) {
   const log = options.shared ?? [];
+  const snapshot = options.snapshot ?? null;
   let tick = 0;
   const now = options.now ?? (() => ++tick);
   const clientId = options.clientId ?? "client-a";
@@ -8486,7 +8718,8 @@ function createInMemoryEventChannel(options = {}) {
       return log;
     },
     async readEvents() {
-      return log.map((event) => ({ ...event }));
+      const { events } = mergeSnapshotAndPending(snapshot, log);
+      return events.map((event) => ({ ...event }));
     },
     async appendEvent(type, payload) {
       log.push({ type, payload, clientId, ts: now() });
@@ -8495,7 +8728,7 @@ function createInMemoryEventChannel(options = {}) {
       log.push(event);
     },
     withClient(otherClientId) {
-      return createInMemoryEventChannel({ clientId: otherClientId, now, shared: log });
+      return createInMemoryEventChannel({ clientId: otherClientId, now, shared: log, snapshot });
     }
   };
   return channel;
@@ -10033,7 +10266,8 @@ function capabilitiesOf(port) {
     imageBatchHistory: typeof port.imageBatchHistory?.listBatchesForPromptRun === "function",
     imageOrderHistory: typeof port.imageBatchHistory?.listOrdersForPromptRun === "function",
     imageBatchWrite: typeof port.imageBatchWrite?.importBatch === "function",
-    imageGeneration: typeof port.imageGeneration?.startFromPromptRun === "function"
+    imageGeneration: typeof port.imageGeneration?.startFromPromptRun === "function",
+    imageJobs: typeof port.imageJobs?.claimAndRun === "function"
   };
 }
 function unsupportedReason(capability) {
@@ -10367,6 +10601,44 @@ function gruppiereZuItems(bilder) {
   items.sort((a, b) => b.juengstes - a.juengstes);
   return items.map((e) => e.item);
 }
+function locatorAus(itemId, position, anzahl) {
+  return anzahl === 1 ? itemId : `${itemId}-${position}`;
+}
+function mimeTypAus(dateiname) {
+  const n = dateiname.toLowerCase();
+  if (n.endsWith(".png")) return "image/png";
+  if (n.endsWith(".webp")) return "image/webp";
+  return "image/jpeg";
+}
+function passt(item, suche) {
+  const f = suche.trim().toLowerCase();
+  if (!f) return true;
+  return (item.title ?? "").toLowerCase().includes(f) || item.id.toLowerCase().includes(f);
+}
+function itemsAusBestand(items, options = {}) {
+  const suche = options.search ?? "";
+  const werke = [];
+  const passende = items.filter((i) => i && typeof i.id === "string" && i.id.length > 0 && passt(i, suche)).sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0) || (a.id < b.id ? 1 : a.id > b.id ? -1 : 0));
+  for (const item of passende) {
+    const galerie = Array.isArray(item.gallery) ? item.gallery : [];
+    const titel = item.title || item.id;
+    const bilder = [];
+    galerie.forEach((eintrag, position) => {
+      const datei = eintrag?.file;
+      if (!datei) return;
+      bilder.push({
+        mediaRef: locatorAus(item.id, position, galerie.length),
+        title: galerie.length === 1 ? titel : `${titel} \xB7 Bild ${position + 1}`,
+        mimeType: mimeTypAus(String(datei)),
+        thumbUrl: options.thumbUrl ? options.thumbUrl(String(datei)) : null
+      });
+    });
+    if (bilder.length === 0) continue;
+    werke.push({ itemRef: item.id, title: titel, images: bilder });
+    if (options.limit && werke.length >= options.limit) break;
+  }
+  return werke;
+}
 
 // src/lib/szenen/hfImageLibrary.ts
 function fehler(nachricht, retryable = false) {
@@ -12560,8 +12832,8 @@ function createFlowImageProvider(generateImage) {
             // Kein Seed: weder als Eingabe dokumentiert noch als Ausgabe
             // geliefert — nichts wird erfunden (D-107).
           });
-        } catch (fehler4) {
-          ersterFehler = fehler4 instanceof Error ? fehler4.message : String(fehler4);
+        } catch (fehler5) {
+          ersterFehler = fehler5 instanceof Error ? fehler5.message : String(fehler5);
           break;
         }
       }
@@ -12771,6 +13043,252 @@ function createHfImageBatchWrite(options) {
   };
 }
 
+// src/lib/szenen/imageJobStore.ts
+var istText7 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+var SETTLED_STATUS = ["succeeded", "partial", "failed", "rejected"];
+function collectImageJobs(events) {
+  const nachId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageJobRequested) continue;
+    const payload = event.payload;
+    if (!payload || !istText7(payload.job_id) || !istText7(payload.prompt_run_id)) continue;
+    if (nachId.has(payload.job_id)) continue;
+    nachId.set(payload.job_id, {
+      job_id: payload.job_id,
+      prompt_run_id: payload.prompt_run_id,
+      execution_target_model_key: payload.execution_target_model_key ?? "",
+      execution_profile_id: payload.execution_profile_id ?? "",
+      image_count: typeof payload.image_count === "number" ? payload.image_count : 0,
+      ...payload.aspect_ratio ? { aspect_ratio: payload.aspect_ratio } : {},
+      requested_by: payload.requested_by ?? "",
+      store_id: payload.store_id ?? "",
+      created_at: payload.created_at ?? "",
+      status: "pending",
+      claim_attempts: []
+    });
+  }
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageJobClaimed) continue;
+    const payload = event.payload;
+    if (!payload || !istText7(payload.job_id) || !istText7(payload.claim_id)) continue;
+    const auftrag = nachId.get(payload.job_id);
+    if (!auftrag) continue;
+    const anspruch = {
+      job_id: payload.job_id,
+      claim_id: payload.claim_id,
+      client_id: payload.client_id ?? "",
+      claimed_at: payload.claimed_at ?? ""
+    };
+    nachId.set(payload.job_id, {
+      ...auftrag,
+      claim: auftrag.claim ?? anspruch,
+      claim_attempts: [...auftrag.claim_attempts, anspruch],
+      status: auftrag.status === "pending" ? "claimed" : auftrag.status
+    });
+  }
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageJobSettled) continue;
+    const payload = event.payload;
+    if (!payload || !istText7(payload.job_id)) continue;
+    const auftrag = nachId.get(payload.job_id);
+    if (!auftrag) continue;
+    if (!auftrag.claim || auftrag.claim.claim_id !== payload.claim_id) continue;
+    if (auftrag.status !== "claimed") continue;
+    if (!SETTLED_STATUS.includes(payload.status)) continue;
+    nachId.set(payload.job_id, {
+      ...auftrag,
+      status: payload.status,
+      ...payload.generation_batch_id ? { generation_batch_id: payload.generation_batch_id } : {},
+      ...payload.item_id ? { item_id: payload.item_id } : {},
+      ...typeof payload.produced_count === "number" ? { produced_count: payload.produced_count } : {},
+      ...payload.diagnostic ? { diagnostic: payload.diagnostic } : {},
+      settled_at: payload.settled_at ?? ""
+    });
+  }
+  return [...nachId.values()];
+}
+function jobsForPromptRun(events, runId) {
+  return collectImageJobs(events).filter((j) => j.prompt_run_id === runId);
+}
+function findImageJob(events, jobId) {
+  return collectImageJobs(events).find((j) => j.job_id === jobId) ?? null;
+}
+function claimWon(job, claimId) {
+  return Boolean(job && job.claim && job.claim.claim_id === claimId);
+}
+function generationBatchIdOf(jobId) {
+  return `job-${jobId}`;
+}
+
+// src/lib/szenen/imageJobPort.ts
+var ANSPRUCH_VERSUCHE = 4;
+function fehler4(error, aktion) {
+  return {
+    message: `${aktion}: ${error instanceof Error ? error.message : String(error)}`
+  };
+}
+function createImageJobPort(options) {
+  const { channel, imageGeneration, storeId, clientId } = options;
+  const newClaimId = options.newClaimId ?? (() => crypto.randomUUID());
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    async listJobs(runId) {
+      try {
+        return { kind: "ok", value: jobsForPromptRun(await channel.readEvents(), runId) };
+      } catch (error) {
+        return {
+          kind: "error",
+          ...fehler4(error, `Die Bildauftraege des Laufs ${runId} konnten nicht gelesen werden`),
+          retryable: true
+        };
+      }
+    },
+    async claimAndRun(jobId) {
+      let letzterGrund = "";
+      for (let versuch = 1; versuch <= ANSPRUCH_VERSUCHE; versuch += 1) {
+        let kopf;
+        try {
+          kopf = await channel.readHead();
+        } catch (error) {
+          return {
+            kind: "error",
+            ...fehler4(error, `Der Kopf-Commit des Bestands war nicht lesbar; Bildauftrag ${jobId} wurde nicht uebernommen`),
+            retryable: true
+          };
+        }
+        let auftrag;
+        try {
+          auftrag = findImageJob(await channel.readEventsAt(kopf), jobId);
+        } catch (error) {
+          return {
+            kind: "error",
+            ...fehler4(error, `Der Bildauftrag ${jobId} konnte nicht gelesen werden`),
+            retryable: true
+          };
+        }
+        if (!auftrag) {
+          return {
+            kind: "rejected",
+            message: `Der Bildauftrag ${jobId} steht nicht im autoritativen Log dieses Bestands.`
+          };
+        }
+        if (auftrag.store_id !== storeId) {
+          return {
+            kind: "rejected",
+            message: `Der Bildauftrag ${jobId} gilt fuer den Bestand "${auftrag.store_id}", dieser Host arbeitet auf "${storeId}". Nutzer, Umgebung und Bestand muessen zusammenpassen.`
+          };
+        }
+        if (auftrag.status !== "pending") {
+          return {
+            kind: "lost",
+            job: auftrag,
+            message: `Der Bildauftrag ${jobId} ist bereits "${auftrag.status}"` + (auftrag.claim ? ` (Client ${auftrag.claim.client_id})` : "") + ". Er wird nicht erneut ausgefuehrt \u2014 ein zweiter Lauf waere ein zweites Mal bezahlte Rechenzeit."
+          };
+        }
+        const anspruch = {
+          job_id: jobId,
+          claim_id: newClaimId(),
+          client_id: clientId,
+          claimed_at: now().toISOString()
+        };
+        try {
+          await channel.appendEventAt(
+            SZENEN_EVENT_TYPES.imageJobClaimed,
+            anspruch,
+            kopf
+          );
+        } catch (error) {
+          if (istPreconditionFehler(error)) {
+            letzterGrund = error instanceof Error ? error.message : String(error);
+            continue;
+          }
+          return {
+            kind: "error",
+            ...fehler4(error, `Der Anspruch auf Bildauftrag ${jobId} konnte nicht angehaengt werden`),
+            retryable: true
+          };
+        }
+        const gewonnen = {
+          ...auftrag,
+          status: "claimed",
+          claim: anspruch,
+          claim_attempts: [...auftrag.claim_attempts, anspruch]
+        };
+        return await fuehreAus(gewonnen, anspruch, jobId);
+      }
+      return {
+        kind: "error",
+        message: `Der Bildauftrag ${jobId} liess sich in ${ANSPRUCH_VERSUCHE} Versuchen nicht exklusiv uebernehmen \u2014 der Bestand wird gerade von anderer Seite beschrieben (${letzterGrund}). Es wurde nichts ausgefuehrt und nichts bezahlt; ein neuer Versuch ist gefahrlos.`,
+        retryable: true
+      };
+    }
+  };
+  async function fuehreAus(gewonnen, anspruch, jobId) {
+    const ergebnis = await imageGeneration.startFromPromptRun({
+      runId: gewonnen.prompt_run_id,
+      generationBatchId: generationBatchIdOf(jobId),
+      executionTargetModelKey: gewonnen.execution_target_model_key,
+      executionProfileId: gewonnen.execution_profile_id,
+      imageCount: gewonnen.image_count,
+      ...gewonnen.aspect_ratio ? { aspectRatio: gewonnen.aspect_ratio } : {}
+    });
+    const abschluss = {
+      job_id: jobId,
+      claim_id: anspruch.claim_id,
+      ...abschlussFelder(ergebnis, jobId),
+      settled_at: now().toISOString()
+    };
+    try {
+      await channel.appendEvent(SZENEN_EVENT_TYPES.imageJobSettled, abschluss);
+    } catch {
+    }
+    const gelesen = await channel.readEvents().catch(() => null);
+    return {
+      kind: "ok",
+      job: (gelesen && findImageJob(gelesen, jobId)) ?? {
+        ...gewonnen,
+        status: abschluss.status,
+        ...abschluss.generation_batch_id ? { generation_batch_id: abschluss.generation_batch_id } : {},
+        ...abschluss.diagnostic ? { diagnostic: abschluss.diagnostic } : {},
+        settled_at: abschluss.settled_at
+      }
+    };
+  }
+}
+function istPreconditionFehler(error) {
+  return Boolean(error && typeof error === "object" && error.name === "HfPreconditionFailed");
+}
+function abschlussFelder(ergebnis, jobId) {
+  const batchId = generationBatchIdOf(jobId);
+  switch (ergebnis.kind) {
+    case "succeeded":
+      return {
+        status: "succeeded",
+        generation_batch_id: batchId,
+        item_id: ergebnis.batch.item_id,
+        produced_count: ergebnis.batch.images.length
+      };
+    case "partial":
+      return {
+        status: "partial",
+        generation_batch_id: batchId,
+        item_id: ergebnis.batch.item_id,
+        produced_count: ergebnis.produced,
+        diagnostic: `Angefordert ${ergebnis.requested}, geliefert ${ergebnis.produced}.`
+      };
+    case "failed":
+      return { status: "failed", produced_count: 0, diagnostic: ergebnis.message };
+    case "unsupported":
+      return {
+        status: "rejected",
+        produced_count: 0,
+        diagnostic: `Zielmodell "${ergebnis.targetModelKey}" ist in dieser Umgebung nicht ausfuehrbar: ${ergebnis.reason}`
+      };
+    default:
+      return { status: "rejected", produced_count: 0, diagnostic: ergebnis.message };
+  }
+}
+
 // src/lib/szenen/flowViewPort.ts
 var defaultContext = {
   async chainFor(contextId) {
@@ -12869,10 +13387,21 @@ function createFlowSzenenViewPort(options) {
     },
     ...options.now ? { now: options.now } : {}
   }) : void 0;
+  const kanalMitRevision = typeof channel.readHead === "function" && typeof channel.readEventsAt === "function" && typeof channel.appendEventAt === "function";
+  const imageJobs = imageGeneration && hatHfZugangsdaten && kanalMitRevision ? createImageJobPort({
+    channel,
+    imageGeneration,
+    // Dieselbe Form, in der der Server seinen Bestand kennt (`storeId`).
+    storeId: `hf:${options.namespace}`,
+    clientId: options.imageJobClientId ?? crypto.randomUUID(),
+    ...options.newImageJobClaimId ? { newClaimId: options.newImageJobClaimId } : {},
+    ...options.now ? { now: options.now } : {}
+  }) : void 0;
   const port = { elements, context, runs, derivation, imageBatchHistory };
   if (imageLibrary) port.imageLibrary = imageLibrary;
   if (imageBatchWrite) port.imageBatchWrite = imageBatchWrite;
   if (imageGeneration) port.imageGeneration = imageGeneration;
+  if (imageJobs) port.imageJobs = imageJobs;
   return port;
 }
 
@@ -13012,7 +13541,7 @@ var VERBOTEN_JE_HERKUNFT = {
   draft_chain: ["shot_version_id", "scene_setup_version_id"],
   scene_direct: ["shot_version_id", "shot_element_id", "scene_setup_version_id", "camera_id"]
 };
-function istText7(wert) {
+function istText8(wert) {
   return typeof wert === "string" && wert.trim().length > 0;
 }
 function isObject12(wert) {
@@ -13032,7 +13561,7 @@ function pruefeLaufherkunft(quelle) {
   }
   if (quelle.kind === "published") {
     for (const feld of ["shot_version_id", "scene_setup_version_id"]) {
-      if (!istText7(quelle[feld])) {
+      if (!istText8(quelle[feld])) {
         return { ok: false, message: `"source.${feld}" fehlt oder ist leer.` };
       }
     }
@@ -13043,11 +13572,11 @@ function pruefeLaufherkunft(quelle) {
     if (!isObject12(szene)) {
       return { ok: false, message: '"source.scene" muss ein Objekt sein.' };
     }
-    if (!istText7(szene.element_id)) {
+    if (!istText8(szene.element_id)) {
       return { ok: false, message: '"source.scene.element_id" fehlt oder ist leer.' };
     }
-    const ausEntwurf = istText7(szene.draft_id);
-    const ausVersion = istText7(szene.version_id);
+    const ausEntwurf = istText8(szene.draft_id);
+    const ausVersion = istText8(szene.version_id);
     if (ausEntwurf === ausVersion) {
       return {
         ok: false,
@@ -13068,7 +13597,7 @@ function pruefeLaufherkunft(quelle) {
     }
     return { ok: true };
   }
-  if (!istText7(quelle.chain_id)) {
+  if (!istText8(quelle.chain_id)) {
     return { ok: false, message: '"source.chain_id" fehlt oder ist leer.' };
   }
   if (!Array.isArray(quelle.nodes) || quelle.nodes.length === 0) {
@@ -13087,7 +13616,7 @@ function pruefeLaufherkunft(quelle) {
         message: `"source.nodes[${index}].type" ist unbekannt: ${JSON.stringify(knoten.type)}.`
       };
     }
-    if (!istText7(knoten.element_id) || !istText7(knoten.draft_id)) {
+    if (!istText8(knoten.element_id) || !istText8(knoten.draft_id)) {
       return {
         ok: false,
         message: `"source.nodes[${index}]" braucht element_id und draft_id.`
@@ -13100,10 +13629,10 @@ function pruefeLaufherkunft(quelle) {
       };
     }
   }
-  if (quelle.derivation_run_id !== void 0 && !istText7(quelle.derivation_run_id)) {
+  if (quelle.derivation_run_id !== void 0 && !istText8(quelle.derivation_run_id)) {
     return { ok: false, message: '"source.derivation_run_id" ist gesetzt, aber leer.' };
   }
-  if (quelle.derivation_recovery_id !== void 0 && !istText7(quelle.derivation_recovery_id)) {
+  if (quelle.derivation_recovery_id !== void 0 && !istText8(quelle.derivation_recovery_id)) {
     return { ok: false, message: '"source.derivation_recovery_id" ist gesetzt, aber leer.' };
   }
   return { ok: true };
@@ -13123,7 +13652,7 @@ function checkPromptRunRecord(candidate) {
   }
   const herkunft = isObject12(quelle) && typeof quelle.kind === "string" ? quelle.kind : "published";
   for (const feld of PFLICHTFELDER) {
-    if (!istText7(record[feld])) {
+    if (!istText8(record[feld])) {
       return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
     }
   }
@@ -13136,7 +13665,7 @@ function checkPromptRunRecord(candidate) {
     }
   }
   for (const feld of PFLICHT_JE_HERKUNFT[herkunft] ?? []) {
-    if (!istText7(record[feld])) {
+    if (!istText8(record[feld])) {
       return {
         ok: false,
         message: `"${feld}" fehlt oder ist leer, wird bei Herkunft "${herkunft}" aber gebraucht.`
@@ -13144,7 +13673,7 @@ function checkPromptRunRecord(candidate) {
     }
   }
   for (const feld of VERBOTEN_JE_HERKUNFT[herkunft] ?? []) {
-    if (istText7(record[feld])) {
+    if (istText8(record[feld])) {
       return {
         ok: false,
         message: `"${feld}" ist bei einem Lauf der Herkunft "${herkunft}" gesetzt. Dort gibt es diesen Wert nicht, und erfundene sind unzulaessig (D-98/D-135).`
@@ -13181,7 +13710,7 @@ function checkPromptRunRecord(candidate) {
         message: `"failure.class" ist unbekannt: ${JSON.stringify(failure.class)}. Erlaubt sind ${FAILURE_CLASSES.join(", ")}.`
       };
     }
-    if (!istText7(failure.message)) {
+    if (!istText8(failure.message)) {
       return { ok: false, message: '"failure.message" fehlt oder ist leer.' };
     }
     return { ok: true };
@@ -13223,7 +13752,7 @@ function checkSceneDerivationRecord(candidate) {
   }
   const record = candidate;
   for (const feld of DERIVATION_PFLICHTFELDER) {
-    if (!istText7(record[feld])) {
+    if (!istText8(record[feld])) {
       return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
     }
   }
@@ -13278,13 +13807,13 @@ function checkSceneDerivationRecord(candidate) {
       return { ok: false, message: '"follows" muss ein Objekt sein.' };
     }
     const f = folgt;
-    if (!istText7(f.run_id)) {
+    if (!istText8(f.run_id)) {
       return { ok: false, message: '"follows.run_id" fehlt oder ist leer.' };
     }
     if (f.run_id === record.run_id) {
       return { ok: false, message: '"follows.run_id" zeigt auf den Lauf selbst.' };
     }
-    if (!istText7(f.note)) {
+    if (!istText8(f.note)) {
       return {
         ok: false,
         message: '"follows.note" fehlt oder ist leer \u2014 ohne Beanstandung ist ein Folgelauf nicht nachvollziehbar (D-89).'
@@ -13298,7 +13827,7 @@ function checkSceneDerivationRecord(candidate) {
     }
   }
   const reply = record.reply;
-  if (reply !== void 0 && !istText7(reply)) {
+  if (reply !== void 0 && !istText8(reply)) {
     return {
       ok: false,
       message: `"reply" ist unbrauchbar: erwartet wird eine nicht leere Zeichenkette, angekommen ist ${JSON.stringify(reply)}. Ohne "reply" einreichen ist zulaessig.`
@@ -13318,7 +13847,7 @@ function checkSceneDerivationRecord(candidate) {
         message: `"failure.class" ist unbekannt: ${JSON.stringify(failure.class)}. Erlaubt sind ${FAILURE_CLASSES.join(", ")}.`
       };
     }
-    if (!istText7(failure.message)) {
+    if (!istText8(failure.message)) {
       return { ok: false, message: '"failure.message" fehlt oder ist leer.' };
     }
     if (Array.isArray(record.proposals) && record.proposals.length > 0) {
@@ -13373,7 +13902,7 @@ function checkSceneDerivationRecord(candidate) {
         };
       }
       for (const [gapIndex, luecke] of gaps.entries()) {
-        if (!luecke || typeof luecke !== "object" || !istText7(luecke.pointer) || !istText7(luecke.reason)) {
+        if (!luecke || typeof luecke !== "object" || !istText8(luecke.pointer) || !istText8(luecke.reason)) {
           return {
             ok: false,
             message: `"proposals[${index}].gaps[${gapIndex}]" braucht pointer und reason.`
@@ -13399,7 +13928,7 @@ function checkSceneDerivationRecoveryRecord(candidate) {
   }
   const record = candidate;
   for (const feld of ["recovery_id", "run_id", "created_at"]) {
-    if (!istText7(record[feld])) {
+    if (!istText8(record[feld])) {
       return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
     }
   }
@@ -13426,7 +13955,7 @@ function checkSceneDerivationRecoveryRecord(candidate) {
     return { ok: false, message: '"diagnostics" muss ein Array sein (auch ein leeres).' };
   }
   for (const [index, befund] of record.diagnostics.entries()) {
-    if (!befund || typeof befund !== "object" || !istText7(befund.code) || !istText7(befund.message)) {
+    if (!befund || typeof befund !== "object" || !istText8(befund.code) || !istText8(befund.message)) {
       return {
         ok: false,
         message: `"diagnostics[${index}]" braucht code und message.`
@@ -13478,7 +14007,7 @@ function checkSceneDerivationRecoveryRecord(candidate) {
     }
     if (Array.isArray(gaps)) {
       for (const [gapIndex, luecke] of gaps.entries()) {
-        if (!luecke || typeof luecke !== "object" || !istText7(luecke.pointer) || !istText7(luecke.reason)) {
+        if (!luecke || typeof luecke !== "object" || !istText8(luecke.pointer) || !istText8(luecke.reason)) {
           return {
             ok: false,
             message: `"proposals[${index}].gaps[${gapIndex}]" braucht pointer und reason.`
@@ -13514,6 +14043,120 @@ function checkSceneDerivationRecoveryRecord(candidate) {
   return { ok: true };
 }
 
+// src/lib/szenen/scenePromptOperation.ts
+var MCP_CLIENT_PROVIDER = "mcp_client";
+var UNVERIFIED_MODEL_ID = "mcp-client-unspecified";
+var istText9 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+function collectPromptOperations(events) {
+  const nachId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.promptOperationPrepared) continue;
+    const payload = event.payload;
+    if (!payload || !istText9(payload.operation_id)) continue;
+    if (nachId.has(payload.operation_id)) continue;
+    nachId.set(payload.operation_id, payload);
+  }
+  return [...nachId.values()];
+}
+function findPromptOperation(events, operationId) {
+  return collectPromptOperations(events).find((v) => v.operation_id === operationId) ?? null;
+}
+async function preparePromptOperation(input) {
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const eingefroren = await freezeSceneWorkingState({
+    sceneElementId: input.sceneElementId,
+    store: input.store,
+    resolver: input.resolver,
+    contextChain: input.contextChain,
+    userInstruction: input.userInstruction ?? null
+  });
+  if (eingefroren.kind !== "ok") return eingefroren;
+  const rendererInput = eingefroren.input;
+  return {
+    kind: "ok",
+    operation: {
+      operation_id: input.operationId,
+      scene: eingefroren.scene,
+      context_id: input.contextId,
+      user_instruction: input.userInstruction ?? null,
+      renderer_input: rendererInput,
+      renderer_instruction: buildSystemInstruction(rendererInput),
+      renderer_payload: buildUserPrompt(rendererInput),
+      response_contract: responseContractOf(rendererInput),
+      prepared_by: input.preparedBy,
+      created_at: now().toISOString()
+    }
+  };
+}
+function responseContractOf(input) {
+  const model = input.target_model ?? {};
+  return {
+    format: "json",
+    required_fields: ["positive", "negative", "feedback", "visibility", "notes"],
+    negative_prompt_allowed: model.supports_negative_prompt === true,
+    node_ids: input.scene.nodes.map((node) => node.node_id),
+    prompt_language: typeof model.prompt_language === "string" ? model.prompt_language : "en"
+  };
+}
+function completePromptOperation(input) {
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const { operation } = input;
+  const geparst = parseRunResponse(input.response);
+  if (!geparst.ok) {
+    return {
+      kind: "rejected",
+      message: `Die Antwort zu Vorgang ${operation.operation_id} ist nicht verwertbar: ${geparst.message}`
+    };
+  }
+  const geprueft = checkRunResponse(geparst.value, operation.renderer_input);
+  if (!geprueft.ok) {
+    return {
+      kind: "rejected",
+      message: `Die Antwort zu Vorgang ${operation.operation_id} passt nicht zur eingefrorenen Eingabe: ${geprueft.message}`
+    };
+  }
+  const origin = {
+    host: "mcp",
+    ...istText9(input.declaredModelId) ? { declared_model_id: input.declaredModelId } : {},
+    renderer_instruction_was_system_prompt: false
+  };
+  return {
+    kind: "ok",
+    record: {
+      run_id: input.runId,
+      // Keine fingierten Kennungen (D-98/D-75) — genau wie beim
+      // Szene-Direktlauf des bestehenden Pfads.
+      shot_version_id: "",
+      shot_element_id: "",
+      scene_setup_version_id: "",
+      camera_id: "",
+      target_model_version_id: operation.renderer_input.target_model_resolution?.version_id ?? "",
+      provider: MCP_CLIENT_PROVIDER,
+      model_id: UNVERIFIED_MODEL_ID,
+      // Die Renderer-Anweisung, wie sie der Vorgang eingefroren hat — nicht
+      // eine zweite, jetzt neu gebaute Fassung.
+      system_prompt: operation.renderer_instruction,
+      input_payload: operation.renderer_input,
+      status: "succeeded",
+      failure: null,
+      output: geprueft.output,
+      raw_output: input.response,
+      source: { kind: "scene_direct", scene: operation.scene },
+      operation_id: operation.operation_id,
+      execution_origin: origin,
+      created_at: now().toISOString()
+    }
+  };
+}
+function runOfOperation(runs, operationId) {
+  return runs.find(
+    (run) => run.operation_id === operationId
+  ) ?? null;
+}
+function sameResponseAs(run, response) {
+  return (run.raw_output ?? "") === response;
+}
+
 // src/lib/szenen/seedListe.ts
 var DEFAULT_SEED_VORLAGE = {
   name: "Default",
@@ -13608,9 +14251,9 @@ async function leseBilderAusZip(datei) {
     );
   }
   const { default: JSZip2 } = await import("jszip");
-  const archiv = await JSZip2.loadAsync(datei).catch((fehler4) => {
+  const archiv = await JSZip2.loadAsync(datei).catch((fehler5) => {
     throw new Error(
-      `${name} konnte nicht als ZIP gelesen werden: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+      `${name} konnte nicht als ZIP gelesen werden: ${fehler5 instanceof Error ? fehler5.message : String(fehler5)}`
     );
   });
   const pfade = [];
@@ -13708,13 +14351,13 @@ function noticeFor(ergebnis, was) {
       };
     }
     case "rejected": {
-      const fehler4 = ergebnis.errors ?? [];
+      const fehler5 = ergebnis.errors ?? [];
       const ungeprueft = ergebnis.unchecked ?? [];
       return {
         tone: "rejected",
-        text: `${was}: abgelehnt \u2014 ${fehler4.length} Befund${fehler4.length === 1 ? "" : "e"}.`,
+        text: `${was}: abgelehnt \u2014 ${fehler5.length} Befund${fehler5.length === 1 ? "" : "e"}.`,
         details: [
-          ...fehler4.map((f) => `${f.path ?? "(ohne Pfad)"}: ${f.message ?? "ohne Meldung"}`),
+          ...fehler5.map((f) => `${f.path ?? "(ohne Pfad)"}: ${f.message ?? "ohne Meldung"}`),
           // Nicht verschweigen: was nicht geprüft wurde, ist nicht in Ordnung,
           // sondern ungeprüft.
           ...ungeprueft.map((u) => `ungepr\xFCft: ${u}`)
@@ -15598,7 +16241,7 @@ var ERKLAERUNG = {
 };
 var CapabilityPanel = ({ port, elementId, setupPayload }) => {
   const [bericht, setBericht] = (0, import_react5.useState)(null);
-  const [fehler4, setFehler] = (0, import_react5.useState)(null);
+  const [fehler5, setFehler] = (0, import_react5.useState)(null);
   (0, import_react5.useEffect)(() => {
     let abgemeldet = false;
     setBericht(null);
@@ -15620,10 +16263,10 @@ var CapabilityPanel = ({ port, elementId, setupPayload }) => {
       abgemeldet = true;
     };
   }, [port, elementId, setupPayload]);
-  if (fehler4) {
+  if (fehler5) {
     return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("p", { "data-testid": "capability-fehler", role: "alert", children: [
       "F\xE4higkeitsbericht nicht erstellbar: ",
-      fehler4
+      fehler5
     ] });
   }
   if (!bericht) return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { "data-testid": "capability-laden", children: "F\xE4higkeitsbericht wird erstellt \u2026" });
@@ -16030,6 +16673,7 @@ var RunImagesPanel = ({ port, lauf }) => {
   const neuLesen = () => setNachladen((n) => n + 1);
   const [erzeugenOffen, setErzeugenOffen] = (0, import_react8.useState)(null);
   const [zuordnenOffen, setZuordnenOffen] = (0, import_react8.useState)(null);
+  const [chatAuftraegeOffen, setChatAuftraegeOffen] = (0, import_react8.useState)(null);
   const quelle = sourceOf(lauf);
   const [wahlPhase] = usePortQuery(
     () => port.imageGeneration ? port.imageGeneration.imageModelChoiceForRun(lauf.run_id) : Promise.resolve({ kind: "ok", value: null }),
@@ -16044,10 +16688,17 @@ var RunImagesPanel = ({ port, lauf }) => {
     () => port.imageBatchHistory ? port.imageBatchHistory.listBatchesForPromptRun(lauf.run_id) : Promise.resolve({ kind: "ok", value: [] }),
     [port, lauf.run_id, nachladen]
   );
+  const [chatAuftraegePhase] = usePortQuery(
+    () => port.imageJobs ? port.imageJobs.listJobs(lauf.run_id) : Promise.resolve({ kind: "ok", value: [] }),
+    [port, lauf.run_id, nachladen]
+  );
   const auftraege = auftraegePhase.status === "ready" ? auftraegePhase.value : [];
   const batches = batchesPhase.status === "ready" ? batchesPhase.value : [];
+  const chatAuftraege = chatAuftraegePhase.status === "ready" ? chatAuftraegePhase.value : [];
+  const offeneChatAuftraege = chatAuftraege.filter((a) => a.status === "pending").length;
   const auffaellige = auftraege.filter((a) => a.status !== "succeeded");
   const erzeugenAuf = erzeugenOffen ?? batches.length === 0;
+  const chatAuftraegeAuf = chatAuftraegeOffen ?? offeneChatAuftraege > 0;
   return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "szenen-bilder", "data-testid": `bilder-${lauf.run_id}`, children: [
     /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("section", { className: "szenen-bilder__eingang", "data-testid": `eingang-${lauf.run_id}`, children: [
       /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("h5", { children: "Eingang \u2014 woraus dieser Prompt entstand" }),
@@ -16168,6 +16819,43 @@ var RunImagesPanel = ({ port, lauf }) => {
         }
       )
     ] }),
+    faehig.imageJobs && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+      "details",
+      {
+        className: "szenen-bilder__aktion",
+        "data-testid": `auftraege-chat-bereich-${lauf.run_id}`,
+        open: chatAuftraegeAuf,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+            "summary",
+            {
+              onClick: (e) => {
+                e.preventDefault();
+                setChatAuftraegeOffen(!chatAuftraegeAuf);
+              },
+              children: [
+                "Bildauftraege aus dem Chat",
+                offeneChatAuftraege > 0 ? ` (${offeneChatAuftraege} wartend)` : ""
+              ]
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+            ChatAuftraegeAktion,
+            {
+              port,
+              lauf,
+              auftraege: chatAuftraege,
+              fehler: chatAuftraegePhase.status === "error" ? chatAuftraegePhase.message : null,
+              laedt: chatAuftraegePhase.status === "loading",
+              onFertig: () => {
+                setChatAuftraegeOffen(true);
+                neuLesen();
+              }
+            }
+          )
+        ]
+      }
+    ),
     /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
       "details",
       {
@@ -16351,7 +17039,7 @@ function useBildQuellen(port, bilder) {
     erneutVersuchen: () => setVersuch((n) => n + 1)
   };
 }
-var BildDetails = ({ bild, fehler: fehler4, aufloesbar }) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "szenen-bilder__meta", "data-testid": `batchbild-${bild.media_ref}`, children: [
+var BildDetails = ({ bild, fehler: fehler5, aufloesbar }) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "szenen-bilder__meta", "data-testid": `batchbild-${bild.media_ref}`, children: [
   /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { children: bild.media_ref }),
   /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { children: [
     "Position ",
@@ -16364,7 +17052,7 @@ var BildDetails = ({ bild, fehler: fehler4, aufloesbar }) => /* @__PURE__ */ (0,
     "\xD7",
     bild.height
   ] }) : null,
-  fehler4 && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("em", { "data-testid": `batchbild-fehler-${bild.media_ref}`, children: fehler4 }),
+  fehler5 && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("em", { "data-testid": `batchbild-fehler-${bild.media_ref}`, children: fehler5 }),
   !aufloesbar && // Capability-Grenze, kein Fehler: Dieser Host kann Batches lesen,
   // aber keine Bilder auflösen (E). Kein erfundener Fallback auf eine
   // Serverroute (A6).
@@ -16380,18 +17068,18 @@ var HERKUNFT_KURZ = {
   external_import: "extern importiert"
 };
 var BatchKachel = ({ port, batch }) => {
-  const { quellen, fehler: fehler4, wiederholbar, erneutVersuchen } = useBildQuellen(port, batch.images);
+  const { quellen, fehler: fehler5, wiederholbar, erneutVersuchen } = useBildQuellen(port, batch.images);
   const aufloesbar = Boolean(port.imageLibrary);
   const bilder = batch.images.map((bild) => ({
     id: bild.media_ref,
     quelle: quellen.get(bild.media_ref) ?? null,
     titel: `Bild ${bild.position + 1}`,
-    ...fehler4.get(bild.media_ref) ? { leerText: "Nicht ladbar" } : {},
+    ...fehler5.get(bild.media_ref) ? { leerText: "Nicht ladbar" } : {},
     details: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
       BildDetails,
       {
         bild,
-        fehler: fehler4.get(bild.media_ref) ?? null,
+        fehler: fehler5.get(bild.media_ref) ?? null,
         aufloesbar
       }
     )
@@ -16451,7 +17139,7 @@ var BatchKachel = ({ port, batch }) => {
             BildDetails,
             {
               bild,
-              fehler: fehler4.get(bild.media_ref) ?? null,
+              fehler: fehler5.get(bild.media_ref) ?? null,
               aufloesbar
             }
           ) }, bild.media_ref)) })
@@ -16720,11 +17408,11 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
         setSeedListe(DEFAULT_SEED_VORLAGE.seeds);
         setVorlageKey(DEFAULT_VORLAGE_KEY);
       }
-    } catch (fehler4) {
+    } catch (fehler5) {
       if (veraltet()) return;
       setNotiz({
         tone: "error",
-        text: fehler4 instanceof Error ? fehler4.message : String(fehler4)
+        text: fehler5 instanceof Error ? fehler5.message : String(fehler5)
       });
     }
     if (veraltet()) return;
@@ -16743,10 +17431,10 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
       setNotiz(
         ergebnis.kind === "ok" ? { tone: "ok", text: `Importiert als Item ${ergebnis.value.item_id} mit ${bilder.length} Bild(ern).` } : noticeFor(ergebnis, "Externe Bilder importieren")
       );
-    } catch (fehler4) {
+    } catch (fehler5) {
       setNotiz({
         tone: "error",
-        text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+        text: `Externe Bilder importieren: ${fehler5 instanceof Error ? fehler5.message : String(fehler5)}`
       });
     }
     setLaeuft(false);
@@ -16768,10 +17456,10 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
           ...seed !== void 0 ? { seed } : {}
         });
       }
-    } catch (fehler4) {
+    } catch (fehler5) {
       setNotiz({
         tone: "error",
-        text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+        text: `Externe Bilder importieren: ${fehler5 instanceof Error ? fehler5.message : String(fehler5)}`
       });
       return;
     }
@@ -17107,6 +17795,101 @@ function readAsBase64(datei) {
     leser.readAsDataURL(datei);
   });
 }
+var CHAT_AUFTRAG_TEXT = {
+  pending: "wartet auf \xDCbernahme",
+  // Wie bei `started` (D-119): laufend und abgebrochen sind aus dem Log
+  // nicht unterscheidbar, und es gibt keinen automatischen Retry, der die
+  // Unterscheidung bräuchte.
+  claimed: "\xFCbernommen (l\xE4uft oder unterbrochen)",
+  succeeded: "erfolgreich",
+  partial: "teilweise",
+  failed: "fehlgeschlagen",
+  rejected: "abgelehnt \u2014 es wurde nichts ausgef\xFChrt"
+};
+var ChatAuftraegeAktion = ({
+  port,
+  lauf,
+  auftraege,
+  fehler: fehler5,
+  laedt,
+  onFertig
+}) => {
+  const [laufend, setLaufend] = (0, import_react8.useState)(null);
+  const [notiz, setNotiz] = (0, import_react8.useState)(null);
+  async function uebernehmen(jobId) {
+    if (!port.imageJobs) return;
+    setLaufend(jobId);
+    setNotiz(null);
+    try {
+      const ergebnis = await port.imageJobs.claimAndRun(jobId);
+      if (ergebnis.kind === "ok") {
+        setNotiz({
+          tone: ergebnis.job.status === "succeeded" ? "ok" : "rejected",
+          text: `Auftrag ${jobId}: ${CHAT_AUFTRAG_TEXT[ergebnis.job.status]}.` + (ergebnis.job.diagnostic ? ` ${ergebnis.job.diagnostic}` : "")
+        });
+      } else if (ergebnis.kind === "lost") {
+        setNotiz({ tone: "rejected", text: ergebnis.message });
+      } else {
+        setNotiz({ tone: "error", text: ergebnis.message });
+      }
+    } catch (e) {
+      setNotiz({
+        tone: "error",
+        text: `Die \xDCbernahme von Auftrag ${jobId} ist technisch gescheitert: ` + (e instanceof Error ? e.message : String(e))
+      });
+    } finally {
+      setLaufend(null);
+      onFertig();
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "szenen-bilder__aktion-inhalt", "data-testid": `chat-auftraege-${lauf.run_id}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { className: "szenen-area__lead", children: "Auftr\xE4ge, die \xFCber den MCP aus dem Chat kamen. Der Prompt wird nicht kopiert \u2014 ausgef\xFChrt wird der eingefrorene Prompt dieses Laufs." }),
+    fehler5 && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("p", { role: "alert", "data-testid": `chat-auftraege-fehler-${lauf.run_id}`, children: [
+      "Bildauftr\xE4ge aus dem Chat konnten nicht gelesen werden: ",
+      fehler5
+    ] }),
+    !fehler5 && !laedt && auftraege.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("p", { "data-testid": `chat-auftraege-leer-${lauf.run_id}`, children: "F\xFCr diesen Lauf liegt kein Auftrag aus dem Chat vor." }),
+    notiz && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+      "p",
+      {
+        role: notiz.tone === "error" ? "alert" : void 0,
+        "data-testid": `chat-auftraege-notiz-${lauf.run_id}`,
+        children: notiz.text
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("ul", { className: "szenen-bilder__auftraege", children: auftraege.map((auftrag) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("li", { "data-testid": `chat-auftrag-${auftrag.job_id}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { children: CHAT_AUFTRAG_TEXT[auftrag.status] }),
+      " \u2014 ",
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { children: [
+        auftrag.image_count,
+        " ",
+        auftrag.image_count === 1 ? "Bild" : "Bilder",
+        " mit",
+        " ",
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { children: auftrag.execution_target_model_key }),
+        " / ",
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { children: auftrag.execution_profile_id }),
+        auftrag.aspect_ratio ? ` im Format ${auftrag.aspect_ratio}` : ""
+      ] }),
+      auftrag.diagnostic && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { children: [
+        " ",
+        auftrag.diagnostic
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("br", {}),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("code", { className: "szenen-bilder__auftragskennung", children: auftrag.job_id }),
+      auftrag.status === "pending" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+        "button",
+        {
+          type: "button",
+          disabled: laufend !== null,
+          onClick: () => void uebernehmen(auftrag.job_id),
+          "data-testid": `chat-auftrag-uebernehmen-${auftrag.job_id}`,
+          children: laufend === auftrag.job_id ? "\xDCbernahme l\xE4uft\u2026" : "\xDCbernehmen und ausf\xFChren (kostet einen Bildaufruf)"
+        }
+      )
+    ] }, auftrag.job_id)) })
+  ] });
+};
 
 // src/features/szenen/areas/RunsPanel.tsx
 var import_jsx_runtime9 = require("react/jsx-runtime");
@@ -19389,6 +20172,7 @@ var SzenenView = ({
   DERIVABLE_TYPES,
   ELEMENT_VERSION_SCHEMA_FILE,
   FLOW_EXECUTION_PATH,
+  MCP_CLIENT_PROVIDER,
   PROBE_VERSION_ID,
   PROMPT_RULE_EFFECT,
   REFERENCE_FIELD,
@@ -19403,8 +20187,12 @@ var SzenenView = ({
   SZENEN_EVENT_TYPES,
   SZENEN_ITEM_PREFIX,
   SZENEN_SCHEMAS,
+  SZENEN_SNAPSHOT_FILE,
+  SZENEN_SNAPSHOT_PREFIX,
+  SZENEN_SNAPSHOT_SCHEMA_VERSION,
   SzenenView,
   UNCHECKED_PUBLISH_RULES,
+  UNVERIFIED_MODEL_ID,
   UPLOAD_MAX_BYTES,
   UnsupportedSchemaError,
   VersionDagError,
@@ -19415,6 +20203,7 @@ var SzenenView = ({
   buildDerivationSystemInstruction,
   buildDerivationUserPrompt,
   buildSystemInstruction,
+  buildSzenenSnapshot,
   buildUserPrompt,
   buildVersionDag,
   callOptional,
@@ -19445,14 +20234,18 @@ var SzenenView = ({
   checkSzenenBatchOrigin,
   checkTitle,
   checkWriteDraftInput,
+  claimWon,
   collectImageBatches,
   collectImageGenerationOrders,
+  collectImageJobs,
+  collectPromptOperations,
   collectPromptRuns,
   collectProviderChecks,
   collectSceneDerivationRecoveries,
   collectSceneDerivations,
   collectVersionRefs,
   compileSchemas,
+  completePromptOperation,
   createBrowserTextGenerationPort,
   createClientDerivationPort,
   createClientRunPort,
@@ -19470,6 +20263,7 @@ var SzenenView = ({
   createHfImageLibrary,
   createHfImageStore,
   createImageGenerationPort,
+  createImageJobPort,
   createInMemoryEventChannel,
   createMemoryViewPort,
   createSimulationSceneDerivationPort,
@@ -19488,6 +20282,8 @@ var SzenenView = ({
   findExecutableImageModel,
   findImageBatch,
   findImageGenerationOrder,
+  findImageJob,
+  findPromptOperation,
   findPromptRun,
   findProviderCheck,
   findSceneDerivation,
@@ -19497,6 +20293,7 @@ var SzenenView = ({
   formatSeedListe,
   freezeDraftChain,
   freezeSceneWorkingState,
+  generationBatchIdOf,
   gesamtHerkunft,
   getSzenenSchemas,
   gruppiereZuItems,
@@ -19505,14 +20302,20 @@ var SzenenView = ({
   isOk,
   isProjectionCurrent,
   isSzenenItemId,
+  istSzenenSnapshotDatei,
   istZipDatei,
   itemIdForRun,
+  itemsAusBestand,
+  jobsForPromptRun,
   ladeVorschauen,
   leseBilderAusZip,
   linkFor,
+  locatorAus,
   locatorTeile,
   logRevisionOf,
+  mergeSnapshotAndPending,
   mergeSzenenBatchOrigin,
+  mimeTypAus,
   mitDefaultVorlage,
   noticeFor,
   ordersForPromptRun,
@@ -19520,8 +20323,10 @@ var SzenenView = ({
   parseDerivationResponse,
   parseRunResponse,
   parseSeedListe,
+  parseSzenenSnapshot,
   preferredHeadRevisionOf,
   preferredVersionId,
+  preparePromptOperation,
   promptDiagnosticsOf,
   publishedHeadsOf,
   recoveriesForRun,
@@ -19534,19 +20339,23 @@ var SzenenView = ({
   resolveShotPayload,
   resolveTargetModelOver,
   resolverFromQueries,
+  responseContractOf,
   roundOfRun,
   rulesWithoutPromptEffect,
   runElementStoreContract,
+  runOfOperation,
   runPromptDerivation,
   runPublishChecks,
   runSceneDerivation,
   runStoreDifferential,
+  sameResponseAs,
   sceneOnlyCapabilities,
   scopeOfPath,
   seedFehlerText,
   selectableTargetModels,
   showChain,
   simulatedAnswerFor,
+  szenenSnapshotFilename,
   totalModelCalls,
   typAusBytes,
   unclassifiedPublishRules,