@rslsp1/fa-app-tools 10.3.2 → 10.3.3

package/dist/{chunk-JP7LIWDR.mjs → chunk-XLNA2BD6.mjs}

@@ -8,14 +8,19 @@ import {
   CAMERA_ASPECT_RATIOS,
   STAGE_CATALOGUE,
   checkCameraAspectRatioChanges,
+  distinctPreviewColor,
+  facingRotationZ,
   frozenCameraAspectRatio,
+  normalizePreviewColor,
+  previewColorConflicts,
+  previewColorLegibility,
   roundMeters,
   stageColor,
   stageColors,
   stageFrame,
   stageTypeLabel,
   withStagePositions
-} from "./chunk-TFWIMFNF.mjs";
+} from "./chunk-GKLCL2VQ.mjs";
 
 // src/lib/szenen/szenenSnapshot.ts
 var SZENEN_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -442,6 +447,98 @@ async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeTy
   return result === "ABORT" ? null : result;
 }
 
+// src/lib/szenen/stageMigration.ts
+var STAGE_MIGRATION_ID = "stage_floor_center_v1";
+var STAGE_MIGRATION_EVENT = "szenen.stage_convention_migrated";
+function migrateNode(node, report, source) {
+  if (!node.proxy_3d || node.proxy_3d.origin === "floor_center") return structuredClone(node);
+  const proxy = node.proxy_3d, d = proxy.dimensions;
+  if (!Array.isArray(d) || d.length !== 3 || d.some((v) => !Number.isFinite(v) || v <= 0)) throw new Error(`${source}/${node.node_id}: ung\xFCltige Proxy-Ma\xDFe.`);
+  let shape;
+  if (node.label === "Mensch" || node.type === "subject") shape = { primitive: "humanoid_proxy", pose_ref: "standing", morph: { build: 0.5, gender: 0.5 } };
+  else if (node.label === "Stuhl") shape = { primitive: "furniture_proxy", variant: "chair" };
+  else if (node.label === "Tisch" || node.type === "surface") shape = { primitive: "furniture_proxy", variant: "table" };
+  else if (node.label === "Lampe" || node.type === "light") shape = { primitive: "furniture_proxy", variant: "floor_lamp" };
+  else {
+    shape = { primitive: "box" };
+    report.remaining_boxes.push(`${source}/${node.node_id}`);
+  }
+  const anchors = node.anchors && Object.fromEntries(Object.entries(node.anchors).map(([key, value2]) => {
+    const a = value2;
+    return [key, [a[0], a[1], a[2] + d[2] / 2]];
+  }));
+  return { ...node, proxy_3d: { ...proxy, dimensions: [...d], ...shape, origin: "floor_center" }, ...anchors ? { anchors } : {} };
+}
+function prepareStageMigration(state) {
+  const report = { remaining_boxes: [], changed_camera_views: [], placements: 0 };
+  const entries = [];
+  const records = (snapshot) => [
+    ...snapshot.versions.map((v) => ({ element_id: v.element_id, version_id: v.version_id, before: v.payload })),
+    ...snapshot.draft ? [{
+      element_id: snapshot.element.element_id,
+      draft_id: snapshot.draft.draft_id,
+      revision: snapshot.draft.revision,
+      before: snapshot.draft.payload
+    }] : []
+  ];
+  for (const snapshot of state.elements.values()) {
+    if (!["scene", "scene_setup"].includes(snapshot.element.type)) continue;
+    if (snapshot.draftFork) throw new Error(`Migration: Entwurfskonflikt an ${snapshot.element.element_id} zuerst aufl\xF6sen.`);
+    for (const record of records(snapshot)) {
+      const source = record.element_id + "/" + ("version_id" in record ? record.version_id : record.draft_id);
+      let after;
+      if (snapshot.element.type === "scene") {
+        if (record.before.nodes === void 0) continue;
+        if (!Array.isArray(record.before.nodes)) throw new Error(`${source}: nodes ist keine Liste.`);
+        after = { ...record.before, nodes: record.before.nodes.map((n) => migrateNode(n, report, source)) };
+      } else {
+        const p = record.before;
+        const scene = state.elements.get(p.scene_ref?.element_id);
+        const link = "draft_id" in record && snapshot.draft?.chain?.links.find((l) => l.field === "scene_ref");
+        const scenePayload = link && scene?.draft?.draft_id === link.target_draft_id ? scene.draft.payload : scene?.versions.find((v) => v.version_id === p.scene_ref?.version_id)?.payload;
+        if (!scenePayload && (p.placements?.length || p.node_overrides?.some((n) => n.proxy_3d))) throw new Error(`${source}: referenzierte Szene fehlt.`);
+        const placements = (p.placements ?? []).map((placement) => {
+          const raw = scenePayload?.nodes.find((n) => n.node_id === placement.node_id);
+          const override = p.node_overrides?.find((n) => n.node_id === placement.node_id);
+          const proxy = override?.proxy_3d ?? raw?.proxy_3d;
+          if (!proxy || proxy.origin === "floor_center") return placement;
+          if (!Number.isFinite(proxy.dimensions?.[2]) || proxy.dimensions[2] <= 0) throw new Error(`${source}/${placement.node_id}: H\xF6he fehlt.`);
+          report.placements++;
+          return { ...placement, position: [placement.position[0], placement.position[1], placement.position[2] - proxy.dimensions[2] / 2] };
+        });
+        for (const camera of p.camera_rig?.cameras ?? []) {
+          if (camera.orientation?.mode === "explicit" && camera.orientation.rotation_euler_deg.filter((n) => n !== 0).length >= 2)
+            report.changed_camera_views.push(`${source}/${camera.camera_id}`);
+        }
+        after = {
+          ...p,
+          ...p.placements ? { placements } : {},
+          ...p.node_overrides ? { node_overrides: p.node_overrides.map((n) => {
+            const raw = scenePayload?.nodes.find((x) => x.node_id === n.node_id);
+            return n.proxy_3d ? { ...n, proxy_3d: migrateNode({ ...raw, ...n }, report, source).proxy_3d } : n;
+          }) } : {}
+        };
+      }
+      if (JSON.stringify(after) !== JSON.stringify(record.before)) entries.push({ ...record, after });
+    }
+  }
+  return { migration_id: STAGE_MIGRATION_ID, entries, report };
+}
+function applyStageMigration(state, migration) {
+  if (migration.migration_id !== STAGE_MIGRATION_ID) throw new Error("Unbekannte B\xFChnenmigration.");
+  for (const entry of migration.entries) {
+    const snapshot = state.elements.get(entry.element_id);
+    if (!snapshot) throw new Error(`B\xFChnenmigration: Element ${entry.element_id} fehlt.`);
+    if (entry.version_id) {
+      const version = snapshot.versions.find((v) => v.version_id === entry.version_id);
+      if (!version) throw new Error(`B\xFChnenmigration: Version ${entry.version_id} fehlt.`);
+      if (JSON.stringify(version.payload) === JSON.stringify(entry.before)) version.payload = structuredClone(entry.after);
+    } else if (snapshot.draft && snapshot.draft.draft_id === entry.draft_id && snapshot.draft.revision === entry.revision && JSON.stringify(snapshot.draft.payload) === JSON.stringify(entry.before)) {
+      snapshot.draft = { ...snapshot.draft, payload: structuredClone(entry.after), revision: snapshot.draft.revision + 1 };
+    }
+  }
+}
+
 // src/lib/szenen/elementEvents.ts
 var SZENEN_EVENT_PREFIX = "szenen.";
 var SZENEN_EVENT_TYPES = {
@@ -827,7 +924,9 @@ function reduceElementEvents(events) {
   for (const [elementId, snapshot] of snapshots) {
     elements.set(elementId, finalize(elementId, snapshot));
   }
-  return { elements, findings };
+  const state = { elements, findings };
+  for (const event of ordered) if (event.type === STAGE_MIGRATION_EVENT) applyStageMigration(state, event.payload);
+  return state;
 }
 var highestRevision = (byRevision) => [...byRevision.keys()].reduce((max, revision) => revision > max ? revision : max, 0);
 function finalize(elementId, snapshot) {
@@ -2021,7 +2120,7 @@ function applySchema(schema, instance, path, baseId, ctx) {
 }
 function applyKeywords(schema, instance, path, baseId, ctx) {
   let valid = true;
-  const fail3 = (keyword, message) => {
+  const fail4 = (keyword, message) => {
     ctx.errors.push({ instancePath: path, message, keyword });
     valid = false;
   };
@@ -2032,24 +2131,24 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
   if ("type" in schema) {
     const expected = Array.isArray(schema.type) ? schema.type : [schema.type];
     if (!expected.some((t) => matchesType(instance, t))) {
-      fail3("type", `muss ${expected.join(" oder ")} sein, ist ${jsonTypeOf(instance)}`);
+      fail4("type", `muss ${expected.join(" oder ")} sein, ist ${jsonTypeOf(instance)}`);
     }
   }
   if ("const" in schema && !deepEqual(instance, schema.const)) {
-    fail3("const", `muss gleich ${JSON.stringify(schema.const)} sein`);
+    fail4("const", `muss gleich ${JSON.stringify(schema.const)} sein`);
   }
   if (Array.isArray(schema.enum) && !schema.enum.some((option) => deepEqual(instance, option))) {
-    fail3("enum", `muss einer der erlaubten Werte sein: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}`);
+    fail4("enum", `muss einer der erlaubten Werte sein: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}`);
   }
   if (typeof instance === "string") {
     if (typeof schema.minLength === "number" && instance.length < schema.minLength) {
-      fail3("minLength", `muss mindestens ${schema.minLength} Zeichen haben`);
+      fail4("minLength", `muss mindestens ${schema.minLength} Zeichen haben`);
     }
     if (typeof schema.maxLength === "number" && instance.length > schema.maxLength) {
-      fail3("maxLength", `darf hoechstens ${schema.maxLength} Zeichen haben`);
+      fail4("maxLength", `darf hoechstens ${schema.maxLength} Zeichen haben`);
     }
     if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(instance)) {
-      fail3("pattern", `muss dem Muster ${schema.pattern} entsprechen`);
+      fail4("pattern", `muss dem Muster ${schema.pattern} entsprechen`);
     }
     if (typeof schema.format === "string") {
       const check = FORMATS[schema.format];
@@ -2058,40 +2157,40 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
           `Format "${schema.format}" ist in jsonSchema.ts nicht implementiert.`
         );
       }
-      if (!check(instance)) fail3("format", `muss dem Format ${schema.format} entsprechen`);
+      if (!check(instance)) fail4("format", `muss dem Format ${schema.format} entsprechen`);
     }
   }
   if (typeof instance === "number") {
     if (typeof schema.minimum === "number" && instance < schema.minimum) {
-      fail3("minimum", `muss >= ${schema.minimum} sein`);
+      fail4("minimum", `muss >= ${schema.minimum} sein`);
     }
     if (typeof schema.maximum === "number" && instance > schema.maximum) {
-      fail3("maximum", `muss <= ${schema.maximum} sein`);
+      fail4("maximum", `muss <= ${schema.maximum} sein`);
     }
     if (typeof schema.exclusiveMinimum === "number" && instance <= schema.exclusiveMinimum) {
-      fail3("exclusiveMinimum", `muss > ${schema.exclusiveMinimum} sein`);
+      fail4("exclusiveMinimum", `muss > ${schema.exclusiveMinimum} sein`);
     }
     if (typeof schema.exclusiveMaximum === "number" && instance >= schema.exclusiveMaximum) {
-      fail3("exclusiveMaximum", `muss < ${schema.exclusiveMaximum} sein`);
+      fail4("exclusiveMaximum", `muss < ${schema.exclusiveMaximum} sein`);
     }
     if (typeof schema.multipleOf === "number" && schema.multipleOf > 0) {
       const quotient = instance / schema.multipleOf;
-      if (!Number.isInteger(quotient)) fail3("multipleOf", `muss ein Vielfaches von ${schema.multipleOf} sein`);
+      if (!Number.isInteger(quotient)) fail4("multipleOf", `muss ein Vielfaches von ${schema.multipleOf} sein`);
     }
   }
   if (Array.isArray(instance)) {
     if (typeof schema.minItems === "number" && instance.length < schema.minItems) {
-      fail3("minItems", `muss mindestens ${schema.minItems} Eintraege haben`);
+      fail4("minItems", `muss mindestens ${schema.minItems} Eintraege haben`);
     }
     if (typeof schema.maxItems === "number" && instance.length > schema.maxItems) {
-      fail3("maxItems", `darf hoechstens ${schema.maxItems} Eintraege haben`);
+      fail4("maxItems", `darf hoechstens ${schema.maxItems} Eintraege haben`);
     }
     if (schema.uniqueItems === true) {
       const gesehen = /* @__PURE__ */ new Set();
       for (const eintrag of instance) {
         const schluessel = canonicalJson(eintrag);
         if (gesehen.has(schluessel)) {
-          fail3("uniqueItems", "darf keine doppelten Eintraege enthalten");
+          fail4("uniqueItems", "darf keine doppelten Eintraege enthalten");
           break;
         }
         gesehen.add(schluessel);
@@ -2102,7 +2201,7 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
       const trifft = instance.some(
         (eintrag, i) => applySchema(schema.contains, eintrag, `${path}/${i}`, baseId, { ...ctx, errors: probe })
       );
-      if (!trifft) fail3("contains", "muss mindestens einen passenden Eintrag enthalten");
+      if (!trifft) fail4("contains", "muss mindestens einen passenden Eintrag enthalten");
     }
     if ("items" in schema) {
       for (let i = 0; i < instance.length; i++) {
@@ -2115,10 +2214,10 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
   if (isObject2(instance)) {
     const keys = Object.keys(instance);
     if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
-      fail3("minProperties", `muss mindestens ${schema.minProperties} Eigenschaften haben`);
+      fail4("minProperties", `muss mindestens ${schema.minProperties} Eigenschaften haben`);
     }
     if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
-      fail3("maxProperties", `darf hoechstens ${schema.maxProperties} Eigenschaften haben`);
+      fail4("maxProperties", `darf hoechstens ${schema.maxProperties} Eigenschaften haben`);
     }
     if (Array.isArray(schema.required)) {
       for (const name of schema.required) {
@@ -2148,7 +2247,7 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
         if (known.has(name)) continue;
         const childPath = `${path}/${escapePointer(name)}`;
         if (schema.additionalProperties === false) {
-          fail3("additionalProperties", `unbekannte Eigenschaft "${name}"`);
+          fail4("additionalProperties", `unbekannte Eigenschaft "${name}"`);
         } else if (schema.additionalProperties !== true) {
           if (!applySchema(schema.additionalProperties, instance[name], childPath, baseId, ctx)) {
             valid = false;
@@ -2167,7 +2266,7 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
     const anyValid = schema.anyOf.some(
       (branch) => applySchema(branch, instance, path, baseId, { ...ctx, errors: probe })
     );
-    if (!anyValid) fail3("anyOf", "passt auf keine der erlaubten Varianten");
+    if (!anyValid) fail4("anyOf", "passt auf keine der erlaubten Varianten");
   }
   if (Array.isArray(schema.oneOf)) {
     const probe = [];
@@ -2175,7 +2274,7 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
       (branch) => applySchema(branch, instance, path, baseId, { ...ctx, errors: probe })
     ).length;
     if (matches !== 1) {
-      fail3(
+      fail4(
         "oneOf",
         matches === 0 ? "passt auf keine der erlaubten Varianten" : `passt auf ${matches} Varianten, erlaubt ist genau eine`
       );
@@ -2184,7 +2283,7 @@ function applyKeywords(schema, instance, path, baseId, ctx) {
   if ("not" in schema) {
     const probe = [];
     if (applySchema(schema.not, instance, path, baseId, { ...ctx, errors: probe })) {
-      fail3("not", "darf hier nicht zutreffen");
+      fail4("not", "darf hier nicht zutreffen");
     }
   }
   if ("if" in schema) {
@@ -2711,6 +2810,34 @@ var SZENEN_SCHEMAS = {
               "string",
               "null"
             ]
+          },
+          "variant": {
+            "type": "string"
+          },
+          "origin": {
+            "type": "string",
+            "const": "floor_center"
+          },
+          "morph": {
+            "type": "object",
+            "properties": {
+              "build": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1
+              },
+              "gender": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1
+              }
+            },
+            "additionalProperties": false
+          },
+          "preview_color": {
+            "description": "Feste Markerfarbe des Proxys in Editor und Kamera-Preview (#rrggbb). Reiner Kompositionsmarker zur Zuordnung von Proxy und Objekt \u2014 KEINE Angabe zur realen Farbe oder zum Material des Objekts. Fehlt sie, vergibt der Editor eine unterscheidbare Ersatzfarbe.",
+            "type": "string",
+            "pattern": "^#[0-9a-f]{6}$"
           }
         },
         "required": [
@@ -8509,6 +8636,219 @@ function sameResponseAs(run, response) {
   return (run.raw_output ?? "") === response;
 }
 
+// src/lib/szenen/promptRunVariant.ts
+var CAMERA_PREVIEW_ASSET_ROLE = "camera_preview";
+var VARIANT_VISIBILITY_BASIS = "variant_unassessed";
+var VARIANT_NODE_STATE = "unassessed";
+var VARIANT_SYSTEM_PROMPT = "Promptvariante eines bestehenden Laufs. Es wurde keine Renderer-Anweisung ausgefuehrt und kein Modell vom Server gerufen; der Prompttext stammt unveraendert vom MCP-Aufrufer. Eingefrorener Stand und Eingangsbilder sind die des Quelllaufs.";
+var VARIANT_ASSUMPTION = "Die Sichtbarkeit der Szenenknoten wurde fuer diesen Prompttext nicht beurteilt.";
+var istText7 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+var isObject12 = (wert) => typeof wert === "object" && wert !== null && !Array.isArray(wert);
+function unbeurteilteKnoten(input) {
+  return input.scene.nodes.map((node) => ({
+    node_id: node.node_id,
+    state: VARIANT_NODE_STATE,
+    reason: "Promptvariante \u2014 keine Sichtbarkeitsbeurteilung fuer diesen Text.",
+    assumption: true
+  }));
+}
+function checkVariantInputAssets(assets, cameraPreview) {
+  if (!Array.isArray(assets)) {
+    return { ok: false, message: '"variant_of.input_assets" muss eine Liste sein.' };
+  }
+  const gesehen = /* @__PURE__ */ new Set();
+  for (const [index, asset] of assets.entries()) {
+    if (!isObject12(asset)) {
+      return { ok: false, message: `"variant_of.input_assets[${index}]" ist kein Objekt.` };
+    }
+    if (!istText7(asset.asset_id)) {
+      return { ok: false, message: `"variant_of.input_assets[${index}].asset_id" fehlt.` };
+    }
+    if (asset.role !== CAMERA_PREVIEW_ASSET_ROLE) {
+      return {
+        ok: false,
+        message: `"variant_of.input_assets[${index}].role" ist unbekannt: ${JSON.stringify(asset.role)}. Erlaubt: ${CAMERA_PREVIEW_ASSET_ROLE}.`
+      };
+    }
+    if (asset.position !== index) {
+      return {
+        ok: false,
+        message: `"variant_of.input_assets[${index}].position" ist ${JSON.stringify(asset.position)}; die Eingangsbilder sind lueckenlos ab 0 geordnet.`
+      };
+    }
+    if (asset.prompt_token !== null && !istText7(asset.prompt_token)) {
+      return {
+        ok: false,
+        message: `"variant_of.input_assets[${index}].prompt_token" muss Text oder null sein.`
+      };
+    }
+    if (typeof asset.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(asset.sha256)) {
+      return { ok: false, message: `"variant_of.input_assets[${index}].sha256" ist ungueltig.` };
+    }
+    const herkunft = asset.origin;
+    if (!isObject12(herkunft) || !istText7(herkunft.run_id) || !istText7(herkunft.item_id)) {
+      return {
+        ok: false,
+        message: `"variant_of.input_assets[${index}].origin" braucht run_id und item_id.`
+      };
+    }
+    if (gesehen.has(asset.asset_id)) {
+      return {
+        ok: false,
+        message: `Asset ${asset.asset_id} steht mehrfach in "variant_of.input_assets".`
+      };
+    }
+    gesehen.add(asset.asset_id);
+  }
+  const previews = assets.filter((asset) => asset.role === CAMERA_PREVIEW_ASSET_ROLE);
+  if (cameraPreview) {
+    if (previews.length !== 1) {
+      return {
+        ok: false,
+        message: `Der Lauf traegt ein Kamera-Preview, die Eingangsbilder nennen aber ${previews.length} davon. Erwartet ist genau das eingefrorene Preview.`
+      };
+    }
+    if (previews[0].sha256 !== cameraPreview.sha256) {
+      return {
+        ok: false,
+        message: "Das Eingangsbild passt nicht zum eingefrorenen Kamera-Preview (sha256 weicht ab)."
+      };
+    }
+  } else if (previews.length > 0) {
+    return {
+      ok: false,
+      message: "Die Eingangsbilder nennen ein Kamera-Preview, der Lauf traegt aber keines."
+    };
+  }
+  return { ok: true };
+}
+function checkVariantBlock(record) {
+  const block = record.variant_of;
+  if (block === void 0) return { ok: true };
+  if (!isObject12(block)) return { ok: false, message: '"variant_of" muss ein Objekt sein.' };
+  if (!istText7(block.source_run_id)) {
+    return { ok: false, message: '"variant_of.source_run_id" fehlt oder ist leer.' };
+  }
+  if (block.source_run_id === record.run_id) {
+    return { ok: false, message: "Ein Lauf kann nicht Variante seiner selbst sein." };
+  }
+  if (!istText7(block.operation_id) || block.operation_id !== record.operation_id) {
+    return {
+      ok: false,
+      message: '"variant_of.operation_id" fehlt oder widerspricht "operation_id" des Laufs.'
+    };
+  }
+  if (record.provider !== MCP_CLIENT_PROVIDER || record.status !== "succeeded") {
+    return {
+      ok: false,
+      message: `Ein Variantenlauf ist ein erfolgreicher Lauf mit provider "${MCP_CLIENT_PROVIDER}".`
+    };
+  }
+  return checkVariantInputAssets(
+    block.input_assets,
+    record.camera_preview
+  );
+}
+function buildPromptRunVariantRecord(eingabe) {
+  const now = eingabe.now ?? (() => /* @__PURE__ */ new Date());
+  const quelle = eingabe.source;
+  if (!istText7(eingabe.runId) || !istText7(eingabe.operationId)) {
+    return { kind: "rejected", message: "Ein Variantenlauf braucht run_id und operation_id." };
+  }
+  if (!quelle || quelle.status !== "succeeded" || !quelle.output || !quelle.input_payload) {
+    return {
+      kind: "rejected",
+      message: "Nur ein erfolgreicher Lauf mit eingefrorener Eingabe kann Quelle einer Variante sein."
+    };
+  }
+  if (quelle.run_id === eingabe.runId) {
+    return { kind: "rejected", message: "Die Variante braucht eine eigene run_id." };
+  }
+  const eingabeSnapshot = structuredClone(quelle.input_payload);
+  const modell = eingabeSnapshot.target_model ?? {};
+  if (typeof modell.max_prompt_chars === "number" && eingabe.positive.length > modell.max_prompt_chars) {
+    return {
+      kind: "rejected",
+      message: `Der Prompt hat ${eingabe.positive.length} Zeichen; das eingefrorene Zielmodell erlaubt hoechstens ${modell.max_prompt_chars}.`
+    };
+  }
+  const assets = checkVariantInputAssets(eingabe.inputAssets, quelle.camera_preview);
+  if (!assets.ok) return { kind: "rejected", message: assets.message };
+  const notiz = istText7(eingabe.note) ? eingabe.note.trim() : null;
+  const geprueft = checkRunResponse({
+    positive: eingabe.positive,
+    negative: eingabe.negative ?? null,
+    feedback: `Promptvariante von Lauf ${quelle.run_id}; Snapshot und Eingangsbilder unveraendert uebernommen.`,
+    visibility: {
+      basis: VARIANT_VISIBILITY_BASIS,
+      nodes: unbeurteilteKnoten(eingabeSnapshot),
+      assumptions: [VARIANT_ASSUMPTION]
+    },
+    notes: notiz === null ? [] : [`Notiz zur Variante: ${notiz}`]
+  }, eingabeSnapshot);
+  if (!geprueft.ok) return { kind: "rejected", message: geprueft.message };
+  const output = {
+    ...geprueft.output,
+    // **Unveraendert** — `checkRunResponse` liefert den Text ohnehin woertlich.
+    positive: eingabe.positive
+  };
+  const origin = {
+    host: "mcp",
+    ...istText7(eingabe.declaredModelId) ? { declared_model_id: eingabe.declaredModelId } : {},
+    renderer_instruction_was_system_prompt: false
+  };
+  const record = {
+    run_id: eingabe.runId,
+    // Woertlich aus dem Quelllauf: dieselbe Herkunft, dieselben Kennungen.
+    shot_version_id: quelle.shot_version_id,
+    shot_element_id: quelle.shot_element_id,
+    scene_setup_version_id: quelle.scene_setup_version_id,
+    camera_id: quelle.camera_id,
+    target_model_version_id: quelle.target_model_version_id,
+    provider: MCP_CLIENT_PROVIDER,
+    model_id: UNVERIFIED_MODEL_ID,
+    system_prompt: VARIANT_SYSTEM_PROMPT,
+    input_payload: eingabeSnapshot,
+    status: "succeeded",
+    failure: null,
+    output,
+    raw_output: JSON.stringify({
+      positive: eingabe.positive,
+      negative: output.negative,
+      note: notiz
+    }),
+    ...quelle.source ? { source: structuredClone(quelle.source) } : {},
+    ...quelle.camera_preview ? { camera_preview: structuredClone(quelle.camera_preview) } : {},
+    operation_id: eingabe.operationId,
+    execution_origin: origin,
+    variant_of: {
+      source_run_id: quelle.run_id,
+      operation_id: eingabe.operationId,
+      input_assets: eingabe.inputAssets.map((asset) => structuredClone(asset))
+    },
+    created_at: now().toISOString()
+  };
+  return { kind: "ok", record };
+}
+function variantOf(run) {
+  const block = run.variant_of;
+  if (!isObject12(block) || !istText7(block.source_run_id)) return null;
+  return block;
+}
+function sameVariantRequest(run, anfrage) {
+  const block = variantOf(run);
+  if (!block || block.source_run_id !== anfrage.sourceRunId || !run.output) return false;
+  const negativ = istText7(anfrage.negative) ? anfrage.negative : null;
+  const notiz = istText7(anfrage.note) ? anfrage.note.trim() : null;
+  let gespeichert = {};
+  try {
+    gespeichert = JSON.parse(run.raw_output ?? "{}");
+  } catch {
+    return false;
+  }
+  return run.output.positive === anfrage.positive && (run.output.negative ?? null) === negativ && (gespeichert.note ?? null) === notiz;
+}
+
 // src/lib/szenen/seedListe.ts
 var DEFAULT_SEED_VORLAGE = {
   name: "Default",
@@ -8636,6 +8976,398 @@ async function leseBilderAusZip(datei) {
   return bilder;
 }
 
+// src/lib/szenen/stageOperations.ts
+var NODE_TYPES = ["subject", "object", "surface", "light", "camera_target", "group", "other"];
+var PROXY_PRIMITIVES = ["humanoid_proxy", "box", "cylinder", "sphere", "plane", "room_shell", "furniture_proxy"];
+var SLUG = /^[a-z][a-z0-9_]{0,62}$/;
+var Abgelehnt = class extends Error {
+};
+var fail2 = (message) => {
+  throw new Abgelehnt(message);
+};
+function vec3(value2, label, positive = false) {
+  if (!Array.isArray(value2) || value2.length !== 3 || value2.some((n) => typeof n !== "number" || !Number.isFinite(n))) {
+    fail2(`${label}: drei endliche Zahlen erforderlich.`);
+  }
+  if (positive && value2.some((n) => n <= 0)) fail2(`${label}: alle Werte m\xFCssen positiv sein.`);
+  return [...value2];
+}
+function farbe(value2, label) {
+  const hex = normalizePreviewColor(value2);
+  if (!hex) fail2(`${label}: Farbe als RGB-Hexwert #rrggbb angeben, angekommen ist ${JSON.stringify(value2)}.`);
+  return hex;
+}
+function checkProxyShape(proxy) {
+  if (proxy.primitive === "furniture_proxy" && !["chair", "table", "floor_lamp"].includes(proxy.variant)) fail2("M\xF6bel ben\xF6tigen variant: chair, table oder floor_lamp.");
+  if (proxy.pose_ref != null && !["standing", "sitting", "walking", "arms_crossed", "hand_on_chin"].includes(proxy.pose_ref)) fail2("Unbekannte Personenpose.");
+  if (proxy.morph && Object.entries(proxy.morph).some(([key, v]) => !["build", "gender"].includes(key) || typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 1)) fail2("Morph-Regler ben\xF6tigen endliche Werte zwischen 0 und 1.");
+}
+var hiddenOf = (shot) => new Set(Array.isArray(shot?.overrides?.hidden_nodes) ? shot.overrides.hidden_nodes : []);
+function previewColorNodes(scene, setup, shot) {
+  const hidden = hiddenOf(shot);
+  const overrides = new Map((setup?.node_overrides ?? []).map((o) => [o.node_id, o]));
+  return (Array.isArray(scene.nodes) ? scene.nodes : []).filter((n) => !hidden.has(n.node_id)).map((n) => {
+    const o = overrides.get(n.node_id);
+    return { node_id: n.node_id, type: n.type, proxy_3d: (o && o.proxy_3d !== void 0 ? o.proxy_3d : n.proxy_3d) ?? null };
+  });
+}
+function pinPreviewColors(scene, setup, shot) {
+  const nodes = Array.isArray(scene.nodes) ? scene.nodes : [];
+  const colors = stageColors(previewColorNodes(scene, setup, shot));
+  const taken = Object.values(colors).map((c) => c.hex);
+  return {
+    ...scene,
+    nodes: nodes.map((n) => {
+      if (!n.proxy_3d || normalizePreviewColor(n.proxy_3d.preview_color) || setup && proxyUeberschrieben(setup, n.node_id)) return n;
+      let hex = colors[n.node_id]?.hex;
+      if (!hex) {
+        hex = distinctPreviewColor(n.type, taken);
+        taken.push(hex);
+      }
+      return { ...n, proxy_3d: { ...n.proxy_3d, preview_color: hex } };
+    })
+  };
+}
+function fremdeVerweise(nodeId, setup, shot) {
+  const out = [];
+  for (const c of setup.camera_rig?.cameras ?? []) {
+    if (c.orientation?.target?.node_ref === nodeId) out.push(`Kamera ${c.camera_id} blickt auf ihn`);
+    if (c.framing?.target?.node_ref === nodeId) out.push(`Kamera ${c.camera_id} rahmt ihn`);
+    if (c.focus?.node_ref === nodeId) out.push(`Kamera ${c.camera_id} fokussiert ihn`);
+  }
+  if (shot) {
+    if (shot.overrides?.focus?.node_ref === nodeId) out.push("der Shot fokussiert ihn");
+    if (shot.overrides?.framing?.target?.node_ref === nodeId) out.push("der Shot rahmt ihn");
+    if (hiddenOf(shot).has(nodeId)) out.push("der Shot blendet ihn aus");
+  }
+  return out;
+}
+function proxyUeberschrieben(setup, nodeId) {
+  return (setup.node_overrides ?? []).some((o) => o.node_id === nodeId && o.proxy_3d !== void 0);
+}
+function neueNodeId(nodes, type) {
+  const basis = SLUG.test(type) ? type : "node";
+  for (let i = 1; ; i++) {
+    const id = `${basis}_${i}`;
+    if (!nodes.some((n) => n.node_id === id)) return id;
+  }
+}
+function applyStageOperations(input, operations) {
+  let scene = structuredClone(input.scene);
+  let setup = structuredClone(input.setup);
+  let shot = input.shot ? structuredClone(input.shot) : null;
+  const changed = { scene: false, setup: false, shot: false };
+  const created = [];
+  let adds = 0, removes = 0;
+  let index = null;
+  try {
+    if (!Array.isArray(scene.nodes)) fail2("Die Szene hat keine Node-Liste.");
+    if (!Array.isArray(setup.camera_rig?.cameras)) fail2("Der Aufbau hat kein Kamera-Rig.");
+    if (!Array.isArray(operations) || operations.length === 0) fail2("Mindestens eine Operation angeben.");
+    const vorher = JSON.stringify(scene);
+    scene = pinPreviewColors(scene, setup, shot);
+    if (JSON.stringify(scene) !== vorher) changed.scene = true;
+    for (const [i, operation] of operations.entries()) {
+      index = i;
+      const nodes = scene.nodes;
+      const findNode = (id) => {
+        const node = nodes.find((n) => n.node_id === id);
+        if (!node) fail2(`Node ${JSON.stringify(id)} gibt es in der Szene nicht.`);
+        return node;
+      };
+      switch (operation.op) {
+        case "add_node": {
+          adds++;
+          if (!NODE_TYPES.includes(operation.type)) fail2(`Unbekannter Node-Typ ${JSON.stringify(operation.type)}.`);
+          if (typeof operation.description !== "string" || !operation.description.trim()) fail2("add_node braucht eine semantische Beschreibung (description).");
+          const id = operation.node_id ?? neueNodeId(nodes, operation.type);
+          if (!SLUG.test(id)) fail2(`node_id ${JSON.stringify(id)} ist kein g\xFCltiger Bezeichner (Kleinbuchstaben, Ziffern, Unterstrich).`);
+          if (nodes.some((n) => n.node_id === id)) fail2(`node_id ${id} ist bereits vergeben.`);
+          const catalogueLabel = operation.label?.replace(/\s+\d+$/, "");
+          const vorlage = STAGE_CATALOGUE.find((e) => e.label === catalogueLabel && e.type === operation.type) ?? (operation.label && operation.type === "object" ? void 0 : STAGE_CATALOGUE.find((e) => e.type === operation.type));
+          const dimensions = operation.dimensions ? vec3(operation.dimensions, "dimensions", true) : [...vorlage?.dimensions ?? [0.5, 0.5, 0.5]];
+          const primitive = operation.primitive ?? vorlage?.primitive ?? "box";
+          if (!PROXY_PRIMITIVES.includes(primitive)) fail2(`Unbekanntes Primitive ${JSON.stringify(primitive)}.`);
+          scene = pinPreviewColors(scene, setup, shot);
+          const taken = Object.values(stageColors(previewColorNodes(scene, setup, shot))).map((c) => c.hex);
+          const color = operation.preview_color !== void 0 ? farbe(operation.preview_color, "preview_color") : distinctPreviewColor(operation.type, taken);
+          const node = {
+            node_id: id,
+            type: operation.type,
+            ...operation.label ? { label: operation.label } : {},
+            semantic: { description: operation.description, ...operation.properties ? { properties: operation.properties } : {} },
+            proxy_3d: {
+              primitive,
+              dimensions,
+              preview_color: color,
+              origin: "floor_center",
+              ...primitive === "furniture_proxy" ? { variant: operation.variant ?? (vorlage && "variant" in vorlage ? vorlage.variant : void 0) } : {},
+              ...primitive === "humanoid_proxy" ? { pose_ref: operation.pose_ref ?? "standing", morph: operation.morph ?? { build: 0.5, gender: 0.5 } } : {}
+            }
+          };
+          scene = { ...scene, unit_system: "blender_z_up_meters", nodes: [...scene.nodes, node] };
+          checkProxyShape(node.proxy_3d);
+          const position = operation.position ? vec3(operation.position, "position") : [0, 0, 0];
+          setup = {
+            ...setup,
+            coordinate_system: "blender_z_up_meters",
+            placements: [...setup.placements ?? [], {
+              node_id: id,
+              position,
+              ...operation.rotation_euler_deg ? { rotation_euler_deg: vec3(operation.rotation_euler_deg, "rotation_euler_deg") } : {},
+              ...operation.scale ? { scale: vec3(operation.scale, "scale", true) } : {}
+            }]
+          };
+          changed.scene = changed.setup = true;
+          created.push(id);
+          break;
+        }
+        case "update_node": {
+          const node = findNode(operation.node_id);
+          const next = { ...node };
+          if (operation.type !== void 0) {
+            if (!NODE_TYPES.includes(operation.type)) fail2(`Unbekannter Node-Typ ${JSON.stringify(operation.type)}.`);
+            next.type = operation.type;
+          }
+          if (operation.label !== void 0) {
+            if (operation.label === null || operation.label === "") delete next.label;
+            else next.label = operation.label;
+          }
+          if (operation.description !== void 0 || operation.properties !== void 0) {
+            if (operation.description !== void 0 && !String(operation.description).trim()) fail2("description darf nicht leer sein.");
+            next.semantic = {
+              ...node.semantic,
+              ...operation.description !== void 0 ? { description: operation.description } : {},
+              ...operation.properties !== void 0 ? { properties: operation.properties } : {}
+            };
+          }
+          if (operation.primitive !== void 0 || operation.dimensions !== void 0 || operation.preview_color !== void 0 || operation.variant !== void 0 || operation.pose_ref !== void 0 || operation.morph !== void 0) {
+            if (proxyUeberschrieben(setup, node.node_id)) {
+              fail2(`Node ${node.node_id} hat im Aufbau eine proxy_3d-\xDCberschreibung; Geometrie und Farbe wirken dort, nicht in der Szene.`);
+            }
+            const proxy = { ...node.proxy_3d ?? {} };
+            if (!node.proxy_3d && operation.dimensions === void 0) fail2(`Node ${node.node_id} hat keine Proxy-Geometrie; zuerst dimensions setzen.`);
+            if (operation.primitive !== void 0) {
+              if (!PROXY_PRIMITIVES.includes(operation.primitive)) fail2(`Unbekanntes Primitive ${JSON.stringify(operation.primitive)}.`);
+              proxy.primitive = operation.primitive;
+            }
+            proxy.primitive ?? (proxy.primitive = "box");
+            if (operation.dimensions !== void 0) proxy.dimensions = vec3(operation.dimensions, "dimensions", true);
+            if (operation.variant !== void 0) proxy.variant = operation.variant;
+            if (operation.pose_ref !== void 0) proxy.pose_ref = operation.pose_ref;
+            if (operation.morph !== void 0) proxy.morph = { ...proxy.morph, ...operation.morph };
+            if (operation.preview_color === null) delete proxy.preview_color;
+            else if (operation.preview_color !== void 0) proxy.preview_color = farbe(operation.preview_color, "preview_color");
+            checkProxyShape(proxy);
+            next.proxy_3d = proxy;
+          }
+          scene = { ...scene, nodes: nodes.map((n) => n === node ? next : n) };
+          changed.scene = true;
+          break;
+        }
+        case "place_node": {
+          findNode(operation.node_id);
+          const placements = setup.placements ?? [];
+          const vorhanden = placements.find((p) => p.node_id === operation.node_id);
+          if (!vorhanden && !operation.position) fail2(`Node ${operation.node_id} ist noch nicht platziert; position angeben.`);
+          const next = {
+            ...vorhanden ?? { node_id: operation.node_id },
+            ...operation.position ? { position: vec3(operation.position, "position") } : {},
+            ...operation.rotation_euler_deg ? { rotation_euler_deg: vec3(operation.rotation_euler_deg, "rotation_euler_deg") } : {},
+            ...operation.scale ? { scale: vec3(operation.scale, "scale", true) } : {}
+          };
+          setup = {
+            ...setup,
+            coordinate_system: setup.coordinate_system ?? "blender_z_up_meters",
+            placements: vorhanden ? placements.map((p) => p === vorhanden ? next : p) : [...placements, next]
+          };
+          changed.setup = true;
+          break;
+        }
+        case "remove_node": {
+          removes++;
+          findNode(operation.node_id);
+          const verweise = fremdeVerweise(operation.node_id, setup, shot);
+          if (verweise.length) fail2(`Node ${operation.node_id} wird noch verwendet: ${verweise.join("; ")}. Zuerst diese Bez\xFCge \xE4ndern.`);
+          scene = pinPreviewColors(scene, setup, shot);
+          scene = {
+            ...scene,
+            nodes: scene.nodes.filter((n) => n.node_id !== operation.node_id),
+            relations: (scene.relations ?? []).filter((r) => r.from !== operation.node_id && r.to !== operation.node_id)
+          };
+          setup = {
+            ...setup,
+            ...setup.placements ? { placements: setup.placements.filter((p) => p.node_id !== operation.node_id) } : {},
+            ...setup.node_overrides ? { node_overrides: setup.node_overrides.filter((o) => o.node_id !== operation.node_id) } : {}
+          };
+          changed.scene = changed.setup = true;
+          break;
+        }
+        case "add_camera": {
+          const camera = operation.camera;
+          if (!camera || typeof camera !== "object" || !SLUG.test(camera.camera_id)) fail2("add_camera braucht ein Kameraobjekt mit g\xFCltiger camera_id.");
+          if (setup.camera_rig.cameras.some((c) => c.camera_id === camera.camera_id)) fail2(`camera_id ${camera.camera_id} ist bereits vergeben.`);
+          if (typeof camera.aspect_ratio !== "string") fail2("Eine neue Kamera braucht ein explizites aspect_ratio.");
+          for (const ref of [camera.orientation?.target?.node_ref, camera.framing?.target?.node_ref, camera.focus?.node_ref]) {
+            if (ref !== void 0) findNode(ref);
+          }
+          setup = { ...setup, camera_rig: { ...setup.camera_rig, cameras: [...setup.camera_rig.cameras, structuredClone(camera)] } };
+          changed.setup = true;
+          break;
+        }
+        case "update_camera": {
+          const cameras = setup.camera_rig.cameras;
+          const camera = cameras.find((c) => c.camera_id === operation.camera_id);
+          if (!camera) fail2(`Kamera ${operation.camera_id} gibt es im Aufbau nicht.`);
+          if (!operation.changes || typeof operation.changes !== "object") fail2("update_camera braucht changes.");
+          if ("camera_id" in operation.changes && operation.changes.camera_id !== operation.camera_id) fail2("camera_id ist unver\xE4nderlich.");
+          const next = { ...camera, ...structuredClone(operation.changes) };
+          for (const ref of [next.orientation?.target?.node_ref, next.framing?.target?.node_ref, next.focus?.node_ref]) {
+            if (ref !== void 0) findNode(ref);
+          }
+          setup = { ...setup, camera_rig: { ...setup.camera_rig, cameras: cameras.map((c) => c === camera ? next : c) } };
+          changed.setup = true;
+          break;
+        }
+        case "set_shot_camera": {
+          if (!shot) fail2("Ohne Shot-Entwurf gibt es keine aktive Kamera zu setzen.");
+          if (!setup.camera_rig.cameras.some((c) => c.camera_id === operation.camera_id)) fail2(`Kamera ${operation.camera_id} gibt es im Aufbau nicht.`);
+          shot = { ...shot, camera_id: operation.camera_id };
+          changed.shot = true;
+          break;
+        }
+        default:
+          fail2(`Unbekannte Operation ${JSON.stringify(operation.op)}.`);
+      }
+    }
+    index = null;
+    if (adds && removes) fail2("Hinzuf\xFCgen und Entfernen bitte in getrennten Aufrufen: F\xFCr beides zugleich gibt es keine Schreibreihenfolge ohne verwaisten Zwischenstand.");
+    const ids = new Set(scene.nodes.map((n) => n.node_id));
+    const waise = (setup.placements ?? []).filter((p) => !ids.has(p.node_id)).map((p) => p.node_id);
+    if (waise.length) fail2(`Placements ohne Node: ${waise.join(", ")}.`);
+    if (shot && !setup.camera_rig.cameras.some((c) => c.camera_id === shot.camera_id)) fail2(`Die aktive Kamera ${shot.camera_id} fehlt im Aufbau.`);
+  } catch (e) {
+    if (e instanceof Abgelehnt) return { kind: "rejected", message: e.message, operation_index: index };
+    throw e;
+  }
+  const order = removes ? ["setup", "scene", "shot"] : ["scene", "setup", "shot"];
+  return {
+    kind: "ok",
+    payloads: { scene, setup, shot },
+    changed,
+    created_node_ids: created,
+    write_order: order.filter((k) => changed[k]),
+    color_conflicts: previewColorConflicts(previewColorNodes(scene, setup, shot))
+  };
+}
+
+// src/lib/szenen/stageChain.ts
+function stageValue(r) {
+  if (r.kind !== "ok" || r.value == null) {
+    throw new Error(r.message ?? (r.kind === "conflict" ? "Der Entwurf wurde parallel ge\xE4ndert; die letzte \xC4nderung wurde nicht gespeichert." : `Operation fehlgeschlagen: ${r.kind}`));
+  }
+  return r.value;
+}
+async function lies(elements, id) {
+  const gelesen = stageValue(await elements.getElement(id));
+  return gelesen;
+}
+async function mitKette(elements, type, chainId) {
+  const liste = stageValue(await elements.listElements({ type }));
+  const treffer = [];
+  for (const eintrag of liste) {
+    const s = await lies(elements, eintrag.element_id);
+    if (s.draft?.chain?.chain_id === chainId) treffer.push(s);
+  }
+  return treffer;
+}
+async function findStageDraftChain(elements, sceneElementId) {
+  const scene = await lies(elements, sceneElementId);
+  if (scene.element.type !== "scene") throw new Error(`Element ${sceneElementId} ist keine Szene.`);
+  if (scene.draftFork) throw new Error("Die Szene hat konkurrierende Entw\xFCrfe. Bitte zuerst aufl\xF6sen.");
+  const chainId = scene.draft?.chain?.chain_id;
+  if (!chainId) return null;
+  const setups = await mitKette(elements, "scene_setup", chainId);
+  const shots = await mitKette(elements, "shot", chainId);
+  if (setups.length !== 1 || shots.length !== 1) {
+    throw new Error(`Die Draft-Kette ${chainId} ist unvollst\xE4ndig oder mehrdeutig (${setups.length} Aufbau-, ${shots.length} Shot-Entw\xFCrfe).`);
+  }
+  const link = setups[0].draft.chain.links.find((l) => l.field === "scene_ref");
+  if (link?.target_draft_id !== scene.draft.draft_id) throw new Error("Die gespeicherte Draft-Kette passt nicht zur Szene.");
+  const shotLink = shots[0].draft.chain.links.find((l) => l.field === "scene_setup_ref");
+  if (shotLink?.target_draft_id !== setups[0].draft.draft_id) throw new Error("Der Shot-Entwurf zeigt nicht auf den Aufbau dieser Kette.");
+  return { chain_id: chainId, scene, setup: setups[0], shot: shots[0] };
+}
+async function openStageDraftChain(elements, input) {
+  const { sceneElementId, setupVersionId, contextId } = input;
+  const setup = await lies(elements, input.setupElementId);
+  if (setup.element.type !== "scene_setup") throw new Error(`Element ${input.setupElementId} ist kein Scene Setup.`);
+  if (setup.draftFork) throw new Error("Der Aufbau hat konkurrierende Entw\xFCrfe. Bitte zuerst aufl\xF6sen.");
+  if (setupVersionId && setup.draft) throw new Error("F\xFCr diesen Aufbau existiert bereits ein Entwurf. Bitte diesen explizit ausw\xE4hlen.");
+  const setupPayload = setupVersionId ? setup.versions.find((v) => v.version_id === setupVersionId)?.payload : setup.draft?.payload;
+  if (!setupPayload) throw new Error("Der gew\xE4hlte Stand ist nicht mehr vorhanden.");
+  const scene = await lies(elements, sceneElementId);
+  if (scene.draftFork) throw new Error("Die Szene hat konkurrierende Entw\xFCrfe.");
+  const existingChain = setup.draft?.chain;
+  if (existingChain) {
+    const link = existingChain.links.find((l) => l.field === "scene_ref");
+    if (link?.target_draft_id !== scene.draft?.draft_id || scene.draft?.chain?.chain_id !== existingChain.chain_id) {
+      throw new Error("Die gespeicherte Draft-Kette passt nicht zur Szene.");
+    }
+  } else if (scene.draft?.chain) {
+    throw new Error("Die Szene geh\xF6rt bereits zu einer anderen Draft-Kette.");
+  }
+  const ref = setupPayload.scene_ref;
+  if (!existingChain && ref?.element_id && ref.element_id !== sceneElementId) {
+    throw new Error("Der Aufbau geh\xF6rt zu einer anderen Szene.");
+  }
+  const scenePayload = scene.draft?.payload ?? scene.versions.find((v) => v.version_id === ref?.version_id)?.payload;
+  if (!scenePayload) throw new Error("Die referenzierte Szene ist nicht vorhanden.");
+  const chainId = existingChain?.chain_id ?? (input.newChainId ?? (() => crypto.randomUUID()))();
+  const chain = existingChain ?? { chain_id: chainId, origin: "stage", links: [] };
+  let sceneDraft = scene.draft;
+  if (!existingChain) {
+    sceneDraft = stageValue(await elements.writeDraft({
+      elementId: sceneElementId,
+      payload: scenePayload,
+      expectedRevision: scene.draft?.revision ?? 0,
+      baseVersionId: scene.draft?.base_version_id ?? ref?.version_id ?? null,
+      chain: { ...chain, links: [] }
+    }));
+  }
+  let setupDraft = setup.draft;
+  if (!existingChain) {
+    setupDraft = stageValue(await elements.writeDraft({
+      elementId: setup.element.element_id,
+      payload: setupPayload,
+      expectedRevision: setup.draft?.revision ?? 0,
+      baseVersionId: setupVersionId,
+      chain: { ...chain, links: [{ field: "scene_ref", target_element_id: sceneElementId, target_draft_id: sceneDraft.draft_id }] }
+    }));
+  }
+  const shots = await mitKette(elements, "shot", chainId);
+  let shot = shots[0] ?? null;
+  if (!shot) {
+    const created = stageValue(await elements.createElement({ type: "shot", contextId, title: "3D-Kameraansicht" }));
+    const cameraId = setupPayload.camera_rig?.cameras?.[0]?.camera_id;
+    if (!cameraId) throw new Error("Der Aufbau hat keine Kamera.");
+    const shotPayload = { camera_id: cameraId, ...input.targetModelId ? { prompt_render_settings: { target_model_id: input.targetModelId } } : {} };
+    stageValue(await elements.writeDraft({
+      elementId: created.element_id,
+      payload: shotPayload,
+      expectedRevision: 0,
+      chain: { ...chain, links: [{ field: "scene_setup_ref", target_element_id: setup.element.element_id, target_draft_id: setupDraft.draft_id }] }
+    }));
+    shot = await lies(elements, created.element_id);
+  }
+  return {
+    chain_id: chainId,
+    scene: await lies(elements, sceneElementId),
+    setup: await lies(elements, setup.element.element_id),
+    shot
+  };
+}
+
 // src/lib/szenen/textGenerationPort.ts
 function simulatedAnswerFor(request) {
   let input;
@@ -9140,7 +9872,7 @@ function validateDerivationInput(input) {
   if (input.policy.produces.length === 0) return "Die Regel erzeugt keinen einzigen Vorschlag.";
   return null;
 }
-var isObject12 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isObject13 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var MAX_PROPOSAL_TITLE_LENGTH = 120;
 function fallbackProposalTitle(type) {
   return `Rekonstruktion ${type}`;
@@ -9157,7 +9889,7 @@ function pruefeNodeLabels(payload) {
   if (!Array.isArray(payload.nodes)) return { payload, hinweise: [] };
   const hinweise = [];
   const nodes = payload.nodes.map((node, i) => {
-    if (!isObject12(node) || typeof node.node_id !== "string") return node;
+    if (!isObject13(node) || typeof node.node_id !== "string") return node;
     const abgeleitet = kurznameAusNodeId(node.node_id);
     if (!("label" in node)) {
       hinweise.push({
@@ -9190,7 +9922,7 @@ function resolveJsonPointer(wurzel, pointer) {
       aktuell = aktuell[index];
       continue;
     }
-    if (!isObject12(aktuell) || !(schluessel in aktuell)) {
+    if (!isObject13(aktuell) || !(schluessel in aktuell)) {
       return { found: false, value: void 0 };
     }
     aktuell = aktuell[schluessel];
@@ -9204,7 +9936,7 @@ function collectVersionRefs2(value2) {
       knoten.forEach(besuchen);
       return;
     }
-    if (!isObject12(knoten)) return;
+    if (!isObject13(knoten)) return;
     if (typeof knoten.element_id === "string" && typeof knoten.version_id === "string") {
       gefunden.push({ element_id: knoten.element_id, version_id: knoten.version_id });
     }
@@ -9270,7 +10002,7 @@ function assessDerivationResponse(value2, input) {
     envelope: null,
     contract_ok: false
   });
-  if (!isObject12(value2)) {
+  if (!isObject13(value2)) {
     befund({
       code: "response.not_object",
       severity: "error",
@@ -9288,7 +10020,7 @@ function assessDerivationResponse(value2, input) {
     });
   }
   const rohProposals = value2.proposals;
-  const proposalsLesbar = isObject12(rohProposals);
+  const proposalsLesbar = isObject13(rohProposals);
   if (!proposalsLesbar) {
     befund({
       code: "envelope.proposals_missing",
@@ -9298,7 +10030,7 @@ function assessDerivationResponse(value2, input) {
     });
   }
   const roh = proposalsLesbar ? rohProposals : {};
-  const rohGaps = isObject12(value2.gaps) ? value2.gaps : {};
+  const rohGaps = isObject13(value2.gaps) ? value2.gaps : {};
   const gapsUngefragt = Object.keys(rohGaps).filter(
     (t) => !input.policy.produces.includes(t)
   );
@@ -9310,7 +10042,7 @@ function assessDerivationResponse(value2, input) {
       pointer: "/gaps"
     });
   }
-  const fehlend = input.policy.produces.filter((t) => !isObject12(roh[t]));
+  const fehlend = input.policy.produces.filter((t) => !isObject13(roh[t]));
   if (fehlend.length > 0 && proposalsLesbar) {
     const d = befund({
       code: "envelope.proposals_missing_types",
@@ -9331,11 +10063,11 @@ function assessDerivationResponse(value2, input) {
       pointer: "/proposals"
     });
   }
-  const rohTitles = isObject12(value2.titles) ? value2.titles : {};
+  const rohTitles = isObject13(value2.titles) ? value2.titles : {};
   const umgebucht = [];
   const ohneLabel = [];
   for (const type of input.policy.produces) {
-    if (!isObject12(roh[type])) continue;
+    if (!isObject13(roh[type])) continue;
     const labelPruefung = type === "scene" ? pruefeNodeLabels(roh[type]) : { payload: roh[type], hinweise: [] };
     const payload = labelPruefung.payload;
     const eigene = [];
@@ -9372,7 +10104,7 @@ function assessDerivationResponse(value2, input) {
     const bezugPointer = bezug ? `/${bezug.field}` : null;
     let gapFehler = false;
     for (const eintrag of benannt) {
-      if (!isObject12(eintrag) || typeof eintrag.pointer !== "string" || typeof eintrag.reason !== "string" || !eintrag.reason.trim()) {
+      if (!isObject13(eintrag) || typeof eintrag.pointer !== "string" || typeof eintrag.reason !== "string" || !eintrag.reason.trim()) {
         eigene.push(befund({
           code: "proposal.gap_entry_invalid",
           severity: "error",
@@ -9449,7 +10181,7 @@ function assessDerivationResponse(value2, input) {
       });
     } else {
       for (const eintrag of value2.not_derivable) {
-        if (!isObject12(eintrag) || typeof eintrag.field !== "string" || typeof eintrag.reason !== "string") {
+        if (!isObject13(eintrag) || typeof eintrag.field !== "string" || typeof eintrag.reason !== "string") {
           befund({
             code: "envelope.not_derivable_entry_invalid",
             severity: "error",
@@ -9474,7 +10206,7 @@ function assessDerivationResponse(value2, input) {
       });
     } else {
       for (const eintrag of value2.conflicts) {
-        if (!isObject12(eintrag) || typeof eintrag.field !== "string" || typeof eintrag.from_image !== "string" || typeof eintrag.from_prompt !== "string") {
+        if (!isObject13(eintrag) || typeof eintrag.field !== "string" || typeof eintrag.from_image !== "string" || typeof eintrag.from_prompt !== "string") {
           befund({
             code: "envelope.conflicts_entry_invalid",
             severity: "error",
@@ -10314,9 +11046,46 @@ function usePagedPortQuery(seite, abhaengigkeiten, limit = LOAD_MORE_PAGE_SIZE)
   const [mehrFehler, setMehrFehler] = useState6(null);
   const [token, setToken] = useState6(0);
   const sequenz = useRef4(0);
+  const seitenRef = useRef4([]);
+  seitenRef.current = seiten;
+  const zuletzt = useRef4(null);
   useEffect5(() => {
     const meine = sequenz.current += 1;
     let abgemeldet = false;
+    const vorher = zuletzt.current;
+    zuletzt.current = { deps: abhaengigkeiten, token, limit };
+    const nurNeuLaden = vorher !== null && vorher.token !== token && vorher.limit === limit && vorher.deps.length === abhaengigkeiten.length && vorher.deps.every((d, i) => Object.is(d, abhaengigkeiten[i])) && seitenRef.current.length > 0;
+    const fehler5 = (e) => e instanceof Error ? e.message : String(e);
+    if (nurNeuLaden) {
+      const anzahl = seitenRef.current.length;
+      setMehrFehler(null);
+      void (async () => {
+        const neu = [];
+        let cursor = null;
+        try {
+          while (neu.length < anzahl) {
+            const ergebnis = await seite(cursor, limit);
+            if (abgemeldet || meine !== sequenz.current) return;
+            if (ergebnis.kind !== "ok") {
+              setMehrFehler(ergebnis.message);
+              return;
+            }
+            neu.push(ergebnis.value);
+            if (!ergebnis.value.hasMore) break;
+            cursor = ergebnis.value.nextCursor;
+          }
+        } catch (e) {
+          if (!abgemeldet && meine === sequenz.current) setMehrFehler(fehler5(e));
+          return;
+        }
+        setLaedtMehr(false);
+        setPhase({ status: "ready", value: neu[0] });
+        setSeiten(neu);
+      })();
+      return () => {
+        abgemeldet = true;
+      };
+    }
     setPhase({ status: "loading" });
     setSeiten([]);
     setLaedtMehr(false);
@@ -10337,7 +11106,7 @@ function usePagedPortQuery(seite, abhaengigkeiten, limit = LOAD_MORE_PAGE_SIZE)
       if (abgemeldet || meine !== sequenz.current) return;
       setPhase({
         status: "error",
-        message: e instanceof Error ? e.message : String(e),
+        message: fehler5(e),
         retryable: true
       });
     });
@@ -10655,7 +11424,7 @@ function ortVon(instanz) {
 
 // src/features/szenen/areas/SceneEditor.tsx
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
-var NODE_TYPES = [
+var NODE_TYPES2 = [
   "subject",
   "object",
   "surface",
@@ -10807,7 +11576,7 @@ var SceneEditor = ({
                 "data-testid": "neuer-node-typ",
                 value: neuerTyp,
                 onChange: (e) => setNeuerTyp(e.target.value),
-                children: NODE_TYPES.map((t) => /* @__PURE__ */ jsx6("option", { value: t, children: NODE_TYPE_LABELS[t] }, t))
+                children: NODE_TYPES2.map((t) => /* @__PURE__ */ jsx6("option", { value: t, children: NODE_TYPE_LABELS[t] }, t))
               }
             ),
             /* @__PURE__ */ jsx6(
@@ -10961,7 +11730,7 @@ var NodeFormular = ({
           value: node.type,
           disabled: readOnly,
           onChange: (e) => aendere({ ...node, type: e.target.value }),
-          children: NODE_TYPES.map((t) => /* @__PURE__ */ jsx6("option", { value: t, children: NODE_TYPE_LABELS[t] }, t))
+          children: NODE_TYPES2.map((t) => /* @__PURE__ */ jsx6("option", { value: t, children: NODE_TYPE_LABELS[t] }, t))
         }
       )
     ] }),
@@ -11997,8 +12766,8 @@ function feldLabel(type, pfad, name) {
 
 // src/features/szenen/areas/SchemaFields.tsx
 import { Fragment as Fragment4, jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
-var isObject13 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var istVersionRef = (v) => isObject13(v) && typeof v.element_id === "string" && typeof v.version_id === "string";
+var isObject14 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var istVersionRef = (v) => isObject14(v) && typeof v.element_id === "string" && typeof v.version_id === "string";
 function leseJson(wert) {
   if (!wert || wert === NULL_MARKER) return null;
   try {
@@ -12226,13 +12995,13 @@ var VersionRefListeFeld = ({ port, kontextkette, feld: feld2, wert, onChange, re
   }
   const schreiben = (neu) => onChange(
     feld2.path,
-    schreibListe(neu.map((eintrag, i) => isObject13(eintrag) && mitRolle2 ? { ...eintrag, rank: i } : eintrag))
+    schreibListe(neu.map((eintrag, i) => isObject14(eintrag) && mitRolle2 ? { ...eintrag, rank: i } : eintrag))
   );
   return /* @__PURE__ */ jsxs10("div", { className: "szenen-feld__reflist", "data-testid": `reflist-${feld2.path}`, children: [
     liste.length === 0 && /* @__PURE__ */ jsx11("p", { "data-testid": `reflist-${feld2.path}-leer`, children: "Keine Eintr\xE4ge." }),
     /* @__PURE__ */ jsx11("ol", { children: liste.map((eintrag, index) => /* @__PURE__ */ jsxs10("li", { "data-testid": `reflist-${feld2.path}-${index}`, children: [
       istVersionRef(eintrag) ? /* @__PURE__ */ jsx11(RefAnzeige, { port, ref_: eintrag, testId: `reflist-${feld2.path}-${index}-ref` }) : /* @__PURE__ */ jsx11("code", { children: JSON.stringify(eintrag) }),
-      mitRolle2 === "styleRole" && isObject13(eintrag) && /* @__PURE__ */ jsxs10(
+      mitRolle2 === "styleRole" && isObject14(eintrag) && /* @__PURE__ */ jsxs10(
         "select",
         {
           "data-testid": `reflist-${feld2.path}-${index}-role`,
@@ -12245,7 +13014,7 @@ var VersionRefListeFeld = ({ port, kontextkette, feld: feld2, wert, onChange, re
           ]
         }
       ),
-      mitRolle2 === "frei" && isObject13(eintrag) && /* @__PURE__ */ jsx11(
+      mitRolle2 === "frei" && isObject14(eintrag) && /* @__PURE__ */ jsx11(
         "input",
         {
           "data-testid": `reflist-${feld2.path}-${index}-role`,
@@ -12255,7 +13024,7 @@ var VersionRefListeFeld = ({ port, kontextkette, feld: feld2, wert, onChange, re
           onChange: (e) => schreiben(liste.map((x, i) => i === index ? { ...x, role: e.target.value } : x))
         }
       ),
-      mitGewicht && isObject13(eintrag) && /* @__PURE__ */ jsx11(
+      mitGewicht && isObject14(eintrag) && /* @__PURE__ */ jsx11(
         "input",
         {
           "data-testid": `reflist-${feld2.path}-${index}-weight`,
@@ -12453,7 +13222,7 @@ var KameraFeld = ({
     if (phase.status !== "ready" || !phase.value) return [];
     const cameras = valueAtPath(phase.value.payload, "camera_rig.cameras");
     if (!Array.isArray(cameras)) return [];
-    return cameras.filter(isObject13).map((c) => ({
+    return cameras.filter(isObject14).map((c) => ({
       id: typeof c.camera_id === "string" ? c.camera_id : null,
       name: typeof c.name === "string" ? c.name : null
     })).filter((c) => c.id !== null);
@@ -12598,11 +13367,11 @@ var MediaRefListeFeld = ({ feld: feld2, wert, onChange, readOnly }) => {
   }
   const schreiben = (neu) => onChange(
     feld2.path,
-    schreibListe(neu.map((e, i) => isObject13(e) ? { ...e, position: i } : e))
+    schreibListe(neu.map((e, i) => isObject14(e) ? { ...e, position: i } : e))
   );
   return /* @__PURE__ */ jsxs10("div", { className: "szenen-feld__liste", "data-testid": `feld-${feld2.path}`, children: [
     liste.map((eintrag, index) => {
-      const objekt = isObject13(eintrag) ? eintrag : {};
+      const objekt = isObject14(eintrag) ? eintrag : {};
       return /* @__PURE__ */ jsxs10("div", { className: "szenen-feld__liste-zeile", children: [
         /* @__PURE__ */ jsx11(
           "input",
@@ -12611,7 +13380,7 @@ var MediaRefListeFeld = ({ feld: feld2, wert, onChange, readOnly }) => {
             value: typeof objekt.asset_id === "string" ? objekt.asset_id : "",
             readOnly,
             placeholder: "asset_id (UUID)",
-            onChange: (e) => schreiben(liste.map((x, i) => i === index ? { ...isObject13(x) ? x : {}, asset_id: e.target.value } : x))
+            onChange: (e) => schreiben(liste.map((x, i) => i === index ? { ...isObject14(x) ? x : {}, asset_id: e.target.value } : x))
           }
         ),
         /* @__PURE__ */ jsxs10(
@@ -12620,7 +13389,7 @@ var MediaRefListeFeld = ({ feld: feld2, wert, onChange, readOnly }) => {
             "data-testid": `feld-${feld2.path}-${index}-rolle`,
             value: typeof objekt.role === "string" ? objekt.role : "",
             disabled: readOnly,
-            onChange: (e) => schreiben(liste.map((x, i) => i === index ? { ...isObject13(x) ? x : {}, role: e.target.value } : x)),
+            onChange: (e) => schreiben(liste.map((x, i) => i === index ? { ...isObject14(x) ? x : {}, role: e.target.value } : x)),
             children: [
               /* @__PURE__ */ jsx11("option", { value: "", children: "(Rolle w\xE4hlen)" }),
               rollen.map((r) => /* @__PURE__ */ jsx11("option", { value: r, children: r }, r))
@@ -12663,7 +13432,7 @@ var LEERES_PROFIL = {
 var listeAus = (text2) => text2.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
 var AusfuehrungsprofileFeld = ({ feld: feld2, wert, onChange, readOnly }) => {
   const gelesen = leseListe(wert);
-  const profile = (gelesen ?? []).filter(isObject13);
+  const profile = (gelesen ?? []).filter(isObject14);
   const unlesbar = gelesen === null;
   const schreibe = (neu) => onChange(feld2.path, schreibListe(neu));
   const alleBefunde = checkImageExecutionProfiles(profile);
@@ -15419,6 +16188,7 @@ var STATUS_TEXT = {
   failed: "fehlgeschlagen"
 };
 function herkunftChip(lauf) {
+  if (variantOf(lauf)) return "Variante \xFCber MCP";
   if (lauf.provider === MANUAL_PROVIDER) return "manuell eingetragen";
   if (lauf.provider === MCP_CLIENT_PROVIDER) return "\xFCber MCP";
   return lauf.model_id;
@@ -15464,6 +16234,7 @@ var LaufInhalt = ({
     onItemGespeichert();
   };
   const handeingabe = manualEntryOf(lauf);
+  const variante = variantOf(lauf);
   const id = lauf.run_id;
   const promptUndTags = /* @__PURE__ */ jsxs18(Fragment9, { children: [
     lauf.status === "succeeded" && lauf.output && /* @__PURE__ */ jsx20(
@@ -15530,6 +16301,23 @@ var LaufInhalt = ({
         /* @__PURE__ */ jsx20("summary", { children: "Erl\xE4uterung des Modells" }),
         /* @__PURE__ */ jsx20("p", { "data-testid": `feedback-${id}`, children: lauf.output.feedback })
       ] }),
+      variante && /* @__PURE__ */ jsxs18("section", { className: "szenen-lauf__handeingabe", "data-testid": `variante-${id}`, children: [
+        /* @__PURE__ */ jsx20("h5", { children: "Promptvariante" }),
+        /* @__PURE__ */ jsxs18("p", { children: [
+          "Snapshot und Eingangsbilder aus Lauf",
+          " ",
+          /* @__PURE__ */ jsx20("code", { children: variante.source_run_id }),
+          "; der Prompttext stammt unver\xE4ndert vom MCP-Aufrufer."
+        ] }),
+        variante.input_assets.map((asset) => /* @__PURE__ */ jsxs18("p", { "data-testid": `variante-asset-${id}-${asset.position}`, children: [
+          "Eingang ",
+          asset.position + 1,
+          asset.prompt_token ? ` (${asset.prompt_token})` : "",
+          ":",
+          " ",
+          /* @__PURE__ */ jsx20("code", { children: asset.asset_id })
+        ] }, asset.asset_id))
+      ] }),
       handeingabe && /* @__PURE__ */ jsxs18("section", { className: "szenen-lauf__handeingabe", "data-testid": `handeingabe-${id}`, children: [
         /* @__PURE__ */ jsx20("h5", { children: "Manuell erfasst" }),
         /* @__PURE__ */ jsxs18("p", { "data-testid": `handeingabe-von-${id}`, children: [
@@ -16658,12 +17446,12 @@ var ElementSheet = ({
 import { useEffect as useEffect15, useMemo as useMemo6, useRef as useRef11, useState as useState21 } from "react";
 
 // src/lib/szenen/bausteinKatalog.ts
-var isObject14 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isObject15 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var text = (v) => typeof v === "string" && v.trim() !== "" ? v : null;
 function kachelAssetId(payload) {
-  const refs = isObject14(payload) && Array.isArray(payload.media_refs) ? payload.media_refs : [];
+  const refs = isObject15(payload) && Array.isArray(payload.media_refs) ? payload.media_refs : [];
   for (const rolle of ["example", "reference"]) {
-    const treffer = refs.find((r) => isObject14(r) && r.role === rolle && typeof r.asset_id === "string");
+    const treffer = refs.find((r) => isObject15(r) && r.role === rolle && typeof r.asset_id === "string");
     if (treffer) return treffer.asset_id;
   }
   return null;
@@ -16706,7 +17494,7 @@ async function bausteinKatalog(queries, kette) {
       katalog.push({ ...basis, titel, zustand: { art: "fork" } });
       continue;
     }
-    const payload = isObject14(version.payload) ? version.payload : {};
+    const payload = isObject15(version.payload) ? version.payload : {};
     katalog.push({
       element_id: stammsatz.element_id,
       titel,
@@ -17037,7 +17825,7 @@ var BausteinSheet = ({
 import React21, { useEffect as useEffect17, useState as useState23, useRef as useRef12, useReducer } from "react";
 
 // src/features/szenen/areas/loadStageEngine.ts
-var loadStageEngine = () => import("./StageEngine-3MOBM2WX.mjs");
+var loadStageEngine = () => import("./StageEngine-PYWITIIY.mjs");
 
 // src/features/szenen/areas/StagePromptSettings.tsx
 import { useEffect as useEffect16, useState as useState22 } from "react";
@@ -17050,9 +17838,13 @@ function StagePromptSettings({ port, contextId, forElementId, target, settings,
   const [inspection, setInspection] = useState22(null);
   const [inspectionError, setInspectionError] = useState22("");
   const [previewImage, setPreviewImage] = useState22("");
+  const [request, setRequest] = useState22(0);
+  const [rendering, setRendering] = useState22(false);
+  const [renderedBasis, setRenderedBasis] = useState22(null);
   const inputFingerprint = JSON.stringify(input);
   const settingsFingerprint = JSON.stringify(settings);
   const [instruction, setInstruction] = useState22(settings.user_instruction ?? "");
+  const basis = JSON.stringify([inputFingerprint, settingsFingerprint, instruction, target, forElementId, contextId, tags]);
   useEffect16(() => setInstruction(settings.user_instruction ?? ""), [settings.user_instruction]);
   useEffect16(() => {
     let live = true;
@@ -17110,10 +17902,10 @@ function StagePromptSettings({ port, contextId, forElementId, target, settings,
     };
   }, [port, contextId, forElementId, target, settings.reference_sentence_tag, tags]);
   useEffect16(() => {
+    if (!request) return;
     let live = true;
-    setInspection(null);
-    setPreviewImage("");
     setInspectionError("");
+    setRendering(true);
     const timer = setTimeout(() => {
       void (async () => {
         try {
@@ -17152,17 +17944,22 @@ function StagePromptSettings({ port, contextId, forElementId, target, settings,
           if (live) {
             setInspection(prepared);
             setPreviewImage(`data:${preview.mime_type};base64,${preview.data}`);
+            setRenderedBasis(basis);
           }
         } catch (e) {
           if (live) setInspectionError(String(e));
+        } finally {
+          if (live) setRendering(false);
         }
       })();
-    }, 250);
+    }, 50);
     return () => {
       live = false;
       clearTimeout(timer);
+      setRendering(false);
     };
-  }, [port, contextId, forElementId, target, inputFingerprint, settingsFingerprint, instruction, tags, previewRenderer]);
+  }, [request]);
+  const stale = !!inspection && renderedBasis !== basis;
   const selected = settings.prompt_tags ?? [];
   const groups = ["Inhalt", "Stil", "Regeln", "Anweisungen"];
   const missing = selected.filter((s) => !tags.some((t) => same(t, s)));
@@ -17243,8 +18040,11 @@ function StagePromptSettings({ port, contextId, forElementId, target, settings,
     /* @__PURE__ */ jsx27("p", { className: "szenen-3d__referenz", "aria-live": "polite", children: reference }),
     /* @__PURE__ */ jsxs25("div", { className: "szenen-3d__gemini", "aria-label": "Gemini-Eingabe vor der Erzeugung", children: [
       /* @__PURE__ */ jsx27("h5", { children: "Das erh\xE4lt Gemini" }),
+      /* @__PURE__ */ jsx27("button", { type: "button", disabled: rendering || !input || !previewRenderer, onClick: () => setRequest((n) => n + 1), children: inspection ? "Preview aktualisieren" : "Preview erzeugen" }),
+      rendering && /* @__PURE__ */ jsx27("p", { role: "status", children: "Preview wird gerendert \u2026" }),
       inspectionError && /* @__PURE__ */ jsx27("p", { role: "alert", children: inspectionError }),
-      !inspection && !inspectionError && /* @__PURE__ */ jsx27("p", { children: "Vorschau wird vorbereitet \u2026" }),
+      !inspection && !inspectionError && !rendering && /* @__PURE__ */ jsx27("p", { className: "szenen-3d__hinweis", children: "Noch kein Preview. Das Rendern dauert auf dem Handy einige Sekunden; beim Ableiten des Prompts wird es ohnehin neu erzeugt." }),
+      stale && !rendering && /* @__PURE__ */ jsx27("p", { role: "status", className: "szenen-3d__hinweis", children: "Veraltet: B\xFChne oder Einstellungen haben sich seit diesem Preview ge\xE4ndert." }),
       inspection && /* @__PURE__ */ jsxs25(Fragment11, { children: [
         previewImage && /* @__PURE__ */ jsx27("img", { src: previewImage, alt: "Referenzbild f\xFCr Gemini" }),
         /* @__PURE__ */ jsx27("p", { children: "Gemini erh\xE4lt dieses Preview und die folgende Objektzuordnung. Bildverweise sind derzeit Asset-Kennungen; Objektbilder werden noch nicht mitgesendet." }),
@@ -17285,7 +18085,9 @@ var value = (r) => {
   return r.value;
 };
 var errorText = (e) => e instanceof Error ? e.message : String(e);
-var VIEWS = [["top", "Draufsicht"], ["side", "Seitenansicht"], ["camera", "Kamera"]];
+var VIEWS = [["top", "Draufsicht"], ["side", "Seitenansicht"], ["camera", "Kamera"], ["free", "Freie Ansicht"]];
+var ANCHORS_BASIC = [["center", "Mitte"], ["base", "Boden"]];
+var ANCHORS_HUMAN = [...ANCHORS_BASIC, ["head", "Kopf"], ["eyes", "Augen"], ["face", "Gesicht"], ["hands", "H\xE4nde"], ["left_shoulder", "Linke Schulter"], ["right_shoulder", "Rechte Schulter"]];
 var StageBoundary = class extends React21.Component {
   constructor() {
     super(...arguments);
@@ -17333,17 +18135,122 @@ function MeterField({ label, axis, value: current, min, step, disabled, onCommit
     )
   ] });
 }
+function MorphField({ label, value: stored, onCommit }) {
+  const [pending, setPending] = useState23(stored), last = useRef12(stored);
+  useEffect17(() => {
+    setPending(stored);
+    last.current = stored;
+  }, [stored]);
+  const commit = (value2) => {
+    if (value2 !== last.current) {
+      last.current = value2;
+      onCommit(value2);
+    }
+  };
+  return /* @__PURE__ */ jsxs26("label", { className: "szenen-3d__morph", children: [
+    label,
+    /* @__PURE__ */ jsx28(
+      "input",
+      {
+        "aria-label": label,
+        type: "range",
+        min: "0",
+        max: "1",
+        step: ".01",
+        value: pending,
+        onChange: (e) => setPending(Number(e.currentTarget.value)),
+        onPointerUp: (e) => commit(Number(e.currentTarget.value)),
+        onPointerCancel: () => setPending(stored),
+        onKeyUp: (e) => commit(Number(e.currentTarget.value)),
+        onBlur: (e) => commit(Number(e.currentTarget.value))
+      }
+    )
+  ] });
+}
+function ColorField({ hex, explicit, disabled, onCommit, onReset }) {
+  const [pending, setPending] = useState23(hex);
+  const [text2, setText] = useState23(hex);
+  useEffect17(() => {
+    setPending(hex);
+    setText(hex);
+  }, [hex]);
+  const changed = pending !== hex;
+  const discard = () => {
+    setPending(hex);
+    setText(hex);
+  };
+  const commit = () => {
+    if (changed) onCommit(pending);
+  };
+  return /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__farbe", children: [
+    /* @__PURE__ */ jsx28(
+      "input",
+      {
+        type: "color",
+        value: pending,
+        disabled,
+        "aria-label": "Markerfarbe w\xE4hlen",
+        onChange: (e) => {
+          const next = normalizePreviewColor(e.currentTarget.value);
+          if (next) {
+            setPending(next);
+            setText(next);
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx28(
+      "input",
+      {
+        type: "text",
+        value: text2,
+        disabled,
+        inputMode: "text",
+        autoComplete: "off",
+        spellCheck: false,
+        maxLength: 7,
+        "aria-label": "Markerfarbe als Hexwert",
+        onChange: (e) => {
+          const raw = e.currentTarget.value;
+          setText(raw);
+          const next = normalizePreviewColor(raw.startsWith("#") ? raw : `#${raw}`);
+          if (next) setPending(next);
+        },
+        onKeyDown: (e) => {
+          if (e.key === "Enter") {
+            e.preventDefault();
+            commit();
+          } else if (e.key === "Escape") discard();
+        }
+      }
+    ),
+    changed ? /* @__PURE__ */ jsxs26(Fragment12, { children: [
+      /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__farbe-uebernehmen", disabled, onClick: commit, children: "Farbe \xFCbernehmen" }),
+      /* @__PURE__ */ jsx28("button", { type: "button", disabled, onClick: discard, children: "Verwerfen" })
+    ] }) : explicit ? /* @__PURE__ */ jsx28("button", { type: "button", disabled, onClick: onReset, children: "Standardfarbe" }) : /* @__PURE__ */ jsx28("span", { className: "szenen-3d__farbe-auto", children: "automatisch" })
+  ] });
+}
 function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, embedded = false }) {
   const [engine, setEngine] = useState23(null);
   const [choices, setChoices] = useState23([]);
   const [choice, setChoice] = useState23("");
   const [working, setWorking] = useState23(null);
   const [shown, setShown] = useState23(null);
+  const shownRef = useRef12(null);
   const previewRef = useRef12(null);
   const [input, setInput] = useState23(null);
+  const resolvedRef = useRef12(null), exportSources = useRef12(null);
   const [view, setView] = useState23("top");
   const [selected, setSelected] = useState23(null);
+  const [objectTarget, setObjectTarget] = useState23("");
+  const [sichtbar, setSichtbar] = useState23({ nodes: /* @__PURE__ */ new Set(), walls: /* @__PURE__ */ new Set(), floors: /* @__PURE__ */ new Set(), ground: true, camera: true });
+  const [blatt, setBlatt] = useState23(false);
+  const [vollbild, setVollbild] = useState23(false);
+  const [kameraBlatt, setKameraBlatt] = useState23(false);
+  const buehne = useRef12(null);
+  const [entfernen, setEntfernen] = useState23(null);
   const [message, setMessage] = useState23("B\xFChne wird geladen \u2026");
+  const [vorab, setVorab] = useState23([]);
   const [busy, setBusy] = useState23(false);
   const [pending, setPending] = useState23(0);
   const [targets, setTargets] = useState23([]);
@@ -17373,12 +18280,16 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
       chain: { scene: { element_id: w.scene.element.element_id, version_id: "", payload: w.scenePayload }, setup: { element_id: w.setup.element.element_id, version_id: "", payload: w.setupPayload } }
     });
     if (result.kind !== "resolved") throw new Error(result.failure.message);
-    setInput(withCameraPreviewMetadata(result.input, w.scenePayload));
+    const resolved = withCameraPreviewMetadata(result.input, w.scenePayload);
+    resolvedRef.current = resolved;
+    exportSources.current = Object.fromEntries(["scene", "setup", "shot"].map((key) => [key, { element_id: w[key].element.element_id, version_id: null, draft: { draft_id: w[key].draft.draft_id, revision: w[key].draft.revision } }]));
+    setInput(resolved);
+    return resolved;
   }
   async function reload(w) {
     const [scene, setup, shot] = await Promise.all([read(w.scene.element.element_id), read(w.setup.element.element_id), read(w.shot.element.element_id)]);
     if (!scene.draft || !setup.draft || !shot.draft) throw new Error("Ein B\xFChnenentwurf fehlt. Bitte den Aufbau erneut \xF6ffnen.");
-    await resolve({ scene, setup, shot, scenePayload: scene.draft.payload, setupPayload: setup.draft.payload, shotPayload: shot.draft.payload });
+    return resolve({ scene, setup, shot, scenePayload: scene.draft.payload, setupPayload: setup.draft.payload, shotPayload: shot.draft.payload });
   }
   async function act(operation) {
     if (busy) return;
@@ -17398,8 +18309,8 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
     setPending((n) => n + 1);
     setMessage("");
     queue.current = queue.current.then(async () => {
-      if (generation !== epoch.current) return;
       try {
+        if (generation !== epoch.current) return;
         if (!workingRef.current && previewRef.current) await open(previewRef.current);
         const w = workingRef.current;
         if (!w) return;
@@ -17424,6 +18335,10 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
     });
   }
   async function write(w, which, payload) {
+    const pinned = pinPreviewColors(which === "scene" ? payload : w.scenePayload, w.setupPayload, w.shotPayload);
+    if (which === "scene") payload = pinned;
+    else if (JSON.stringify(pinned) !== JSON.stringify(w.scenePayload))
+      value(await port.elements.writeDraft({ elementId: w.scene.element.element_id, payload: pinned, expectedRevision: w.scene.draft.revision }));
     const s = w[which];
     value(await port.elements.writeDraft({ elementId: s.element.element_id, payload, expectedRevision: s.draft.revision }));
     await reload(w);
@@ -17452,7 +18367,11 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
     let live = true;
     void (async () => {
       try {
-        const loaded = await loadStageEngine();
+        const engineLaden = loadStageEngine();
+        const szeneFrueh = await read(sceneElementId);
+        const szenePayloadFrueh = szeneFrueh.draft?.payload ?? szeneFrueh.versions[szeneFrueh.versions.length - 1]?.payload;
+        if (live && Array.isArray(szenePayloadFrueh?.nodes)) setVorab(szenePayloadFrueh.nodes);
+        const loaded = await engineLaden;
         const chain = value(await port.context.chainFor(contextId));
         const list = value(await port.elements.listElements({ type: "scene_setup" })).filter((e) => chain.includes(e.context_id));
         const snapshots = await Promise.all(list.map((e) => read(e.element_id)));
@@ -17496,6 +18415,32 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
       live = false;
     };
   }, [port, sceneElementId, contextId]);
+  useEffect17(() => {
+    if (selected && blatt) setKameraBlatt(false);
+  }, [selected, blatt]);
+  useEffect17(() => {
+    if (selected && (sichtbar.nodes.has(selected) || sichtbar.walls.has(selected) && sichtbar.floors.has(selected))) setSelected(null);
+  }, [selected, sichtbar]);
+  useEffect17(() => {
+    if (!vollbild) return;
+    const el = buehne.current, root = document.documentElement, overflow = root.style.overflow;
+    root.style.overflow = "hidden";
+    let api = false;
+    const left = () => {
+      if (api && !document.fullscreenElement) setVollbild(false);
+    };
+    document.addEventListener("fullscreenchange", left);
+    if (el?.requestFullscreen && !document.fullscreenElement) el.requestFullscreen({ navigationUI: "hide" }).then(() => {
+      api = true;
+    }, () => {
+    });
+    return () => {
+      document.removeEventListener("fullscreenchange", left);
+      root.style.overflow = overflow;
+      if (document.fullscreenElement === el) void document.exitFullscreen().catch(() => {
+      });
+    };
+  }, [vollbild]);
   async function preview(c) {
     const scene = await read(sceneElementId);
     const scenePayload = scene.draft?.payload ?? scene.versions.find((v) => v.version_id === c.payload.scene_ref?.version_id)?.payload;
@@ -17513,53 +18458,49 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
       chain: { scene: { element_id: sceneElementId, version_id: "", payload: scenePayload }, setup: { element_id: c.setup.element.element_id, version_id: c.versionId ?? "", payload: c.payload } }
     });
     if (result.kind !== "resolved") throw new Error(result.failure.message);
+    resolvedRef.current = withCameraPreviewMetadata(result.input, scenePayload);
+    exportSources.current = {
+      scene: { element_id: sceneElementId, version_id: scene.draft ? null : c.payload.scene_ref.version_id, draft: scene.draft ? { draft_id: scene.draft.draft_id, revision: scene.draft.revision } : null },
+      setup: { element_id: c.setup.element.element_id, version_id: c.versionId, draft: c.versionId ? null : { draft_id: c.setup.draft.draft_id, revision: c.setup.draft.revision } },
+      shot: { element_id: null, version_id: null, synthetic: true }
+    };
+    shownRef.current = { scenePayload, setupPayload: c.payload, shotPayload };
     previewRef.current = c;
     setChoice(c.key);
-    setShown({ scenePayload, setupPayload: c.payload, shotPayload });
+    setShown(shownRef.current);
     setInput(withCameraPreviewMetadata(result.input, scenePayload));
   }
   async function open(c) {
-    const setup = await read(c.setup.element.element_id);
-    if (setup.draftFork) throw new Error("Der Aufbau hat konkurrierende Entw\xFCrfe. Bitte zuerst aufl\xF6sen.");
-    if (c.versionId && setup.draft) throw new Error("F\xFCr diesen Aufbau existiert bereits ein Entwurf. Bitte diesen explizit ausw\xE4hlen.");
-    const setupPayload = c.versionId ? setup.versions.find((v) => v.version_id === c.versionId)?.payload : setup.draft?.payload;
-    if (!setupPayload) throw new Error("Der gew\xE4hlte Stand ist nicht mehr vorhanden.");
-    const scene = await read(sceneElementId);
-    if (scene.draftFork) throw new Error("Die Szene hat konkurrierende Entw\xFCrfe.");
-    const existingChain = setup.draft?.chain;
-    if (existingChain) {
-      const link = existingChain.links.find((l) => l.field === "scene_ref");
-      if (link?.target_draft_id !== scene.draft?.draft_id || scene.draft?.chain?.chain_id !== existingChain.chain_id) throw new Error("Die gespeicherte Draft-Kette passt nicht zur Szene.");
-    } else if (scene.draft?.chain) throw new Error("Die Szene geh\xF6rt bereits zu einer anderen Draft-Kette.");
-    const ref = setupPayload.scene_ref;
-    const scenePayload = scene.draft?.payload ?? scene.versions.find((v) => v.version_id === ref?.version_id)?.payload;
-    if (!scenePayload) throw new Error("Die referenzierte Szene ist nicht vorhanden.");
-    const chainId = existingChain?.chain_id ?? crypto.randomUUID();
-    const chain = existingChain ?? { chain_id: chainId, origin: "stage", links: [] };
-    let sceneDraft = scene.draft;
-    if (!existingChain) sceneDraft = value(await port.elements.writeDraft({ elementId: sceneElementId, payload: scenePayload, expectedRevision: scene.draft?.revision ?? 0, baseVersionId: scene.draft?.base_version_id ?? ref?.version_id ?? null, chain: { ...chain, links: [] } }));
-    let setupDraft = setup.draft;
-    if (!existingChain) setupDraft = value(await port.elements.writeDraft({ elementId: setup.element.element_id, payload: setupPayload, expectedRevision: setup.draft?.revision ?? 0, baseVersionId: c.versionId, chain: { ...chain, links: [{ field: "scene_ref", target_element_id: sceneElementId, target_draft_id: sceneDraft.draft_id }] } }));
-    const shots = value(await port.elements.listElements({ type: "shot" }));
-    let shot = null;
-    for (const entry of shots) {
-      const s = await read(entry.element_id);
-      if (s.draft?.chain?.chain_id === chainId) {
-        shot = s;
-        break;
-      }
-    }
-    if (!shot) {
-      const created = value(await port.elements.createElement({ type: "shot", contextId, title: "3D-Kameraansicht" }));
-      const cameraId = setupPayload.camera_rig?.cameras?.[0]?.camera_id;
-      if (!cameraId) throw new Error("Der Aufbau hat keine Kamera.");
-      const shotPayload = { camera_id: cameraId, ...target ? { prompt_render_settings: { target_model_id: target } } : {} };
-      value(await port.elements.writeDraft({ elementId: created.element_id, payload: shotPayload, expectedRevision: 0, chain: { ...chain, links: [{ field: "scene_setup_ref", target_element_id: setup.element.element_id, target_draft_id: setupDraft.draft_id }] } }));
-      shot = await read(created.element_id);
-    }
-    await reload({ scene, setup, shot, scenePayload, setupPayload, shotPayload: shot.draft.payload });
+    const state = await openStageDraftChain(port.elements, { sceneElementId, setupElementId: c.setup.element.element_id, setupVersionId: c.versionId, contextId, targetModelId: target || null });
+    await reload({ scene: state.scene, setup: state.setup, shot: state.shot, scenePayload: state.scene.draft.payload, setupPayload: state.setup.draft.payload, shotPayload: state.shot.draft.payload });
     previewRef.current = null;
   }
+  async function apply(w, operations) {
+    const result = applyStageOperations({ scene: w.scenePayload, setup: w.setupPayload, shot: w.shotPayload }, operations);
+    if (result.kind !== "ok") throw new Error(result.message);
+    for (const which of result.write_order) {
+      const s = w[which];
+      value(await port.elements.writeDraft({ elementId: s.element.element_id, payload: result.payloads[which], expectedRevision: s.draft.revision }));
+    }
+    await reload(w);
+    return result;
+  }
+  const rotate = (id, rotation) => enqueue(async (w) => {
+    await apply(w, [{ op: "place_node", node_id: id, rotation_euler_deg: rotation }]);
+  });
+  const face = (id, targetId) => enqueue(async (w) => {
+    const saved = await resolve(w), source = saved.scene.nodes.find((n) => n.node_id === id)?.placement;
+    const targetPosition = targetId ? saved.scene.nodes.find((n) => n.node_id === targetId)?.placement?.position : saved.camera?.placement?.position;
+    if (!source || !targetPosition) throw new Error("Quelle oder Ziel ist nicht platziert.");
+    const rotation = [...source.rotation_euler_deg ?? [0, 0, 0]];
+    rotation[2] = facingRotationZ(source.position, targetPosition);
+    await apply(w, [{ op: "place_node", node_id: id, rotation_euler_deg: rotation }]);
+  });
+  const support = (id, targetId) => enqueue(async (w) => {
+    if (!engine) throw new Error("B\xFChne ist noch nicht geladen.");
+    const saved = await resolve(w), position = await engine.stageSupportPosition(saved, id, targetId);
+    await apply(w, [{ op: "place_node", node_id: id, position }]);
+  });
   const display = input && withStagePositions(input, overlay.current.nodes, overlay.current.camera && overlay.current.camera.id === input.camera?.camera_id ? overlay.current.camera.position : null);
   const base = working ?? shown;
   const nodes = base?.scenePayload.nodes ?? [];
@@ -17571,6 +18512,200 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
   const cameraPosition = (display?.camera?.camera_id === camera?.camera_id ? display?.camera?.placement?.position : null) ?? camera?.placement?.position;
   const lookAt = camera?.orientation?.mode === "look_at" ? camera.orientation.target?.node_ref : null;
   const title = choices.find((c) => c.key === choice)?.title;
+  const visibleNodes = display?.scene.nodes.filter((n) => !n.hidden) ?? [];
+  const colors = stageColors(visibleNodes);
+  const conflicts = previewColorConflicts(visibleNodes);
+  const umschalten = (key, id) => setSichtbar((v) => {
+    const next = new Set(v[key]);
+    if (!next.delete(id)) next.add(id);
+    return { ...v, [key]: next };
+  });
+  const ausgeblendet = (sichtbar.ground ? 0 : 1) + (sichtbar.camera ? 0 : 1) + nodes.reduce((sum, n) => sum + [sichtbar.nodes, sichtbar.walls, sichtbar.floors].filter((set) => set.has(n.node_id)).length, 0);
+  const anchorsFor = (n) => n?.proxy_3d?.primitive === "humanoid_proxy" ? ANCHORS_HUMAN : ANCHORS_BASIC;
+  const lookNode = lookAt ? nodes.find((n) => n.node_id === lookAt) : void 0;
+  const setLook = (nodeRef, anchor) => edit("setup", (p) => withCamera(p, camera.camera_id, (c) => ({ ...c, orientation: {
+    ...c.orientation?.mode === "look_at" ? c.orientation : {},
+    mode: "look_at",
+    target: { node_ref: nodeRef, anchor }
+  } })));
+  const cameraFields = base ? /* @__PURE__ */ jsxs26(Fragment12, { children: [
+    /* @__PURE__ */ jsxs26("label", { children: [
+      "Kamera",
+      /* @__PURE__ */ jsx28("select", { disabled: busy, value: base.shotPayload.camera_id ?? "", onChange: (e) => {
+        const id = e.target.value;
+        edit("shot", (p) => ({ ...p, camera_id: id }));
+      }, children: base.setupPayload.camera_rig.cameras.map((c) => /* @__PURE__ */ jsx28("option", { value: c.camera_id, children: c.name ?? c.camera_id }, c.camera_id)) })
+    ] }),
+    camera && /* @__PURE__ */ jsxs26("label", { children: [
+      "Kameraformat",
+      /* @__PURE__ */ jsxs26("select", { disabled: busy, value: camera.aspect_ratio ?? "", onChange: (e) => {
+        const ratio = e.target.value;
+        edit("setup", (p) => withCamera(p, camera.camera_id, (c) => ({ ...c, aspect_ratio: ratio })));
+      }, children: [
+        /* @__PURE__ */ jsx28("option", { value: "", children: "Explizit w\xE4hlen \u2026" }),
+        CAMERA_ASPECT_RATIOS.map((r) => /* @__PURE__ */ jsx28("option", { children: r }, r)),
+        camera.aspect_ratio && !CAMERA_ASPECT_RATIOS.includes(camera.aspect_ratio) && /* @__PURE__ */ jsx28("option", { children: camera.aspect_ratio })
+      ] })
+    ] }),
+    camera?.placement?.mode === "absolute" && /* @__PURE__ */ jsxs26("fieldset", { disabled: busy, className: "szenen-3d__werte", children: [
+      /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Position (m)" }),
+      ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Kameraposition", axis, step: ".1", value: cameraPosition?.[index], onCommit: (n) => edit("setup", (p) => withCamera(p, camera.camera_id, (c) => {
+        const position = [...c.placement.position];
+        position[index] = n;
+        return { ...c, placement: { mode: "absolute", position } };
+      })) }, axis)),
+      camera.orientation?.mode === "explicit" && /* @__PURE__ */ jsxs26(Fragment12, { children: [
+        /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Drehung (\xB0)" }),
+        ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Kameraausrichtung", axis, step: "1", value: camera.orientation.rotation_euler_deg[index], onCommit: (n) => edit("setup", (p) => withCamera(p, camera.camera_id, (c) => {
+          const rotation_euler_deg = [...c.orientation.rotation_euler_deg];
+          rotation_euler_deg[index] = n;
+          return { ...c, orientation: { mode: "explicit", rotation_euler_deg } };
+        })) }, axis))
+      ] })
+    ] }),
+    camera && /* @__PURE__ */ jsxs26("label", { children: [
+      "Blickziel",
+      /* @__PURE__ */ jsxs26("select", { "aria-label": "Blickziel", disabled: busy, value: lookAt ?? "", onChange: (e) => {
+        const id = e.target.value;
+        if (!id) return;
+        const keep = camera.orientation?.target?.anchor;
+        setLook(id, anchorsFor(nodes.find((n) => n.node_id === id)).some(([k]) => k === keep) ? keep : "center");
+      }, children: [
+        !lookAt && /* @__PURE__ */ jsx28("option", { value: "", children: camera.orientation?.mode === "explicit" ? "Feste Drehung (unten)" : "Ausw\xE4hlen \u2026" }),
+        visibleNodes.filter((n) => n.placement).map((n) => /* @__PURE__ */ jsx28("option", { value: n.node_id, children: labels[n.node_id] }, n.node_id))
+      ] })
+    ] }),
+    camera && lookAt && /* @__PURE__ */ jsxs26("label", { children: [
+      "Blickpunkt",
+      /* @__PURE__ */ jsx28("select", { "aria-label": "Blickpunkt", disabled: busy, value: camera.orientation.target?.anchor ?? "center", onChange: (e) => setLook(lookAt, e.target.value), children: anchorsFor(lookNode).map(([key, title2]) => /* @__PURE__ */ jsx28("option", { value: key, children: title2 }, key)) })
+    ] }),
+    lookAt && /* @__PURE__ */ jsxs26("p", { className: "szenen-3d__hinweis", children: [
+      "Blickt auf ",
+      labels[lookAt] ?? lookAt,
+      ". Kamera in Drauf- oder Seitenansicht ziehen, um sie zu versetzen; antippen \xF6ffnet diese Einstellungen."
+    ] })
+  ] }) : null;
+  const objectSheet = node ? /* @__PURE__ */ jsxs26("div", { className: `szenen-3d__objektblatt${blatt ? "" : " is-zu"}`, role: "region", "aria-label": "Gew\xE4hltes Objekt", children: [
+    /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__blatt-schliessen", onClick: () => setSelected(null), children: "Objektblatt schlie\xDFen" }),
+    /* @__PURE__ */ jsxs26("fieldset", { disabled: busy, className: "szenen-3d__werte", children: [
+      /* @__PURE__ */ jsxs26("legend", { children: [
+        labels[node.node_id],
+        " ",
+        /* @__PURE__ */ jsx28("span", { children: stageTypeLabel(node.type) })
+      ] }),
+      colors[node.node_id] && /* @__PURE__ */ jsxs26(Fragment12, { children: [
+        /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Markerfarbe" }),
+        /* @__PURE__ */ jsx28(
+          ColorField,
+          {
+            hex: colors[node.node_id].hex,
+            explicit: colors[node.node_id].explicit,
+            disabled: busy,
+            onCommit: (hex) => enqueue(async (w) => {
+              await apply(w, [{ op: "update_node", node_id: node.node_id, preview_color: hex }]);
+            }),
+            onReset: () => enqueue(async (w) => {
+              await apply(w, [{ op: "update_node", node_id: node.node_id, preview_color: null }]);
+            })
+          }
+        ),
+        previewColorLegibility(colors[node.node_id].hex) && /* @__PURE__ */ jsx28("p", { role: "status", className: "szenen-3d__farbe-hinweis", children: previewColorLegibility(colors[node.node_id].hex) === "too_dark" ? "Sehr dunkle Markerfarbe: Das Bildmodell kann den Block als Schatten oder dunkle Kleidung lesen. Eine kr\xE4ftige, mittelhelle Farbe ist eindeutiger." : "Sehr helle Markerfarbe: Der Block hebt sich kaum vom hellen Preview-Hintergrund ab." }),
+        conflicts.filter((c) => c.node_ids.includes(node.node_id)).map((c) => {
+          const other = c.node_ids[0] === node.node_id ? c.node_ids[1] : c.node_ids[0];
+          return /* @__PURE__ */ jsxs26("p", { role: "status", className: "szenen-3d__farbe-hinweis", children: [
+            c.identical ? "Gleiche Farbe wie" : "Schwer unterscheidbar von",
+            " ",
+            labels[other] ?? other,
+            " (",
+            colors[other]?.hex,
+            ")."
+          ] }, other);
+        })
+      ] }),
+      /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Gr\xF6\xDFe (m)" }),
+      ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Gr\xF6\xDFe", axis, step: ".05", min: 0.01, value: node.proxy_3d?.dimensions?.[index], onCommit: (n) => edit("scene", (p) => ({ ...p, nodes: p.nodes.map((x) => {
+        if (x.node_id !== node.node_id) return x;
+        const d = [...x.proxy_3d?.dimensions ?? [1, 1, 1]];
+        d[index] = n;
+        return { ...x, proxy_3d: { ...x.proxy_3d, primitive: x.proxy_3d?.primitive ?? "box", dimensions: d } };
+      }) })) }, axis)),
+      placement ? /* @__PURE__ */ jsxs26(Fragment12, { children: [
+        /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Position (m)" }),
+        ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Position", axis, step: ".05", value: nodePosition?.[index], onCommit: (n) => edit("setup", (p) => ({ ...p, placements: p.placements.map((x) => {
+          if (x.node_id !== node.node_id) return x;
+          const q = [...x.position];
+          q[index] = n;
+          return { ...x, position: q };
+        }) })) }, axis))
+      ] }) : /* @__PURE__ */ jsx28("button", { type: "button", onClick: () => edit("setup", (p) => ({ ...p, coordinate_system: "blender_z_up_meters", placements: [...p.placements ?? [], { node_id: node.node_id, position: [0, 0, 0] }] })), children: "Am Ursprung platzieren" }),
+      placement && /* @__PURE__ */ jsxs26(Fragment12, { children: [
+        /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Drehung (\xB0)" }),
+        /* @__PURE__ */ jsx28(
+          MeterField,
+          {
+            label: "Objektdrehung",
+            axis: "Z",
+            step: "15",
+            value: placement.rotation_euler_deg?.[2] ?? 0,
+            onCommit: (z) => enqueue(async (w) => {
+              const q = w.setupPayload.placements.find((p) => p.node_id === node.node_id);
+              if (!q) throw new Error("Objekt ist nicht mehr platziert.");
+              await apply(w, [{ op: "place_node", node_id: node.node_id, rotation_euler_deg: [q.rotation_euler_deg?.[0] ?? 0, q.rotation_euler_deg?.[1] ?? 0, z] }]);
+            })
+          }
+        ),
+        /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__objekt-aktionen", children: [
+          /* @__PURE__ */ jsx28("button", { type: "button", onClick: () => face(node.node_id), children: "Zur Kamera drehen" }),
+          /* @__PURE__ */ jsx28("button", { type: "button", onClick: () => support(node.node_id), children: "Auf Boden" })
+        ] }),
+        /* @__PURE__ */ jsxs26("label", { className: "szenen-3d__zeilenkopf", children: [
+          "Zielobjekt",
+          /* @__PURE__ */ jsxs26("select", { "aria-label": "Zielobjekt", value: objectTarget, onChange: (e) => setObjectTarget(e.target.value), children: [
+            /* @__PURE__ */ jsx28("option", { value: "", children: "Ausw\xE4hlen \u2026" }),
+            visibleNodes.filter((n) => n.node_id !== node.node_id && n.placement).map((n) => /* @__PURE__ */ jsx28("option", { value: n.node_id, children: labels[n.node_id] }, n.node_id))
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__objekt-aktionen", children: [
+          /* @__PURE__ */ jsx28("button", { type: "button", disabled: !objectTarget || objectTarget === node.node_id, onClick: () => face(node.node_id, objectTarget), children: "Zu Objekt drehen" }),
+          /* @__PURE__ */ jsx28("button", { type: "button", disabled: !objectTarget || objectTarget === node.node_id, onClick: () => support(node.node_id, objectTarget), children: "Auf Objekt setzen" })
+        ] })
+      ] }),
+      node.proxy_3d?.primitive === "humanoid_proxy" && /* @__PURE__ */ jsxs26(Fragment12, { children: [
+        /* @__PURE__ */ jsx28("div", { className: "szenen-3d__pose", role: "group", "aria-label": "Pose", children: [["standing", "Stehen"], ["sitting", "Sitzen"], ["walking", "Gehen"], ["arms_crossed", "Arme verschr\xE4nkt"], ["hand_on_chin", "Hand am Kinn"]].map(([pose, label]) => /* @__PURE__ */ jsx28("button", { type: "button", "aria-pressed": (node.proxy_3d.pose_ref ?? "standing") === pose, onClick: () => enqueue(async (w) => {
+          await apply(w, [{ op: "update_node", node_id: node.node_id, pose_ref: pose }]);
+        }), children: label }, pose)) }),
+        ["build", "gender"].map((key) => /* @__PURE__ */ jsx28(
+          MorphField,
+          {
+            label: key === "build" ? "Statur" : "Geschlecht",
+            value: node.proxy_3d.morph?.[key] ?? 0.5,
+            onCommit: (v) => enqueue(async (w) => {
+              const current = w.scenePayload.nodes.find((n) => n.node_id === node.node_id);
+              if (!current) throw new Error("Person fehlt.");
+              await apply(w, [{ op: "update_node", node_id: node.node_id, morph: { ...current.proxy_3d.morph, [key]: v } }]);
+            })
+          },
+          key
+        ))
+      ] }),
+      entfernen === node.node_id ? /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__entfernen", role: "group", "aria-label": "Entfernen best\xE4tigen", children: [
+        /* @__PURE__ */ jsxs26("span", { children: [
+          "\u201E",
+          labels[node.node_id],
+          "\u201C aus der Szene entfernen?"
+        ] }),
+        /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__gefahr", onClick: () => {
+          const id = node.node_id;
+          setEntfernen(null);
+          enqueue(async (w) => {
+            await apply(w, [{ op: "remove_node", node_id: id }]);
+            setSelected(null);
+          });
+        }, children: "Entfernen" }),
+        /* @__PURE__ */ jsx28("button", { type: "button", onClick: () => setEntfernen(null), children: "Abbrechen" })
+      ] }) : /* @__PURE__ */ jsx28("button", { type: "button", onClick: () => setEntfernen(node.node_id), children: "Objekt entfernen" })
+    ] })
+  ] }) : null;
   return /* @__PURE__ */ jsxs26("section", { className: `szenen-3d${embedded ? " szenen-3d--eingebettet" : ""}`, "aria-label": "3D-B\xFChne", "data-testid": "szenen-3d", children: [
     /* @__PURE__ */ jsxs26("header", { className: "szenen-3d__kopf", children: [
       !embedded && /* @__PURE__ */ jsx28("h4", { children: "3D-B\xFChne" }),
@@ -17589,120 +18724,171 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
         title.replace(/ · (Entwurf|Version \S+)$/, "")
       ] }),
       base && /* @__PURE__ */ jsx28("span", { className: "szenen-3d__sync", "data-state": pending ? "speichert" : working ? "gespeichert" : "ansicht", "aria-live": "polite", children: pending ? "Speichert \u2026" : working ? "Gespeichert" : "Erste \xC4nderung legt Entwurf an" }),
+      base && engine && /* @__PURE__ */ jsx28("button", { type: "button", disabled: busy, onClick: () => void act(async () => {
+        await queue.current;
+        let payloads;
+        if (workingRef.current) {
+          await reload(workingRef.current);
+          const w = workingRef.current;
+          payloads = w;
+        } else {
+          const c = previewRef.current;
+          if (!c) throw new Error("Bitte einen Aufbau w\xE4hlen.");
+          const setup = await read(c.setup.element.element_id), payload = c.versionId ? setup.versions.find((v) => v.version_id === c.versionId)?.payload : setup.draft?.payload;
+          if (!payload) throw new Error("Der gew\xE4hlte Aufbau fehlt.");
+          await preview({ ...c, setup, payload });
+          payloads = shownRef.current;
+        }
+        if (!resolvedRef.current || !exportSources.current) throw new Error("Der gespeicherte Exportstand fehlt.");
+        const result = await engine.exportStageScene(resolvedRef.current, { payloads: { scene: payloads.scenePayload, setup: payloads.setupPayload, shot: payloads.shotPayload }, sources: exportSources.current }, workingRef.current?.shot.element.title ?? `scene_${resolvedRef.current.camera.camera_id}`);
+        const bytes = new Uint8Array(result.data), url = URL.createObjectURL(new Blob([bytes], { type: "application/zip" }));
+        const link = document.createElement("a");
+        link.href = url;
+        link.download = result.filename;
+        document.body.appendChild(link);
+        link.click();
+        link.remove();
+        setTimeout(() => URL.revokeObjectURL(url), 1e3);
+        setMessage("Szene f\xFCr Blender exportiert.");
+      }), children: "Szene exportieren" }),
       onClose && /* @__PURE__ */ jsx28("button", { type: "button", disabled: busy, onClick: onClose, children: "Schlie\xDFen" })
     ] }),
     message && /* @__PURE__ */ jsx28("p", { role: "status", className: "szenen-3d__meldung", children: message }),
-    !base ? null : /* @__PURE__ */ jsxs26(Fragment12, { children: [
+    !base ? /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__geruest", "aria-hidden": "true", children: [
       /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__leiste", children: [
-        /* @__PURE__ */ jsx28("div", { className: "szenen-studio__umschalter", role: "group", "aria-label": "3D-Ansicht", children: VIEWS.map(([v, title2]) => /* @__PURE__ */ jsx28("button", { type: "button", "aria-pressed": view === v, onClick: () => setView(v), children: title2 }, v)) }),
-        /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__katalog", role: "group", "aria-label": "Objektkatalog", children: [
+        /* @__PURE__ */ jsx28("div", { className: "szenen-studio__umschalter", children: VIEWS.map(([v, title2]) => /* @__PURE__ */ jsx28("button", { type: "button", disabled: true, tabIndex: -1, children: title2 }, v)) }),
+        /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__katalog", children: [
           /* @__PURE__ */ jsx28("span", { children: "Hinzuf\xFCgen" }),
-          STAGE_CATALOGUE.map((entry) => /* @__PURE__ */ jsxs26("button", { type: "button", disabled: busy, onClick: () => enqueue(async (w) => {
-            const id = `node_${crypto.randomUUID().replace(/-/g, "")}`;
-            await write(w, "scene", { ...w.scenePayload, unit_system: "blender_z_up_meters", nodes: [...w.scenePayload.nodes, { node_id: id, label: entry.label, type: entry.type, semantic: { description: entry.label }, proxy_3d: { primitive: "box", dimensions: [...entry.dimensions] } }] });
-            const setup = await read(w.setup.element.element_id);
-            const p = setup.draft.payload;
-            value(await port.elements.writeDraft({ elementId: setup.element.element_id, expectedRevision: setup.draft.revision, payload: { ...p, coordinate_system: "blender_z_up_meters", placements: [...p.placements ?? [], { node_id: id, position: [0, 0, entry.dimensions[2] / 2] }] } }));
-            await reload(workingRef.current);
-            setSelected(id);
-          }), children: [
-            /* @__PURE__ */ jsx28("i", { style: { background: stageColor(entry.type) }, "aria-hidden": "true" }),
+          STAGE_CATALOGUE.map((entry) => /* @__PURE__ */ jsxs26("button", { type: "button", disabled: true, tabIndex: -1, children: [
+            /* @__PURE__ */ jsx28("i", { style: { background: stageColor(entry.type) } }),
             "+ ",
             entry.label
           ] }, entry.label))
         ] })
       ] }),
-      engine && display && /* @__PURE__ */ jsx28(StageBoundary, { resetKey: input, children: /* @__PURE__ */ jsx28(
-        engine.StageEngine,
-        {
-          input: display,
-          view,
-          selected,
-          labels,
-          onSelect: setSelected,
-          onMove: (id, p) => move((o) => {
-            o.nodes.set(id, p);
-          }),
-          onMoveCamera: camera?.placement?.mode === "absolute" ? (p) => move((o) => {
-            o.camera = { id: camera.camera_id, position: p };
-          }) : void 0
-        }
-      ) }),
+      /* @__PURE__ */ jsx28("div", { className: "szenen-3d__viewport szenen-3d__viewport--laden" }),
+      /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__inspektor", children: [
+        /* @__PURE__ */ jsxs26("section", { className: "szenen-3d__karte", children: [
+          /* @__PURE__ */ jsx28("h5", { children: "Elemente" }),
+          /* @__PURE__ */ jsx28("div", { className: "szenen-3d__elemente", children: vorab.map((n) => /* @__PURE__ */ jsxs26("button", { type: "button", disabled: true, tabIndex: -1, children: [
+            /* @__PURE__ */ jsx28("i", { style: { background: stageColors(vorab)[n.node_id]?.hex ?? stageColor(n.type) } }),
+            n.label ?? n.semantic?.description ?? n.node_id
+          ] }, n.node_id)) }),
+          /* @__PURE__ */ jsx28("p", { className: "szenen-3d__hinweis", children: "Element in der B\xFChne oder hier ausw\xE4hlen." })
+        ] }),
+        /* @__PURE__ */ jsxs26("section", { className: "szenen-3d__karte", children: [
+          /* @__PURE__ */ jsx28("h5", { children: "Aktive Kamera" }),
+          /* @__PURE__ */ jsx28("p", { className: "szenen-3d__hinweis", children: "Kamera wird geladen \u2026" })
+        ] })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs26(Fragment12, { children: [
+      /* @__PURE__ */ jsxs26("div", { ref: buehne, className: `szenen-3d__buehne${vollbild ? " is-vollbild" : ""}`, children: [
+        /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__leiste", children: [
+          /* @__PURE__ */ jsx28("div", { className: "szenen-studio__umschalter", role: "group", "aria-label": "3D-Ansicht", children: VIEWS.map(([v, title2]) => /* @__PURE__ */ jsx28("button", { type: "button", "aria-pressed": view === v, onClick: () => setView(v), children: title2 }, v)) }),
+          /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__katalog", role: "group", "aria-label": "Objektkatalog", children: [
+            /* @__PURE__ */ jsx28("span", { children: "Hinzuf\xFCgen" }),
+            STAGE_CATALOGUE.map((entry) => /* @__PURE__ */ jsxs26("button", { type: "button", disabled: busy, onClick: () => enqueue(async (w) => {
+              const result = await apply(w, [{ op: "add_node", type: entry.type, label: entry.label, description: entry.label, dimensions: [...entry.dimensions] }]);
+              setSelected(result.created_node_ids[0]);
+            }), children: [
+              /* @__PURE__ */ jsx28("i", { style: { background: stageColor(entry.type) }, "aria-hidden": "true" }),
+              "+ ",
+              entry.label
+            ] }, entry.label))
+          ] }),
+          /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__ansichtsoptionen", role: "group", "aria-label": "Anzeige", children: [
+            /* @__PURE__ */ jsxs26("details", { className: "szenen-3d__sichtbar", children: [
+              /* @__PURE__ */ jsxs26("summary", { children: [
+                "Sichtbarkeit",
+                ausgeblendet ? ` \xB7 ${ausgeblendet} aus` : ""
+              ] }),
+              /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__sichtbar-liste", role: "group", "aria-label": "Sichtbarkeit", children: [
+                /* @__PURE__ */ jsxs26("label", { children: [
+                  /* @__PURE__ */ jsx28("input", { type: "checkbox", checked: sichtbar.ground, onChange: () => setSichtbar((v) => ({ ...v, ground: !v.ground })) }),
+                  "Grundfl\xE4che"
+                ] }),
+                /* @__PURE__ */ jsxs26("label", { children: [
+                  /* @__PURE__ */ jsx28("input", { type: "checkbox", checked: sichtbar.camera, onChange: () => setSichtbar((v) => ({ ...v, camera: !v.camera })) }),
+                  "Kamerasymbol"
+                ] }),
+                nodes.map((n) => n.proxy_3d?.primitive === "room_shell" ? /* @__PURE__ */ jsxs26(React21.Fragment, { children: [
+                  /* @__PURE__ */ jsxs26("label", { children: [
+                    /* @__PURE__ */ jsx28("input", { type: "checkbox", checked: !sichtbar.floors.has(n.node_id), onChange: () => umschalten("floors", n.node_id) }),
+                    /* @__PURE__ */ jsx28("i", { style: { background: colors[n.node_id]?.hex ?? stageColor(n.type) }, "aria-hidden": "true" }),
+                    labels[n.node_id],
+                    " \xB7 Boden"
+                  ] }),
+                  /* @__PURE__ */ jsxs26("label", { children: [
+                    /* @__PURE__ */ jsx28("input", { type: "checkbox", checked: !sichtbar.walls.has(n.node_id), onChange: () => umschalten("walls", n.node_id) }),
+                    /* @__PURE__ */ jsx28("i", { style: { background: colors[n.node_id]?.hex ?? stageColor(n.type) }, "aria-hidden": "true" }),
+                    labels[n.node_id],
+                    " \xB7 W\xE4nde"
+                  ] })
+                ] }, n.node_id) : /* @__PURE__ */ jsxs26("label", { children: [
+                  /* @__PURE__ */ jsx28("input", { type: "checkbox", checked: !sichtbar.nodes.has(n.node_id), onChange: () => umschalten("nodes", n.node_id) }),
+                  /* @__PURE__ */ jsx28("i", { style: { background: colors[n.node_id]?.hex ?? stageColor(n.type) }, "aria-hidden": "true" }),
+                  labels[n.node_id]
+                ] }, n.node_id)),
+                /* @__PURE__ */ jsx28("button", { type: "button", disabled: !ausgeblendet, onClick: () => setSichtbar({ nodes: /* @__PURE__ */ new Set(), walls: /* @__PURE__ */ new Set(), floors: /* @__PURE__ */ new Set(), ground: true, camera: true }), children: "Alle einblenden" })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__blatt-schalter", "aria-pressed": blatt, onClick: () => setBlatt((b) => !b), children: "Objektblatt" }),
+            vollbild && /* @__PURE__ */ jsx28("button", { type: "button", "aria-pressed": kameraBlatt, onClick: () => {
+              setSelected(null);
+              setKameraBlatt((k) => !k);
+            }, children: "Kamera" }),
+            /* @__PURE__ */ jsx28("button", { type: "button", "aria-pressed": vollbild, onClick: () => {
+              setVollbild((v) => !v);
+              setKameraBlatt(false);
+            }, children: vollbild ? "Vollbild beenden" : "Vollbild" })
+          ] })
+        ] }),
+        engine && display ? /* @__PURE__ */ jsx28(StageBoundary, { resetKey: input, children: /* @__PURE__ */ jsx28(
+          engine.StageEngine,
+          {
+            input: display,
+            view,
+            selected,
+            labels,
+            onSelect: setSelected,
+            onMove: (id, p) => move((o) => {
+              o.nodes.set(id, p);
+            }),
+            onRotate: rotate,
+            onMoveCamera: camera?.placement?.mode === "absolute" ? (p) => move((o) => {
+              o.camera = { id: camera.camera_id, position: p };
+            }) : void 0,
+            visibility: sichtbar,
+            onSelectCamera: blatt ? () => {
+              setSelected(null);
+              setKameraBlatt(true);
+            } : void 0
+          }
+        ) }) : /* @__PURE__ */ jsx28("div", { className: "szenen-3d__viewport szenen-3d__viewport--laden", "aria-hidden": "true" }),
+        vollbild && blatt && objectSheet,
+        vollbild && kameraBlatt && !(blatt && objectSheet) && /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__objektblatt szenen-3d__kamerablatt", role: "region", "aria-label": "Kamera", children: [
+          /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__blatt-schliessen", onClick: () => setKameraBlatt(false), children: "Kamerablatt schlie\xDFen" }),
+          /* @__PURE__ */ jsxs26("fieldset", { disabled: busy, className: "szenen-3d__werte", children: [
+            /* @__PURE__ */ jsx28("legend", { children: "Kamera" }),
+            cameraFields
+          ] })
+        ] })
+      ] }),
       /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__inspektor", children: [
         /* @__PURE__ */ jsxs26("section", { className: "szenen-3d__karte", children: [
           /* @__PURE__ */ jsx28("h5", { children: "Elemente" }),
           /* @__PURE__ */ jsx28("div", { className: "szenen-3d__elemente", role: "group", "aria-label": "Element w\xE4hlen", children: nodes.map((n) => /* @__PURE__ */ jsxs26("button", { type: "button", "aria-pressed": n.node_id === selected, onClick: () => setSelected(n.node_id === selected ? null : n.node_id), children: [
-            /* @__PURE__ */ jsx28("i", { style: { background: stageColors(display?.scene.nodes.filter((n2) => !n2.hidden) ?? [])[n.node_id]?.hex ?? stageColor(n.type) }, "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx28("i", { style: { background: colors[n.node_id]?.hex ?? stageColor(n.type) }, "aria-hidden": "true" }),
             labels[n.node_id]
           ] }, n.node_id)) }),
-          node ? /* @__PURE__ */ jsxs26("fieldset", { disabled: busy, className: "szenen-3d__werte", children: [
-            /* @__PURE__ */ jsxs26("legend", { children: [
-              labels[node.node_id],
-              " ",
-              /* @__PURE__ */ jsx28("span", { children: stageTypeLabel(node.type) })
-            ] }),
-            /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Gr\xF6\xDFe (m)" }),
-            ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Gr\xF6\xDFe", axis, step: ".05", min: 0.01, value: node.proxy_3d?.dimensions?.[index], onCommit: (n) => edit("scene", (p) => ({ ...p, nodes: p.nodes.map((x) => {
-              if (x.node_id !== node.node_id) return x;
-              const d = [...x.proxy_3d?.dimensions ?? [1, 1, 1]];
-              d[index] = n;
-              return { ...x, proxy_3d: { primitive: x.proxy_3d?.primitive ?? "box", dimensions: d } };
-            }) })) }, axis)),
-            placement ? /* @__PURE__ */ jsxs26(Fragment12, { children: [
-              /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Position (m)" }),
-              ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Position", axis, step: ".05", value: nodePosition?.[index], onCommit: (n) => edit("setup", (p) => ({ ...p, placements: p.placements.map((x) => {
-                if (x.node_id !== node.node_id) return x;
-                const q = [...x.position];
-                q[index] = n;
-                return { ...x, position: q };
-              }) })) }, axis))
-            ] }) : /* @__PURE__ */ jsx28("button", { type: "button", onClick: () => edit("setup", (p) => ({ ...p, coordinate_system: "blender_z_up_meters", placements: [...p.placements ?? [], { node_id: node.node_id, position: [0, 0, 0] }] })), children: "Am Ursprung platzieren" })
-          ] }) : /* @__PURE__ */ jsxs26("p", { className: "szenen-3d__hinweis", children: [
+          objectSheet && !vollbild ? objectSheet : /* @__PURE__ */ jsxs26("p", { className: "szenen-3d__hinweis", children: [
             "Element in der B\xFChne oder hier ausw\xE4hlen.",
             /* @__PURE__ */ jsx28("span", { className: "szenen-3d__nur-maus", children: " Pfeiltasten verschieben in 5-cm-Schritten, mit Shift in 50 cm." })
           ] })
         ] }),
         /* @__PURE__ */ jsxs26("section", { className: "szenen-3d__karte", children: [
           /* @__PURE__ */ jsx28("h5", { children: "Aktive Kamera" }),
-          /* @__PURE__ */ jsxs26("label", { children: [
-            "Kamera",
-            /* @__PURE__ */ jsx28("select", { disabled: busy, value: base.shotPayload.camera_id ?? "", onChange: (e) => {
-              const id = e.target.value;
-              edit("shot", (p) => ({ ...p, camera_id: id }));
-            }, children: base.setupPayload.camera_rig.cameras.map((c) => /* @__PURE__ */ jsx28("option", { value: c.camera_id, children: c.name ?? c.camera_id }, c.camera_id)) })
-          ] }),
-          camera && /* @__PURE__ */ jsxs26("label", { children: [
-            "Kameraformat",
-            /* @__PURE__ */ jsxs26("select", { disabled: busy, value: camera.aspect_ratio ?? "", onChange: (e) => {
-              const ratio = e.target.value;
-              edit("setup", (p) => withCamera(p, camera.camera_id, (c) => ({ ...c, aspect_ratio: ratio })));
-            }, children: [
-              /* @__PURE__ */ jsx28("option", { value: "", children: "Explizit w\xE4hlen \u2026" }),
-              CAMERA_ASPECT_RATIOS.map((r) => /* @__PURE__ */ jsx28("option", { children: r }, r)),
-              camera.aspect_ratio && !CAMERA_ASPECT_RATIOS.includes(camera.aspect_ratio) && /* @__PURE__ */ jsx28("option", { children: camera.aspect_ratio })
-            ] })
-          ] }),
-          camera?.placement?.mode === "absolute" && /* @__PURE__ */ jsxs26("fieldset", { disabled: busy, className: "szenen-3d__werte", children: [
-            /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Position (m)" }),
-            ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Kameraposition", axis, step: ".1", value: cameraPosition?.[index], onCommit: (n) => edit("setup", (p) => withCamera(p, camera.camera_id, (c) => {
-              const position = [...c.placement.position];
-              position[index] = n;
-              return { ...c, placement: { mode: "absolute", position } };
-            })) }, axis)),
-            camera.orientation?.mode === "explicit" && /* @__PURE__ */ jsxs26(Fragment12, { children: [
-              /* @__PURE__ */ jsx28("span", { className: "szenen-3d__zeilenkopf", children: "Drehung (\xB0)" }),
-              ["X", "Y", "Z"].map((axis, index) => /* @__PURE__ */ jsx28(MeterField, { label: "Kameraausrichtung", axis, step: "1", value: camera.orientation.rotation_euler_deg[index], onCommit: (n) => edit("setup", (p) => withCamera(p, camera.camera_id, (c) => {
-                const rotation_euler_deg = [...c.orientation.rotation_euler_deg];
-                rotation_euler_deg[index] = n;
-                return { ...c, orientation: { mode: "explicit", rotation_euler_deg } };
-              })) }, axis))
-            ] })
-          ] }),
-          lookAt && /* @__PURE__ */ jsxs26("p", { className: "szenen-3d__hinweis", children: [
-            "Blickt auf ",
-            labels[lookAt] ?? lookAt,
-            ". Kamera in Drauf- oder Seitenansicht ziehen, um sie zu versetzen."
-          ] })
+          vollbild && kameraBlatt ? null : cameraFields
         ] })
       ] }),
       /* @__PURE__ */ jsxs26("div", { className: "szenen-3d__abschluss", children: [
@@ -17760,7 +18946,9 @@ function StageWorkspace({ port, sceneElementId, contextId, onClose, onChanged, e
           setRefresh((r) => r + 1);
         }), children: "Kamera-Preview nachspeichern" }),
         !port.runs.supportsCameraPreview && /* @__PURE__ */ jsx28("p", { className: "szenen-3d__hinweis", children: "Dieser Host kann das Kamera-Preview noch nicht am Run-Item speichern." }),
-        working && /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__nebenaktion", disabled: busy, onClick: () => enqueue((w) => reload(w)), children: "Gespeicherten Stand neu laden" })
+        working && /* @__PURE__ */ jsx28("button", { type: "button", className: "szenen-3d__nebenaktion", disabled: busy, onClick: () => enqueue(async (w) => {
+          await reload(w);
+        }), children: "Gespeicherten Stand neu laden" })
       ] }),
       working && /* @__PURE__ */ jsx28(RunsPanel, { port, contextId, source: { kind: "draft_chain", chainId: working.shot.draft.chain.chain_id } }, refresh)
     ] })
@@ -17915,7 +19103,7 @@ var ElementDetail = ({
   const setzeFeld = (pfad, wert) => setEntwurf((vorher) => ({ ...vorher, [pfad]: wert }));
   const payloadAusFormular = () => payloadFromForm(felder, entwurf);
   const strukturPayload = useMemo7(() => {
-    const lies = (name) => {
+    const lies2 = (name) => {
       try {
         const roh = JSON.parse(entwurf[name] || "[]");
         return Array.isArray(roh) ? roh : [];
@@ -17923,7 +19111,7 @@ var ElementDetail = ({
         return [];
       }
     };
-    return { nodes: lies("nodes"), relations: lies("relations") };
+    return { nodes: lies2("nodes"), relations: lies2("relations") };
   }, [entwurf.nodes, entwurf.relations]);
   const umgebungsRefs = useMemo7(() => {
     try {
@@ -22465,11 +23653,11 @@ function createClientDerivationPort(options) {
 }
 
 // src/lib/szenen/inputChecks.ts
-var fail2 = (message) => ({ kind: "error", message, retryable: false });
+var fail3 = (message) => ({ kind: "error", message, retryable: false });
 var KNOWN_TYPES = new Set(SZENEN_ELEMENT_TYPES);
 function checkRevision(value2, field) {
   if (typeof value2 !== "number" || !Number.isInteger(value2) || value2 < 0) {
-    return fail2(
+    return fail3(
       `${field} muss eine ganze Zahl >= 0 sein, war ${JSON.stringify(value2)}. Ohne belastbare Revision ist die Konfliktregel (\xA73.1) nicht anwendbar.`
     );
   }
@@ -22477,7 +23665,7 @@ function checkRevision(value2, field) {
 }
 function checkElementType(value2) {
   if (typeof value2 !== "string" || !KNOWN_TYPES.has(value2)) {
-    return fail2(
+    return fail3(
       `Unbekannter Elementtyp ${JSON.stringify(value2)}. Erlaubt: ${SZENEN_ELEMENT_TYPES.join(", ")}. Der Typ ist nach Anlage unveraenderlich (D-02) \u2014 ein falsch angelegtes Element laesst sich nur noch stilllegen.`
     );
   }
@@ -22485,20 +23673,20 @@ function checkElementType(value2) {
 }
 function checkTitle(value2) {
   if (typeof value2 !== "string" || value2.trim().length === 0) {
-    return fail2("title muss ein nicht leerer Text sein.");
+    return fail3("title muss ein nicht leerer Text sein.");
   }
   return null;
 }
 function checkOptionalId(value2, field) {
   if (value2 === null || value2 === void 0) return null;
   if (typeof value2 !== "string" || value2.trim().length === 0) {
-    return fail2(`${field} muss ein nicht leerer Text sein, wenn es gesetzt ist.`);
+    return fail3(`${field} muss ein nicht leerer Text sein, wenn es gesetzt ist.`);
   }
   return null;
 }
 function checkRequiredId(value2, field) {
   if (typeof value2 !== "string" || value2.trim().length === 0) {
-    return fail2(`${field} ist erforderlich.`);
+    return fail3(`${field} ist erforderlich.`);
   }
   return null;
 }
@@ -22506,17 +23694,17 @@ var RELATIONS = /* @__PURE__ */ new Set(["derived_from", "merged_from"]);
 function checkParents(value2) {
   if (value2 === void 0 || value2 === null) return null;
   if (!Array.isArray(value2)) {
-    return fail2(`parents muss ein Array sein, war ${typeof value2}.`);
+    return fail3(`parents muss ein Array sein, war ${typeof value2}.`);
   }
   for (const [i, entry] of value2.entries()) {
     if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-      return fail2(`parents[${i}] muss ein Objekt sein.`);
+      return fail3(`parents[${i}] muss ein Objekt sein.`);
     }
     const parent = entry;
     const idError = checkRequiredId(parent.parent_version_id, `parents[${i}].parent_version_id`);
     if (idError) return idError;
     if (typeof parent.relation !== "string" || !RELATIONS.has(parent.relation)) {
-      return fail2(
+      return fail3(
         `parents[${i}].relation muss "derived_from" oder "merged_from" sein, war ${JSON.stringify(parent.relation)}.`
       );
     }
@@ -22524,7 +23712,7 @@ function checkParents(value2) {
   return null;
 }
 function checkPayloadPresent(value2) {
-  if (value2 === void 0) return fail2("payload ist erforderlich.");
+  if (value2 === void 0) return fail3("payload ist erforderlich.");
   return null;
 }
 function firstError(...checks) {
@@ -22568,7 +23756,7 @@ function checkSetPreferredHeadInput(input) {
 }
 function checkCoverLength(value2) {
   if (typeof value2 === "string" && value2.length > 512) {
-    return fail2("cover_media_ref darf hoechstens 512 Zeichen lang sein.");
+    return fail3("cover_media_ref darf hoechstens 512 Zeichen lang sein.");
   }
   return null;
 }
@@ -24147,7 +25335,7 @@ function createFlowImageProvider(generateImage) {
 }
 
 // src/lib/szenen/imageGenerationOrderStore.ts
-function istText7(wert) {
+function istText8(wert) {
   return typeof wert === "string" && wert.trim().length > 0;
 }
 function collectImageGenerationOrders(events) {
@@ -24155,7 +25343,7 @@ function collectImageGenerationOrders(events) {
   for (const event of events) {
     if (event.type !== SZENEN_EVENT_TYPES.imageGenerationStarted) continue;
     const payload = event.payload;
-    if (!payload || !istText7(payload.generation_batch_id) || !istText7(payload.prompt_run_id)) continue;
+    if (!payload || !istText8(payload.generation_batch_id) || !istText8(payload.prompt_run_id)) continue;
     if (byBatchId.has(payload.generation_batch_id)) continue;
     byBatchId.set(payload.generation_batch_id, {
       generation_batch_id: payload.generation_batch_id,
@@ -24169,7 +25357,7 @@ function collectImageGenerationOrders(events) {
   for (const event of events) {
     if (event.type !== SZENEN_EVENT_TYPES.imageGenerationFinished) continue;
     const payload = event.payload;
-    if (!payload || !istText7(payload.generation_batch_id)) continue;
+    if (!payload || !istText8(payload.generation_batch_id)) continue;
     const auftrag = byBatchId.get(payload.generation_batch_id);
     if (!auftrag) continue;
     if (auftrag.status !== "started") continue;
@@ -24239,13 +25427,13 @@ function isSzenenItemId(itemId) {
   return itemId.startsWith(SZENEN_ITEM_PREFIX);
 }
 function checkSzenenBatchOrigin(candidate) {
-  if (!istText8(candidate.prompt_run_id)) {
+  if (!istText9(candidate.prompt_run_id)) {
     return {
       kind: "rejected",
       failure: { field: "prompt_run_id", message: '"prompt_run_id" fehlt oder ist leer.' }
     };
   }
-  if (!istText8(candidate.generation_batch_id)) {
+  if (!istText9(candidate.generation_batch_id)) {
     return {
       kind: "rejected",
       failure: {
@@ -24288,7 +25476,7 @@ function mergeSzenenBatchOrigin(bestehend, neu) {
   };
 }
 var DEFAULT_FSK_LEVEL = "FSK16";
-var istText8 = (v) => typeof v === "string" && v.trim().length > 0;
+var istText9 = (v) => typeof v === "string" && v.trim().length > 0;
 function roundOfRun(run, runsOfShot) {
   return runsOfShot.findIndex((kandidat) => kandidat.run_id === run.run_id) + 1;
 }
@@ -24324,7 +25512,7 @@ function deriveItemFromRun(input) {
       }
     };
   }
-  if (!run.output || !istText8(run.output.positive)) {
+  if (!run.output || !istText9(run.output.positive)) {
     return {
       kind: "rejected",
       failure: {
@@ -24348,8 +25536,8 @@ function deriveItemFromRun(input) {
   }
   const item_id = itemIdForRun(run.run_id);
   const lineage = deriveLineage(item_id, round, existingItems);
-  const negative = istText8(run.output.negative) ? run.output.negative : null;
-  const title = istText8(input.title) ? input.title : istText8(input.shotTitle) ? `${input.shotTitle} \xB7 Runde ${round}` : `Szenen-Lauf ${round}`;
+  const negative = istText9(run.output.negative) ? run.output.negative : null;
+  const title = istText9(input.title) ? input.title : istText9(input.shotTitle) ? `${input.shotTitle} \xB7 Runde ${round}` : `Szenen-Lauf ${round}`;
   return {
     kind: "ok",
     value: {
@@ -24359,9 +25547,9 @@ function deriveItemFromRun(input) {
       negative_prompt: negative,
       // `feedback` ist Pflicht (D-55) und ist genau die Erlaeuterung fuer den
       // Menschen — also gehoert sie in das Feld fuer Notizen.
-      notes: istText8(input.notes) ? input.notes : run.output.feedback,
+      notes: istText9(input.notes) ? input.notes : run.output.feedback,
       rating: typeof input.rating === "number" ? input.rating : 0,
-      fsk_level: istText8(input.fskLevel) ? input.fskLevel : DEFAULT_FSK_LEVEL,
+      fsk_level: istText9(input.fskLevel) ? input.fskLevel : DEFAULT_FSK_LEVEL,
       tags: [],
       szenen: {
         prompt_run_id: run.run_id,
@@ -24783,14 +25971,14 @@ function createImageGenerationPort(options) {
 }
 
 // src/lib/szenen/imageJobStore.ts
-var istText9 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+var istText10 = (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 || !istText9(payload.job_id) || !istText9(payload.prompt_run_id)) continue;
+    if (!payload || !istText10(payload.job_id) || !istText10(payload.prompt_run_id)) continue;
     if (nachId.has(payload.job_id)) continue;
     nachId.set(payload.job_id, {
       job_id: payload.job_id,
@@ -24809,7 +25997,7 @@ function collectImageJobs(events) {
   for (const event of events) {
     if (event.type !== SZENEN_EVENT_TYPES.imageJobClaimed) continue;
     const payload = event.payload;
-    if (!payload || !istText9(payload.job_id) || !istText9(payload.claim_id)) continue;
+    if (!payload || !istText10(payload.job_id) || !istText10(payload.claim_id)) continue;
     const auftrag = nachId.get(payload.job_id);
     if (!auftrag) continue;
     const anspruch = {
@@ -24828,7 +26016,7 @@ function collectImageJobs(events) {
   for (const event of events) {
     if (event.type !== SZENEN_EVENT_TYPES.imageJobSettled) continue;
     const payload = event.payload;
-    if (!payload || !istText9(payload.job_id)) continue;
+    if (!payload || !istText10(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;
@@ -24870,33 +26058,33 @@ function istOffen(job) {
   return job.status === "pending";
 }
 var PROMPT_AUSZUG_ZEICHEN = 160;
-var istText10 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+var istText11 = (wert) => typeof wert === "string" && wert.trim().length > 0;
 function titelJeElement(events) {
   const titel = /* @__PURE__ */ new Map();
   for (const event of events) {
     if (event.type === SZENEN_EVENT_TYPES.elementCreated) {
       const p = event.payload;
-      if (p && istText10(p.element_id) && istText10(p.title)) titel.set(p.element_id, p.title);
+      if (p && istText11(p.element_id) && istText11(p.title)) titel.set(p.element_id, p.title);
     } else if (event.type === SZENEN_EVENT_TYPES.metadataRevised) {
       const p = event.payload;
-      if (p && istText10(p.element_id) && istText10(p.title)) titel.set(p.element_id, p.title);
+      if (p && istText11(p.element_id) && istText11(p.title)) titel.set(p.element_id, p.title);
     }
   }
   return titel;
 }
 function benennendesElement(run) {
   const quelle = run.source;
-  if (quelle?.kind === "scene_direct" && istText10(quelle.scene?.element_id)) {
+  if (quelle?.kind === "scene_direct" && istText11(quelle.scene?.element_id)) {
     return quelle.scene.element_id;
   }
   if (quelle?.kind === "draft_chain") {
     const knoten = quelle.nodes ?? [];
-    const szene = knoten.find((k) => k?.type === "scene" && istText10(k.element_id));
+    const szene = knoten.find((k) => k?.type === "scene" && istText11(k.element_id));
     if (szene) return szene.element_id;
-    const shot = knoten.find((k) => k?.type === "shot" && istText10(k.element_id));
+    const shot = knoten.find((k) => k?.type === "shot" && istText11(k.element_id));
     if (shot) return shot.element_id;
   }
-  return istText10(run.shot_element_id) ? run.shot_element_id : null;
+  return istText11(run.shot_element_id) ? run.shot_element_id : null;
 }
 function kuerze(text2, zeichen) {
   const sauber = text2.replace(/\s+/g, " ").trim();
@@ -24921,7 +26109,7 @@ function herkunftFuer(job, laeufe, elementTitel, bilderJeLauf2) {
     run_id: job.prompt_run_id,
     szene_titel: elementId ? elementTitel.get(elementId) ?? null : null,
     szene_element_id: elementId,
-    prompt_auszug: istText10(positiv) ? kuerze(positiv, PROMPT_AUSZUG_ZEICHEN) : null,
+    prompt_auszug: istText11(positiv) ? kuerze(positiv, PROMPT_AUSZUG_ZEICHEN) : null,
     lauf_gefunden: true,
     bilder_im_lauf
   };
@@ -24943,7 +26131,7 @@ function selectImageJobs(events, storeId, query = {}) {
   const getroffen = status === "all" ? alle : alle.filter((j) => GRUPPEN[status].includes(j.status));
   const geordnet = sortiere(getroffen, logIndex, status === "pending");
   let ab = 0;
-  if (istText10(query.cursor)) {
+  if (istText11(query.cursor)) {
     const stelle = geordnet.findIndex((j) => j.job_id === query.cursor);
     if (stelle < 0) {
       throw new Error(
@@ -24972,8 +26160,8 @@ function bildRefAus(roh, batchId) {
     media_ref: roh.media_ref,
     position: roh.position,
     generation_batch_id: batchId,
-    ...istText10(roh.asset_id) ? { asset_id: roh.asset_id } : {},
-    ...istText10(roh.mime_type) ? { mime_type: roh.mime_type } : {},
+    ...istText11(roh.asset_id) ? { asset_id: roh.asset_id } : {},
+    ...istText11(roh.mime_type) ? { mime_type: roh.mime_type } : {},
     model: roh.model ?? null,
     seed: roh.seed ?? null,
     width: roh.width ?? null,
@@ -24988,10 +26176,10 @@ function bilderJeLauf(events, jobs) {
   for (const event of events) {
     if (event.type !== SZENEN_EVENT_TYPES.imageBatchPersisted) continue;
     const p = event.payload;
-    if (!p || !istText10(p.item_id) || !istText10(p.prompt_run_id) || !istText10(p.generation_batch_id)) continue;
+    if (!p || !istText11(p.item_id) || !istText11(p.prompt_run_id) || !istText11(p.generation_batch_id)) continue;
     if (gesehen.has(p.generation_batch_id)) continue;
     gesehen.add(p.generation_batch_id);
-    const roh = (Array.isArray(p.images) ? p.images : []).filter((b) => !!b && istText10(b.media_ref) && typeof b.position === "number").sort((a, b) => a.position - b.position);
+    const roh = (Array.isArray(p.images) ? p.images : []).filter((b) => !!b && istText11(b.media_ref) && typeof b.position === "number").sort((a, b) => a.position - b.position);
     if (roh.length === 0) continue;
     const job = jobJeBatch.get(p.generation_batch_id) ?? null;
     const liste = jeLauf.get(p.prompt_run_id) ?? [];
@@ -25004,7 +26192,7 @@ function bilderJeLauf(events, jobs) {
         job_id: job?.job_id ?? null,
         position_im_batch: einzeln.position + 1,
         anzahl_im_batch: roh.length,
-        gespeichert_am: istText10(p.created_at) ? p.created_at : null,
+        gespeichert_am: istText11(p.created_at) ? p.created_at : null,
         execution_target_model_key: job?.execution_target_model_key ?? null
       });
     }
@@ -25494,6 +26682,9 @@ export {
   hfUploadImage,
   hfLoadImageAsBase64,
   applyEvents,
+  STAGE_MIGRATION_ID,
+  STAGE_MIGRATION_EVENT,
+  prepareStageMigration,
   SZENEN_EVENT_PREFIX,
   SZENEN_EVENT_TYPES,
   reduceElementEvents,
@@ -25621,6 +26812,12 @@ export {
   completePromptOperation,
   runOfOperation,
   sameResponseAs,
+  CAMERA_PREVIEW_ASSET_ROLE,
+  checkVariantInputAssets,
+  checkVariantBlock,
+  buildPromptRunVariantRecord,
+  variantOf,
+  sameVariantRequest,
   DEFAULT_SEED_VORLAGE,
   parseSeedListe,
   formatSeedListe,
@@ -25630,6 +26827,13 @@ export {
   UPLOAD_MAX_BYTES,
   istZipDatei,
   leseBilderAusZip,
+  NODE_TYPES,
+  PROXY_PRIMITIVES,
+  previewColorNodes,
+  pinPreviewColors,
+  applyStageOperations,
+  findStageDraftChain,
+  openStageDraftChain,
   simulatedAnswerFor,
   SIMULATION_PROVIDER,
   createSimulationTextGenerationPort,