@rslsp1/fa-app-tools 2.0.73 → 2.0.81

package/dist/szenen.mjs

@@ -0,0 +1,1811 @@
+import {
+  ALL_PUBLISH_RULES,
+  CATALOGUE_TYPES,
+  CHAIN_EDGES,
+  CHAIN_LINK_FIELDS,
+  CapabilityAnchorError,
+  DERIVABLE_TYPES,
+  ELEMENT_VERSION_SCHEMA_FILE,
+  MAX_PROPOSAL_TITLE_LENGTH,
+  PROBE_VERSION_ID,
+  REFERENCE_FIELD,
+  RULES_WITHOUT_CAPABILITY_EFFECT,
+  RULE_SCOPES,
+  ResolveTechnicalError,
+  SIMULATION_PROVIDER,
+  SZENEN_ELEMENT_TYPES,
+  SZENEN_EVENT_PREFIX,
+  SZENEN_EVENT_TYPES,
+  SZENEN_ITEM_PREFIX,
+  SZENEN_SCHEMAS,
+  SzenenView,
+  UNCHECKED_PUBLISH_RULES,
+  UnsupportedSchemaError,
+  acceptProposalTitle,
+  areasFor,
+  assessDerivationResponse,
+  buildSystemInstruction,
+  buildSystemInstruction2,
+  buildUserPrompt,
+  buildUserPrompt2,
+  callOptional,
+  capabilitiesOf,
+  capabilityGate,
+  capabilityReport,
+  catalogueFor,
+  checkChainTargets,
+  checkCreateElementInput,
+  checkDerivationResponse,
+  checkDraftChainMeta,
+  checkElementType,
+  checkOptionalId,
+  checkParents,
+  checkPayloadPresent,
+  checkPublishVersionInput,
+  checkRequiredId,
+  checkReviseMetadataInput,
+  checkRevision,
+  checkRunResponse,
+  checkSetPreferredHeadInput,
+  checkSzenenBatchOrigin,
+  checkTitle,
+  checkWriteDraftInput,
+  collectPromptRuns,
+  collectSceneDerivationRecoveries,
+  collectSceneDerivations,
+  collectVersionRefs,
+  compileSchemas,
+  createClientDerivationPort,
+  createClientRunPort,
+  createEventLogDerivationPersistence,
+  createEventLogRunPersistence,
+  createFakeTextGenerationPort,
+  createFlowSzenenViewPort,
+  createFlowTextGenerationPort,
+  createHfElementStore,
+  createHfEventChannel,
+  createHfImageLibrary,
+  createSimulationSceneDerivationPort,
+  createSimulationTextGenerationPort,
+  derivationPoliciesOf,
+  deriveItemFromRun,
+  deriveLineage,
+  describeTargetModelFailure,
+  draftRevisionOf,
+  findPromptRun,
+  findSceneDerivation,
+  findSceneDerivationRecovery,
+  firstError,
+  formatSchemaErrors,
+  freezeDraftChain,
+  getSzenenSchemas,
+  hasPlacementCapability,
+  isKnownElementType,
+  isOk,
+  isProjectionCurrent,
+  isSzenenItemId,
+  itemIdForRun,
+  linkFor,
+  logRevisionOf,
+  mergeSzenenBatchOrigin,
+  noticeFor,
+  parseDerivationResponse,
+  parseRunResponse,
+  preferredHeadRevisionOf,
+  publishedHeadsOf,
+  recoveriesForRun,
+  recoveryStatusOf,
+  reduceElementEvents,
+  resolveArea,
+  resolveShot,
+  resolveShotPayload,
+  resolveTargetModelOver,
+  resolverFromQueries,
+  roundOfRun,
+  runPromptDerivation,
+  runPublishChecks,
+  runSceneDerivation,
+  scopeOfPath,
+  showChain,
+  simulatedAnswerFor,
+  unclassifiedPublishRules,
+  unsupportedReason,
+  validateAgainst,
+  validateDerivationInput,
+  validateElementVersion,
+  validatePayload,
+  withReference
+} from "./chunk-GEGJD43Y.mjs";
+import {
+  ContractViolation,
+  STYLE_PAYLOAD,
+  STYLE_PAYLOAD_V2,
+  elementStoreContractChecks,
+  runElementStoreContract
+} from "./chunk-43TWCAG5.mjs";
+import {
+  VersionDagError,
+  buildVersionDag,
+  preferredVersionId,
+  resolvePreferredHead
+} from "./chunk-FUY2OCVC.mjs";
+import "./chunk-VBWQP7PO.mjs";
+
+// src/lib/szenen/providerCheckStore.ts
+function collectProviderChecks(events) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.providerCheckRecorded) continue;
+    const payload = event.payload;
+    if (!payload || typeof payload.check_id !== "string") continue;
+    if (!byId.has(payload.check_id)) byId.set(payload.check_id, payload);
+  }
+  return [...byId.values()];
+}
+function findProviderCheck(events, checkId) {
+  return collectProviderChecks(events).find((c) => c.check_id === checkId) ?? null;
+}
+function totalModelCalls(checks) {
+  return checks.reduce((summe, check) => summe + (Number(check.model_calls) || 0), 0);
+}
+
+// src/lib/szenen/imageGenerationOrderStore.ts
+function istText(wert) {
+  return typeof wert === "string" && wert.trim().length > 0;
+}
+function collectImageGenerationOrders(events) {
+  const byBatchId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageGenerationStarted) continue;
+    const payload = event.payload;
+    if (!payload || !istText(payload.generation_batch_id) || !istText(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,
+      prompt_run_id: payload.prompt_run_id,
+      source_kind: "generated_in_app",
+      request: payload.request,
+      created_at: payload.created_at ?? "",
+      status: "started"
+    });
+  }
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageGenerationFinished) continue;
+    const payload = event.payload;
+    if (!payload || !istText(payload.generation_batch_id)) continue;
+    const auftrag = byBatchId.get(payload.generation_batch_id);
+    if (!auftrag) continue;
+    if (auftrag.status !== "started") continue;
+    if (payload.status !== "succeeded" && payload.status !== "partial" && payload.status !== "failed") continue;
+    byBatchId.set(payload.generation_batch_id, {
+      ...auftrag,
+      status: payload.status,
+      ...payload.item_id ? { item_id: payload.item_id } : {},
+      produced_count: payload.produced_count ?? 0,
+      ...payload.diagnostic ? { diagnostic: payload.diagnostic } : {},
+      finished_at: payload.finished_at ?? ""
+    });
+  }
+  return [...byBatchId.values()];
+}
+function ordersForPromptRun(events, runId) {
+  return collectImageGenerationOrders(events).filter((o) => o.prompt_run_id === runId);
+}
+function findImageGenerationOrder(events, batchId) {
+  return collectImageGenerationOrders(events).find((o) => o.generation_batch_id === batchId) ?? null;
+}
+
+// src/lib/szenen/inMemoryEventChannel.ts
+function createInMemoryEventChannel(options = {}) {
+  const log = options.shared ?? [];
+  let tick = 0;
+  const now = options.now ?? (() => ++tick);
+  const clientId = options.clientId ?? "client-a";
+  const channel = {
+    get events() {
+      return log;
+    },
+    async readEvents() {
+      return log.map((event) => ({ ...event }));
+    },
+    async appendEvent(type, payload) {
+      log.push({ type, payload, clientId, ts: now() });
+    },
+    appendRaw(event) {
+      log.push(event);
+    },
+    withClient(otherClientId) {
+      return createInMemoryEventChannel({ clientId: otherClientId, now, shared: log });
+    }
+  };
+  return channel;
+}
+
+// src/lib/szenen/storeDifferential.ts
+var IGNORED_FIELDS = /* @__PURE__ */ new Set([
+  "message",
+  /** Der schreibende Client heißt je Untergrund anders. */
+  "updated_by_client",
+  /** Unterscheidet sich zwangsläufig und sagt fachlich nichts. */
+  "server_received_at"
+]);
+function normalize(value, state) {
+  const replacements = /* @__PURE__ */ new Map();
+  replacements.set(state.elementId, "<element>");
+  state.versionIds.forEach((id, i) => replacements.set(id, `<version:${i + 1}>`));
+  if (state.draftId) replacements.set(state.draftId, "<draft>");
+  const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+  const walk = (node) => {
+    if (typeof node === "string") {
+      if (replacements.has(node)) return replacements.get(node);
+      return node.replace(UUID, (match) => replacements.get(match) ?? "<uuid>");
+    }
+    if (Array.isArray(node)) return node.map(walk);
+    if (node && typeof node === "object") {
+      const out = {};
+      for (const key of Object.keys(node).sort()) {
+        if (IGNORED_FIELDS.has(key)) continue;
+        out[key] = walk(node[key]);
+      }
+      return out;
+    }
+    return node;
+  };
+  return walk(value);
+}
+function differentialSteps() {
+  const shape = (result) => result;
+  return [
+    {
+      name: "createElement",
+      async run(store, state) {
+        const result = await store.createElement({
+          type: "style",
+          title: "Kohle",
+          contextId: "diff",
+          description: "erste Notiz"
+        });
+        if (result.kind === "ok") state.elementId = result.value.element_id;
+        return shape(result);
+      }
+    },
+    {
+      name: "writeDraft (erste Revision)",
+      async run(store, state) {
+        const result = await store.writeDraft({
+          elementId: state.elementId,
+          payload: STYLE_PAYLOAD,
+          expectedRevision: 0
+        });
+        if (result.kind === "ok") state.draftId = result.value.draft_id;
+        return shape(result);
+      }
+    },
+    {
+      name: "writeDraft mit veralteter Revision \u2192 conflict",
+      async run(store, state) {
+        return shape(
+          await store.writeDraft({
+            elementId: state.elementId,
+            payload: STYLE_PAYLOAD_V2,
+            expectedRevision: 0
+          })
+        );
+      }
+    },
+    {
+      name: "writeDraft mit unbekannter base_version_id \u2192 error",
+      async run(store, state) {
+        return shape(
+          await store.writeDraft({
+            elementId: state.elementId,
+            payload: STYLE_PAYLOAD,
+            expectedRevision: 1,
+            baseVersionId: "00000000-0000-7000-8000-0000000affff"
+          })
+        );
+      }
+    },
+    {
+      name: "publishVersion",
+      async run(store, state) {
+        const result = await store.publishVersion({
+          elementId: state.elementId,
+          payload: STYLE_PAYLOAD,
+          schemaVersion: "1.0.0",
+          publishedBy: "diff"
+        });
+        if (result.kind === "ok") state.versionIds.push(result.value.version_id);
+        return shape(result);
+      }
+    },
+    {
+      name: "publishVersion mit derived_from",
+      async run(store, state) {
+        const result = await store.publishVersion({
+          elementId: state.elementId,
+          payload: STYLE_PAYLOAD_V2,
+          schemaVersion: "1.0.0",
+          publishedBy: "diff",
+          parents: [{ parent_version_id: state.versionIds[0], relation: "derived_from" }]
+        });
+        if (result.kind === "ok") state.versionIds.push(result.value.version_id);
+        return shape(result);
+      }
+    },
+    {
+      name: "publishVersion schemawidrig \u2192 rejected",
+      async run(store, state) {
+        return shape(
+          await store.publishVersion({
+            elementId: state.elementId,
+            payload: { role: "gibt-es-nicht", name: "X", text: "Y", locale: "de" },
+            schemaVersion: "1.0.0",
+            publishedBy: "diff"
+          })
+        );
+      }
+    },
+    {
+      name: "createElement mit unbekanntem Typ \u2192 error",
+      async run(store) {
+        return shape(await store.createElement({ type: "weltmodell", title: "X" }));
+      }
+    },
+    {
+      name: "reviseMetadata ohne description (\xA78)",
+      async run(store, state) {
+        if (!store.reviseMetadata) return shape({ kind: "unsupported", capability: "reviseMetadata" });
+        return shape(
+          await store.reviseMetadata({
+            elementId: state.elementId,
+            title: "Neu",
+            expectedRevision: 1
+          })
+        );
+      }
+    },
+    {
+      name: "setPreferredHead",
+      async run(store, state) {
+        if (!store.setPreferredHead) {
+          return shape({ kind: "unsupported", capability: "setPreferredHead" });
+        }
+        return shape(
+          await store.setPreferredHead({
+            elementId: state.elementId,
+            contextId: "diff",
+            versionId: state.versionIds[1],
+            expectedRevision: 0,
+            selectedBy: "diff"
+          })
+        );
+      }
+    },
+    {
+      name: "getElement (vollstaendiger Stand)",
+      async run(store, state) {
+        return shape(await store.getElement(state.elementId));
+      }
+    },
+    {
+      name: "listElements im Kontext",
+      async run(store) {
+        return shape(await store.listElements({ contextId: "diff" }));
+      }
+    }
+  ];
+}
+async function runStoreDifferential(left, right) {
+  const steps = differentialSteps();
+  const leftStore = await left();
+  const rightStore = await right();
+  const leftState = { elementId: "", versionIds: [], draftId: null };
+  const rightState = { elementId: "", versionIds: [], draftId: null };
+  const divergences = [];
+  for (const step of steps) {
+    const leftRaw = await step.run(leftStore, leftState);
+    const rightRaw = await step.run(rightStore, rightState);
+    const leftText = JSON.stringify(normalize(leftRaw, leftState));
+    const rightText = JSON.stringify(normalize(rightRaw, rightState));
+    if (leftText !== rightText) {
+      divergences.push({ step: step.name, left: leftText, right: rightText });
+    }
+  }
+  return { steps: steps.length, divergences, identical: divergences.length === 0 };
+}
+
+// src/lib/szenen/imageGenerationCapability.ts
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var IMAGE_MODEL_CATALOGUE = {
+  imagen_4: {
+    callable_model_id: "imagen-4.0-generate-001",
+    provider: "google",
+    max_images: 4,
+    aspect_ratios: ["1:1", "3:4", "4:3", "9:16", "16:9"],
+    supports_seed: true
+  },
+  imagen_3: {
+    callable_model_id: "imagen-3.0-generate-001",
+    provider: "google",
+    max_images: 4,
+    aspect_ratios: ["1:1", "3:4", "4:3", "9:16", "16:9"],
+    supports_seed: true
+  }
+};
+function callableImageModelFor(targetModelKey) {
+  return IMAGE_MODEL_CATALOGUE[targetModelKey] ?? null;
+}
+function targetModelKeyOf(targetModel) {
+  if (!isObject(targetModel)) return null;
+  return typeof targetModel.key === "string" && targetModel.key.length > 0 ? targetModel.key : null;
+}
+function capabilityForTargetModel(targetModel, hasAccess) {
+  const key = targetModelKeyOf(targetModel);
+  if (!key) {
+    return {
+      kind: "unsupported",
+      target_model_key: "(unbekannt)",
+      reason: 'Der eingefrorene Lauf tr\xE4gt kein "target_model.key" \u2014 es gibt nichts zuzuordnen.'
+    };
+  }
+  const modell = callableImageModelFor(key);
+  if (!modell) {
+    return {
+      kind: "unsupported",
+      target_model_key: key,
+      reason: `F\xFCr das Zielmodell "${key}" ist in diesem Host kein Bildpfad katalogisiert.`
+    };
+  }
+  if (!hasAccess(modell)) {
+    return {
+      kind: "unsupported",
+      target_model_key: key,
+      reason: `Dieser Host hat keinen Zugang zu ${modell.callable_model_id} (${modell.provider}).`
+    };
+  }
+  return {
+    kind: "supported",
+    target_model_key: key,
+    provider: modell.provider,
+    callable_model_id: modell.callable_model_id,
+    max_images: modell.max_images,
+    aspect_ratios: modell.aspect_ratios,
+    supports_seed: modell.supports_seed
+  };
+}
+
+// src/lib/szenen/imageGenerationPort.ts
+function queryError(error, action) {
+  return {
+    kind: "error",
+    message: `${action}: ${error instanceof Error ? error.message : String(error)}`,
+    retryable: true
+  };
+}
+function createImageGenerationPort(options) {
+  const { runs, provider, batches, events, hasAccess } = options;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  async function readRun(runId) {
+    try {
+      return await runs.getRun(runId);
+    } catch (error) {
+      return queryError(error, `Lauf ${runId} konnte nicht gelesen werden`);
+    }
+  }
+  return {
+    async capabilityForRun(runId) {
+      const gelesen = await readRun(runId);
+      if (gelesen.kind !== "ok") return gelesen;
+      if (!gelesen.value) {
+        return { kind: "error", message: `Lauf ${runId} ist unbekannt.`, retryable: false };
+      }
+      const targetModel = gelesen.value.input_payload?.target_model;
+      return { kind: "ok", value: capabilityForTargetModel(targetModel, hasAccess) };
+    },
+    async startFromPromptRun(input) {
+      const gelesen = await readRun(input.runId);
+      if (gelesen.kind !== "ok") return { kind: "rejected", message: gelesen.message };
+      if (!gelesen.value) {
+        return { kind: "rejected", message: `Lauf ${input.runId} ist unbekannt.` };
+      }
+      const run = gelesen.value;
+      if (run.status !== "succeeded" || !run.output) {
+        return {
+          kind: "rejected",
+          message: `Lauf ${input.runId} ist nicht erfolgreich \u2014 ein Bildauftrag braucht einen eingefrorenen Prompt (D-103).`
+        };
+      }
+      const targetModel = run.input_payload?.target_model;
+      const capability = capabilityForTargetModel(targetModel, hasAccess);
+      if (capability.kind !== "supported") {
+        return { kind: "unsupported", targetModelKey: capability.target_model_key, reason: capability.reason };
+      }
+      const startedPayload = {
+        generation_batch_id: input.generationBatchId,
+        prompt_run_id: input.runId,
+        source_kind: "generated_in_app",
+        request: {
+          image_count: input.imageCount,
+          ...input.aspectRatio ? { aspect_ratio: input.aspectRatio } : {},
+          ...input.seeds ? { seeds: input.seeds } : {},
+          callable_model_id: capability.callable_model_id
+        },
+        created_at: now().toISOString()
+      };
+      try {
+        await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationStarted, startedPayload);
+      } catch (error) {
+        return {
+          kind: "failed",
+          message: `Der Auftrag ${input.generationBatchId} konnte nicht protokolliert werden: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      let produced = [];
+      let providerFehler = null;
+      try {
+        const antwort = await provider.generate({
+          callableModelId: capability.callable_model_id,
+          provider: capability.provider,
+          positivePrompt: run.output.positive,
+          negativePrompt: run.output.negative,
+          imageCount: input.imageCount,
+          ...input.aspectRatio ? { aspectRatio: input.aspectRatio } : {},
+          ...input.seeds ? { seeds: input.seeds } : {}
+        });
+        produced = antwort.images;
+      } catch (error) {
+        providerFehler = error instanceof Error ? error.message : String(error);
+      }
+      if (providerFehler || produced.length === 0) {
+        const finishedPayload2 = {
+          generation_batch_id: input.generationBatchId,
+          status: "failed",
+          produced_count: 0,
+          diagnostic: providerFehler ?? "Der Provider hat kein verwertbares Bild geliefert.",
+          finished_at: now().toISOString()
+        };
+        await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationFinished, finishedPayload2).catch(() => {
+        });
+        return {
+          kind: "failed",
+          message: finishedPayload2.diagnostic
+        };
+      }
+      const persistiert = await batches.persist({
+        runId: input.runId,
+        generationBatchId: input.generationBatchId,
+        images: produced
+      });
+      if (persistiert.kind !== "ok") {
+        const finishedPayload2 = {
+          generation_batch_id: input.generationBatchId,
+          status: "failed",
+          produced_count: 0,
+          diagnostic: persistiert.kind === "error" ? persistiert.message : `Batch ${input.generationBatchId} konnte nicht gespeichert werden (${persistiert.kind}).`,
+          finished_at: now().toISOString()
+        };
+        await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationFinished, finishedPayload2).catch(() => {
+        });
+        return { kind: "failed", message: finishedPayload2.diagnostic };
+      }
+      const istPartial = produced.length < input.imageCount;
+      const finishedPayload = {
+        generation_batch_id: input.generationBatchId,
+        status: istPartial ? "partial" : "succeeded",
+        item_id: persistiert.value.item_id,
+        produced_count: produced.length,
+        finished_at: now().toISOString()
+      };
+      await events.appendEvent(SZENEN_EVENT_TYPES.imageGenerationFinished, finishedPayload).catch(() => {
+      });
+      return istPartial ? { kind: "partial", batch: persistiert.value, requested: input.imageCount, produced: produced.length } : { kind: "succeeded", batch: persistiert.value };
+    }
+  };
+}
+
+// src/lib/szenen/memoryViewPort.ts
+function ok(value) {
+  return { kind: "ok", value };
+}
+function done(value) {
+  return { kind: "ok", value };
+}
+var laufender = 0;
+var defaultIds = () => `mem-${Date.now().toString(36)}-${(laufender += 1).toString(36)}`;
+function simulierterLauf(input, runId) {
+  return {
+    run_id: runId,
+    shot_version_id: input.shotVersionId,
+    shot_element_id: `element-of-${input.shotVersionId}`,
+    scene_setup_version_id: "setup-simuliert",
+    camera_id: "kamera-simuliert",
+    target_model_version_id: "zielmodell-simuliert",
+    // Sichtbar als Simulation, nicht als echter Anbieter.
+    provider: "simulation",
+    model_id: "simulation",
+    system_prompt: "(simuliert)",
+    input_payload: {},
+    status: "succeeded",
+    failure: null,
+    output: {
+      positive: `Simulierter positiver Prompt f\xFCr ${input.shotVersionId}` + (input.userInstruction ? ` \u2014 Anweisung: ${input.userInstruction}` : ""),
+      negative: "Simulierter negativer Prompt",
+      feedback: "Simulierter Lauf \u2014 kein Anbieter beteiligt.",
+      visibility: { basis: "assumed", nodes: [], assumptions: ["Simulierter Lauf ohne Anbieter"] },
+      notes: []
+    },
+    raw_output: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function simulierteRekonstruktion(input, runId) {
+  return {
+    run_id: runId,
+    policy_version_id: input.policyVersionId,
+    policy_element_id: `element-of-${input.policyVersionId}`,
+    context_id: input.contextId ?? null,
+    provider: "simulation",
+    model_id: "simulation",
+    system_prompt: "(simuliert)",
+    // D-73: die Herkunft, nie die Bilddaten.
+    input: {
+      mode: input.mode,
+      prompt_text: input.promptText ?? null,
+      images: (input.images ?? []).map((b) => b.provenance)
+    },
+    status: "succeeded",
+    failure: null,
+    proposals: [
+      {
+        type: "scene",
+        payload: {
+          nodes: [
+            { node_id: "simuliert", type: "subject", semantic: { description: "simuliert" } }
+          ],
+          relations: []
+        }
+      }
+    ],
+    feedback: "Simulierte Rekonstruktion \u2014 kein Anbieter beteiligt.",
+    assumptions: ["Simulierter Lauf ohne Anbieter"],
+    not_derivable: [{ field: "/", reason: "Ohne Modell ist nichts ableitbar." }],
+    conflicts: [],
+    raw_output: null,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createMemoryViewPort(options = {}) {
+  const ids = options.ids ?? defaultIds;
+  const elements = createHfElementStore({ channel: createInMemoryEventChannel() });
+  const laeufe = [...options.runs ?? []];
+  const items = /* @__PURE__ */ new Map();
+  const versionMedien = /* @__PURE__ */ new Map();
+  const itemMedien = /* @__PURE__ */ new Map();
+  const runs = {
+    async listRunsForShot(shotVersionId) {
+      return ok(laeufe.filter((l) => l.shot_version_id === shotVersionId));
+    },
+    async getRun(runId) {
+      return ok(laeufe.find((l) => l.run_id === runId) ?? null);
+    },
+    async startRun(input) {
+      const runId = ids();
+      const lauf = (options.deriveRun ?? simulierterLauf)(input, runId);
+      laeufe.push(lauf);
+      return done(lauf);
+    },
+    // ── Der Lauf aus einer Draft-Kette (Stufe 6.6, C3) ────────────────────
+    //
+    // Der Speicherport bildet die Form ab: ein Lauf mit `source.kind ===
+    // 'draft_chain'` und ohne Versionskennungen. Ob eine Kette gueltig ist und
+    // ob das Einfrieren traegt, entscheidet `clientRunPort` gegen einen echten
+    // Speicher — hier waere es eine zweite Wahrheit.
+    async startRunFromDraft(input) {
+      const runId = ids();
+      const basis = (options.deriveRun ?? simulierterLauf)(
+        { shotVersionId: "", ...input.userInstruction ? { userInstruction: input.userInstruction } : {} },
+        runId
+      );
+      const lauf = {
+        ...basis,
+        shot_version_id: "",
+        shot_element_id: input.shotElementId,
+        scene_setup_version_id: "",
+        source: {
+          kind: "draft_chain",
+          chain_id: `kette-${runId}`,
+          nodes: [{
+            type: "shot",
+            element_id: input.shotElementId,
+            draft_id: `draft-${input.shotElementId}`,
+            revision: 1
+          }]
+        }
+      };
+      laeufe.push(lauf);
+      return done(lauf);
+    },
+    async listRunsForChain(chainId) {
+      return ok(laeufe.filter(
+        (r) => r.source?.kind === "draft_chain" && r.source.chain_id === chainId
+      ));
+    }
+  };
+  const itemPort = {
+    async getItemForRun(runId) {
+      return ok(items.get(runId) ?? null);
+    },
+    async saveRunAsItem(input) {
+      const lauf = laeufe.find((l) => l.run_id === input.runId);
+      if (!lauf) {
+        return { kind: "error", message: `Lauf ${input.runId} ist unbekannt.`, retryable: false };
+      }
+      if (lauf.status !== "succeeded") {
+        return {
+          kind: "error",
+          message: `Lauf ${input.runId} ist fehlgeschlagen \u2014 aus einem Fehlerlauf entsteht kein Item.`,
+          retryable: false
+        };
+      }
+      const bestehend = items.get(input.runId);
+      if (bestehend) return done({ reference: bestehend, created: false });
+      const referenz = {
+        itemId: itemIdForRun(input.runId),
+        title: input.title ?? `Runde aus ${input.runId}`,
+        item: null
+      };
+      items.set(input.runId, referenz);
+      return done({ reference: referenz, created: true });
+    }
+  };
+  const mediaPort = {
+    async listVersionMedia(versionId) {
+      return ok([...versionMedien.get(versionId) ?? []].sort((a, b) => a.position - b.position));
+    },
+    async listItemMedia(itemId) {
+      return ok([...itemMedien.get(itemId) ?? []].sort((a, b) => a.position - b.position));
+    },
+    async attachVersionMedium(input) {
+      const vorhanden = versionMedien.get(input.versionId) ?? [];
+      const schon = vorhanden.find((m) => m.assetId === input.assetId && m.role === input.role);
+      if (schon) return done(schon);
+      const medium = {
+        assetId: input.assetId,
+        role: input.role,
+        position: input.position ?? vorhanden.length,
+        url: null
+      };
+      versionMedien.set(input.versionId, [...vorhanden, medium]);
+      return done(medium);
+    },
+    async detachVersionMedium(input) {
+      const vorhanden = versionMedien.get(input.versionId) ?? [];
+      const rest = vorhanden.filter((m) => !(m.assetId === input.assetId && m.role === input.role));
+      versionMedien.set(input.versionId, rest);
+      return done({ removed: rest.length !== vorhanden.length });
+    }
+  };
+  const rekonstruktionen = [];
+  const fassungen = [];
+  const uebernommen = /* @__PURE__ */ new Map();
+  const derivationPort = {
+    async listPolicies() {
+      return ok(options.policies ?? [{
+        elementId: "policy-element",
+        versionId: "policy-version",
+        title: "Testregel",
+        inputModes: ["prompt", "image", "image_prompt"],
+        produces: ["scene"]
+      }]);
+    },
+    async getDerivation(runId) {
+      return ok(rekonstruktionen.find((r) => r.run_id === runId) ?? null);
+    },
+    async startDerivation(input) {
+      const runId = ids();
+      const lauf = (options.deriveScene ?? simulierteRekonstruktion)(input, runId);
+      rekonstruktionen.push(lauf);
+      return done(lauf);
+    },
+    async adoptProposal(input) {
+      const lauf = rekonstruktionen.find((r) => r.run_id === input.runId);
+      if (!lauf) {
+        return { kind: "error", message: `Lauf ${input.runId} ist unbekannt.`, retryable: false };
+      }
+      const schluessel = `${input.runId}:${input.type}`;
+      const schon = uebernommen.get(schluessel);
+      if (schon) return done({ runId: input.runId, type: input.type, elementId: schon });
+      const elementId = ids();
+      uebernommen.set(schluessel, elementId);
+      return done({ runId: input.runId, type: input.type, elementId });
+    },
+    // ── Graph-Uebernahme (Stufe 6.6) ──────────────────────────────────────
+    //
+    // Der Speicherport bildet die **Form** ab, nicht die Fachlichkeit: eine
+    // Kette mit einer chain_id und je Typ einem Knoten. Ob Vertraege halten
+    // und Links stimmen, entscheidet `clientDerivationPort` gegen einen echten
+    // Speicher — hier waere es eine zweite Wahrheit.
+    async adoptProposalGraph(input) {
+      if ((input.runId ? 1 : 0) + (input.recoveryId ? 1 : 0) !== 1) {
+        return {
+          kind: "error",
+          message: "Eine Graph-Uebernahme braucht genau einen Ursprung.",
+          retryable: false
+        };
+      }
+      const lauf = rekonstruktionen.find((r) => r.run_id === input.runId) ?? rekonstruktionen.find(
+        (r) => r.run_id === fassungen.find((f) => f.recovery_id === input.recoveryId)?.run_id
+      );
+      if (!lauf) {
+        return { kind: "error", message: "Ursprung ist unbekannt.", retryable: false };
+      }
+      const gewuenscht = input.types ?? lauf.proposals.map((p) => p.type);
+      const chainId = ids();
+      const created = gewuenscht.map((type) => ({
+        type,
+        elementId: ids(),
+        draftId: ids(),
+        revision: 1
+      }));
+      return done({
+        chainId,
+        sourceRunId: lauf.run_id,
+        ...input.recoveryId ? { sourceRecoveryId: input.recoveryId } : {},
+        created,
+        missing: [],
+        complete: true
+      });
+    },
+    // ── Fehlerrettung (Stufe 6.6) ─────────────────────────────────────────
+    //
+    // Der Speicherport simuliert nicht den Parser: Er haelt Fassungen und gibt
+    // zurueck, was hineingegeben wurde. Was eine Bewertung fachlich leistet,
+    // gehoert in `clientDerivationPort` und wird dort geprueft — hier waere es
+    // eine zweite Wahrheit.
+    async assessRawOutput(input) {
+      const lauf = rekonstruktionen.find((r) => r.run_id === input.runId);
+      if (!lauf) {
+        return { kind: "error", message: `Lauf ${input.runId} ist unbekannt.`, retryable: false };
+      }
+      if (typeof lauf.raw_output !== "string" || lauf.raw_output.length === 0) {
+        return {
+          kind: "error",
+          message: `Lauf ${input.runId} hat keine Rohantwort \u2014 es gibt nichts zu pruefen.`,
+          retryable: false
+        };
+      }
+      const text = input.text ?? lauf.raw_output;
+      return ok({
+        runId: input.runId,
+        source_text: text,
+        edited: text !== lauf.raw_output,
+        diagnostics: [],
+        proposals: lauf.proposals,
+        rejected: [],
+        status: lauf.proposals.length > 0 ? "usable" : "invalid"
+      });
+    },
+    async recordRecovery(input) {
+      const geprueft = await derivationPort.assessRawOutput(input);
+      if (geprueft.kind !== "ok") {
+        return { kind: "error", message: geprueft.message, retryable: geprueft.retryable };
+      }
+      const record = {
+        recovery_id: ids(),
+        run_id: geprueft.value.runId,
+        source_text: geprueft.value.source_text,
+        edited: geprueft.value.edited,
+        diagnostics: geprueft.value.diagnostics,
+        proposals: geprueft.value.proposals,
+        status: geprueft.value.status,
+        created_at: (/* @__PURE__ */ new Date(0)).toISOString()
+      };
+      fassungen.push(record);
+      return done(record);
+    },
+    async getRecovery(recoveryId) {
+      return ok(fassungen.find((r) => r.recovery_id === recoveryId) ?? null);
+    },
+    async listRecoveries(runId) {
+      return ok(fassungen.filter((r) => r.run_id === runId));
+    }
+  };
+  const bilder = /* @__PURE__ */ new Map();
+  for (const bild of options.images ?? []) {
+    bilder.set(bild.mediaRef, { bild, data: "AAAA" });
+  }
+  const imageLibraryPort = {
+    async listImages(query) {
+      const alle = [...bilder.values()].map((e) => e.bild);
+      const gesucht = query?.search?.trim().toLowerCase();
+      const gefiltert = gesucht ? alle.filter((b) => b.title.toLowerCase().includes(gesucht)) : alle;
+      return ok(query?.limit ? gefiltert.slice(0, query.limit) : gefiltert);
+    },
+    async resolveImage(mediaRef) {
+      const eintrag = bilder.get(mediaRef);
+      if (!eintrag) {
+        return { kind: "error", message: `Bild ${mediaRef} ist unbekannt.`, retryable: false };
+      }
+      return ok({ data: eintrag.data, mime_type: eintrag.bild.mimeType });
+    },
+    async putImage(input) {
+      const mediaRef = ids();
+      const bild = {
+        mediaRef,
+        title: input.title,
+        mimeType: input.mime_type,
+        thumbUrl: null
+      };
+      bilder.set(mediaRef, { bild, data: input.data });
+      return done(bild);
+    }
+  };
+  const batches = [...options.batches ?? []];
+  const imageGenerationEvents = createInMemoryEventChannel();
+  const imageBatchHistoryPort = {
+    async listBatchesForPromptRun(runId) {
+      return ok(batches.filter((b) => b.prompt_run_id === runId));
+    },
+    async getBatch(batchId) {
+      return ok(batches.find((b) => b.generation_batch_ids.includes(batchId)) ?? null);
+    },
+    async listOrdersForPromptRun(runId) {
+      return ok(ordersForPromptRun(await imageGenerationEvents.readEvents(), runId));
+    }
+  };
+  const imageBatchWritePort = {
+    async importBatch(input) {
+      const bestehend = batches.find((b) => b.generation_batch_ids.includes(input.generationBatchId));
+      if (bestehend) return done(bestehend);
+      const vorhandenesItem = batches.find((b) => b.prompt_run_id === input.runId);
+      const startPosition = vorhandenesItem?.images.length ?? 0;
+      const neueBilder = input.images.map((bild, offset) => ({
+        media_ref: `${input.generationBatchId}-${startPosition + offset}`,
+        position: startPosition + offset,
+        model: bild.model ?? null,
+        seed: bild.seed ?? null,
+        width: bild.width ?? null,
+        height: bild.height ?? null
+      }));
+      const neu = {
+        item_id: vorhandenesItem?.item_id ?? `szn-mem-batch-${input.generationBatchId}`,
+        prompt_run_id: input.runId,
+        generation_batch_ids: [
+          ...vorhandenesItem?.generation_batch_ids ?? [],
+          input.generationBatchId
+        ],
+        source_kind: vorhandenesItem?.source_kind ?? "external_import",
+        title: vorhandenesItem?.title ?? input.title ?? `Batch aus Lauf ${input.runId}`,
+        images: [...vorhandenesItem?.images ?? [], ...neueBilder]
+      };
+      if (vorhandenesItem) {
+        batches.splice(batches.indexOf(vorhandenesItem), 1, neu);
+      } else {
+        batches.push(neu);
+      }
+      for (const bild of neueBilder) {
+        bilder.set(bild.media_ref, {
+          bild: { mediaRef: bild.media_ref, title: neu.title, mimeType: "image/png", thumbUrl: null },
+          data: "AAAA"
+        });
+      }
+      return done(neu);
+    },
+    async attachLibraryItem(input) {
+      const gefunden = batches.find((b) => b.item_id === input.itemId);
+      if (!gefunden) {
+        return { kind: "error", message: `Item ${input.itemId} ist unbekannt.`, retryable: false };
+      }
+      if (gefunden.prompt_run_id !== input.runId) {
+        return {
+          kind: "conflict",
+          message: `Item ${input.itemId} geh\xF6rt bereits zu Lauf ${gefunden.prompt_run_id}.`,
+          existingPromptRunId: gefunden.prompt_run_id
+        };
+      }
+      return { kind: "ok", value: gefunden };
+    }
+  };
+  const simulierterBildProvider = {
+    async generate(input) {
+      const bilder2 = Array.from({ length: input.imageCount }, (_, position) => ({
+        imageBase64: "AAAA",
+        seed: input.seeds?.[position],
+        model: `simulation:${input.callableModelId}`
+      }));
+      return { images: bilder2 };
+    }
+  };
+  const imageGenerationPort = createImageGenerationPort({
+    runs: { async getRun(runId) {
+      return runs.getRun(runId);
+    } },
+    provider: options.imageProvider ?? simulierterBildProvider,
+    batches: {
+      async persist(input) {
+        const vorhandenesItem = batches.find((b) => b.prompt_run_id === input.runId);
+        const startPosition = vorhandenesItem?.images.length ?? 0;
+        const neueBilder = input.images.map((bild, offset) => ({
+          media_ref: `${input.generationBatchId}-${startPosition + offset}`,
+          position: startPosition + offset,
+          model: bild.model ?? null,
+          seed: bild.seed ?? null,
+          width: bild.width ?? null,
+          height: bild.height ?? null
+        }));
+        const neu = {
+          item_id: vorhandenesItem?.item_id ?? `szn-mem-gen-${input.generationBatchId}`,
+          prompt_run_id: input.runId,
+          generation_batch_ids: [
+            ...vorhandenesItem?.generation_batch_ids ?? [],
+            input.generationBatchId
+          ],
+          source_kind: "generated_in_app",
+          title: vorhandenesItem?.title ?? `Batch aus Lauf ${input.runId}`,
+          images: [...vorhandenesItem?.images ?? [], ...neueBilder]
+        };
+        if (vorhandenesItem) {
+          batches.splice(batches.indexOf(vorhandenesItem), 1, neu);
+        } else {
+          batches.push(neu);
+        }
+        for (const bild of neueBilder) {
+          bilder.set(bild.media_ref, {
+            bild: { mediaRef: bild.media_ref, title: neu.title, mimeType: "image/png", thumbUrl: null },
+            data: "AAAA"
+          });
+        }
+        return done(neu);
+      }
+    },
+    events: { async appendEvent(type, payload) {
+      await imageGenerationEvents.appendEvent(type, payload);
+    } },
+    hasAccess: options.imageProviderHasAccess ?? (() => true)
+  });
+  const port = {
+    elements,
+    context: {
+      // Ein Host ohne Kontextgraph liefert `[eigener, null]` — das ist dort
+      // nicht die verkürzte Vererbung, sondern die vollständige.
+      async chainFor(contextId) {
+        return ok(contextId === null ? [null] : [contextId, null]);
+      }
+    },
+    runs
+  };
+  if (options.items !== false) port.items = itemPort;
+  if (options.media !== false) port.media = mediaPort;
+  if (options.imageLibrary !== false) port.imageLibrary = imageLibraryPort;
+  if (options.derivation !== false) port.derivation = derivationPort;
+  if (options.imageBatchHistory !== false) port.imageBatchHistory = imageBatchHistoryPort;
+  if (options.imageBatchWrite !== false) port.imageBatchWrite = imageBatchWritePort;
+  if (options.imageGeneration !== false) port.imageGeneration = imageGenerationPort;
+  return port;
+}
+
+// src/lib/szenen/browserTextGenerationPort.ts
+var DEFAULT_MODEL = "gemini-2.5-flash";
+var PROVIDER = "google";
+var ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models";
+function createBrowserTextGenerationPort(options = {}) {
+  const modelId = options.modelId ?? DEFAULT_MODEL;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  return {
+    async generate(request) {
+      if (typeof fetchImpl !== "function") {
+        throw new Error(
+          "Browser-Textport: kein fetch verfuegbar. Der Host muss eines mitgeben."
+        );
+      }
+      const parts = [{ text: request.prompt }];
+      for (const image of request.images ?? []) {
+        if (!image || typeof image.data !== "string" || typeof image.mime_type !== "string") {
+          throw new Error("Bild ohne Daten oder ohne mime_type \u2014 der Typ wird nicht geraten.");
+        }
+        parts.push({ inlineData: { mimeType: image.mime_type, data: image.data } });
+      }
+      const body = {
+        systemInstruction: { parts: [{ text: request.systemInstruction }] },
+        contents: [{ role: "user", parts }],
+        generationConfig: {
+          ...request.responseFormat === "json" ? { responseMimeType: "application/json" } : {}
+        }
+      };
+      const basis = `${ENDPOINT}/${modelId}:generateContent`;
+      const url = options.apiKey ? `${basis}?key=${options.apiKey}` : basis;
+      let response;
+      try {
+        response = await fetchImpl(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+      } catch (e) {
+        throw new Error(
+          `Modellaufruf nicht moeglich (${modelId}): ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+      if (!response.ok) {
+        const text2 = await response.text().catch(() => "");
+        return {
+          kind: "failed",
+          class: "provider_error",
+          message: `Provider antwortete mit HTTP ${response.status} (${modelId}).`,
+          model_id: modelId,
+          provider: PROVIDER,
+          provider_detail: { status: response.status, body: text2.slice(0, 2e3) }
+        };
+      }
+      const data = await response.json();
+      const blockReason = data?.promptFeedback?.blockReason;
+      if (blockReason) {
+        return {
+          kind: "failed",
+          class: "safety_blocked",
+          message: `Der Provider hat die Anfrage blockiert: ${blockReason}.`,
+          model_id: modelId,
+          provider: PROVIDER,
+          provider_detail: data.promptFeedback
+        };
+      }
+      const candidate = data?.candidates?.[0];
+      if (!candidate) {
+        return {
+          kind: "failed",
+          class: "empty_content",
+          message: "Der Provider lieferte keinen Kandidaten zurueck.",
+          model_id: modelId,
+          provider: PROVIDER,
+          provider_detail: data
+        };
+      }
+      const finishReason = candidate.finishReason;
+      if (finishReason && finishReason !== "STOP") {
+        return {
+          kind: "failed",
+          class: finishReason === "SAFETY" ? "safety_blocked" : "finish_reason",
+          message: `Der Lauf endete mit finishReason "${finishReason}".`,
+          model_id: modelId,
+          provider: PROVIDER,
+          provider_detail: { finishReason, safetyRatings: candidate.safetyRatings }
+        };
+      }
+      const text = (candidate.content?.parts ?? []).map((part) => part.text ?? "").join("").trim();
+      if (!text) {
+        return {
+          kind: "failed",
+          class: "empty_content",
+          message: "Der Provider lieferte einen leeren Text zurueck.",
+          model_id: modelId,
+          provider: PROVIDER,
+          provider_detail: candidate
+        };
+      }
+      return { kind: "ok", text, model_id: modelId, provider: PROVIDER };
+    }
+  };
+}
+
+// src/lib/szenen/runIntegrity.ts
+var FAILURE_CLASSES = [
+  "response_parse",
+  "response_schema",
+  "safety_blocked",
+  "finish_reason",
+  "empty_content",
+  "provider_error"
+];
+var PFLICHTFELDER = [
+  "run_id",
+  "shot_version_id",
+  "shot_element_id",
+  "scene_setup_version_id",
+  "camera_id",
+  "target_model_version_id",
+  "provider",
+  "model_id",
+  "system_prompt",
+  "created_at"
+];
+function istText2(wert) {
+  return typeof wert === "string" && wert.trim().length > 0;
+}
+function isObject2(wert) {
+  return typeof wert === "object" && wert !== null && !Array.isArray(wert);
+}
+var VERSIONSFELDER = ["shot_version_id", "scene_setup_version_id"];
+var KETTEN_TYPEN = ["scene", "scene_setup", "shot"];
+function pruefeLaufherkunft(quelle) {
+  if (!isObject2(quelle)) {
+    return { ok: false, message: '"source" muss ein Objekt sein.' };
+  }
+  if (quelle.kind === "published") {
+    for (const feld of VERSIONSFELDER) {
+      if (!istText2(quelle[feld])) {
+        return { ok: false, message: `"source.${feld}" fehlt oder ist leer.` };
+      }
+    }
+    return { ok: true };
+  }
+  if (quelle.kind !== "draft_chain") {
+    return {
+      ok: false,
+      message: `"source.kind" ist unbekannt: ${JSON.stringify(quelle.kind)}. Erlaubt: published, draft_chain.`
+    };
+  }
+  if (!istText2(quelle.chain_id)) {
+    return { ok: false, message: '"source.chain_id" fehlt oder ist leer.' };
+  }
+  if (!Array.isArray(quelle.nodes) || quelle.nodes.length === 0) {
+    return {
+      ok: false,
+      message: '"source.nodes" fehlt oder ist leer. Ohne Knoten waere nicht nachvollziehbar, welche Entwuerfe eingefroren wurden (G21).'
+    };
+  }
+  for (const [index, knoten] of quelle.nodes.entries()) {
+    if (!isObject2(knoten)) {
+      return { ok: false, message: `"source.nodes[${index}]" ist kein Objekt.` };
+    }
+    if (!KETTEN_TYPEN.includes(knoten.type)) {
+      return {
+        ok: false,
+        message: `"source.nodes[${index}].type" ist unbekannt: ${JSON.stringify(knoten.type)}.`
+      };
+    }
+    if (!istText2(knoten.element_id) || !istText2(knoten.draft_id)) {
+      return {
+        ok: false,
+        message: `"source.nodes[${index}]" braucht element_id und draft_id.`
+      };
+    }
+    if (typeof knoten.revision !== "number" || !Number.isInteger(knoten.revision)) {
+      return {
+        ok: false,
+        message: `"source.nodes[${index}].revision" muss eine ganze Zahl sein \u2014 ohne sie ist der eingefrorene Stand nicht benennbar (D-97).`
+      };
+    }
+  }
+  if (quelle.derivation_run_id !== void 0 && !istText2(quelle.derivation_run_id)) {
+    return { ok: false, message: '"source.derivation_run_id" ist gesetzt, aber leer.' };
+  }
+  if (quelle.derivation_recovery_id !== void 0 && !istText2(quelle.derivation_recovery_id)) {
+    return { ok: false, message: '"source.derivation_recovery_id" ist gesetzt, aber leer.' };
+  }
+  return { ok: true };
+}
+function checkPromptRunRecord(candidate) {
+  if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return {
+      ok: false,
+      message: `Ein Lauf muss ein Objekt sein, angekommen ist ${Array.isArray(candidate) ? "ein Array" : typeof candidate}.`
+    };
+  }
+  const record = candidate;
+  const quelle = record.source;
+  const ausKette = isObject2(quelle) && quelle.kind === "draft_chain";
+  if (quelle !== void 0) {
+    const urteil2 = pruefeLaufherkunft(quelle);
+    if (!urteil2.ok) return urteil2;
+  }
+  const pflicht = ausKette ? PFLICHTFELDER.filter((f) => !VERSIONSFELDER.includes(f)) : PFLICHTFELDER;
+  for (const feld of pflicht) {
+    if (!istText2(record[feld])) {
+      return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
+    }
+  }
+  if (ausKette) {
+    for (const feld of VERSIONSFELDER) {
+      if (istText2(record[feld])) {
+        return {
+          ok: false,
+          message: `"${feld}" ist bei einem Lauf aus einer Draft-Kette gesetzt. Dort gibt es keine Versionen, und erfundene sind unzulaessig (D-98).`
+        };
+      }
+    }
+  }
+  if (record.status !== "succeeded" && record.status !== "failed") {
+    return {
+      ok: false,
+      message: `"status" muss succeeded oder failed sein, angekommen ist ${JSON.stringify(record.status)}.`
+    };
+  }
+  const eingabe = record.input_payload;
+  if (eingabe === null || typeof eingabe !== "object") {
+    return { ok: false, message: '"input_payload" fehlt \u2014 ohne sie ist der Lauf nicht pruefbar.' };
+  }
+  if (record.status === "failed") {
+    if (record.output !== null && record.output !== void 0) {
+      return {
+        ok: false,
+        message: 'Ein gescheiterter Lauf traegt kein "output" \u2014 er hat keines erzeugt.'
+      };
+    }
+    const failure = record.failure;
+    if (!failure || typeof failure !== "object") {
+      return {
+        ok: false,
+        message: 'Ein gescheiterter Lauf braucht ein "failure" \u2014 der Grund ist der Beleg.'
+      };
+    }
+    if (!FAILURE_CLASSES.includes(failure.class)) {
+      return {
+        ok: false,
+        message: `"failure.class" ist unbekannt: ${JSON.stringify(failure.class)}. Erlaubt sind ${FAILURE_CLASSES.join(", ")}.`
+      };
+    }
+    if (!istText2(failure.message)) {
+      return { ok: false, message: '"failure.message" fehlt oder ist leer.' };
+    }
+    return { ok: true };
+  }
+  if (record.failure !== null && record.failure !== void 0) {
+    return {
+      ok: false,
+      message: 'Ein erfolgreicher Lauf traegt kein "failure".'
+    };
+  }
+  if (!record.output || typeof record.output !== "object") {
+    return {
+      ok: false,
+      message: 'Ein erfolgreicher Lauf braucht ein "output" \u2014 sonst belegt er nichts.'
+    };
+  }
+  const urteil = checkRunResponse(record.output, eingabe);
+  if (!urteil.ok) {
+    return { ok: false, message: `Das Ergebnis passt nicht zur Eingabe: ${urteil.message}` };
+  }
+  return { ok: true };
+}
+var INPUT_MODES = ["prompt", "image", "image_prompt"];
+var DERIVATION_PFLICHTFELDER = [
+  "run_id",
+  "policy_version_id",
+  "policy_element_id",
+  "provider",
+  "model_id",
+  "system_prompt",
+  "created_at"
+];
+function checkSceneDerivationRecord(candidate) {
+  if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return {
+      ok: false,
+      message: `Ein Lauf muss ein Objekt sein, angekommen ist ${Array.isArray(candidate) ? "ein Array" : typeof candidate}.`
+    };
+  }
+  const record = candidate;
+  for (const feld of DERIVATION_PFLICHTFELDER) {
+    if (!istText2(record[feld])) {
+      return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
+    }
+  }
+  if (record.context_id !== null && typeof record.context_id !== "string") {
+    return {
+      ok: false,
+      message: '"context_id" muss eine Zeichenkette oder null sein \u2014 er bestimmt, wo uebernommene Entwuerfe landen.'
+    };
+  }
+  if (record.status !== "succeeded" && record.status !== "failed") {
+    return {
+      ok: false,
+      message: `"status" muss succeeded oder failed sein, angekommen ist ${JSON.stringify(record.status)}.`
+    };
+  }
+  const eingabe = record.input;
+  if (!eingabe || typeof eingabe !== "object") {
+    return { ok: false, message: '"input" fehlt \u2014 ohne sie ist der Lauf nicht nachvollziehbar.' };
+  }
+  if (!INPUT_MODES.includes(eingabe.mode)) {
+    return {
+      ok: false,
+      message: `"input.mode" ist unbekannt: ${JSON.stringify(eingabe.mode)}. Erlaubt sind ${INPUT_MODES.join(", ")}.`
+    };
+  }
+  if (eingabe.prompt_text !== null && typeof eingabe.prompt_text !== "string") {
+    return { ok: false, message: '"input.prompt_text" muss eine Zeichenkette oder null sein.' };
+  }
+  if (!Array.isArray(eingabe.images)) {
+    return { ok: false, message: '"input.images" muss eine Liste sein, auch eine leere.' };
+  }
+  for (const [index, bild] of eingabe.images.entries()) {
+    if (!bild || typeof bild !== "object") {
+      return { ok: false, message: `"input.images[${index}]" ist keine Herkunftsangabe.` };
+    }
+    if (typeof bild.mime_type !== "string") {
+      return {
+        ok: false,
+        message: `"input.images[${index}].mime_type" fehlt \u2014 der Typ wird nicht geraten.`
+      };
+    }
+    if ("data" in bild) {
+      return {
+        ok: false,
+        message: `"input.images[${index}]" traegt Bilddaten. Eingefroren wird die Herkunft, nicht das Bild (D-73).`
+      };
+    }
+  }
+  const folgt = record.follows;
+  if (folgt !== void 0) {
+    if (!folgt || typeof folgt !== "object" || Array.isArray(folgt)) {
+      return { ok: false, message: '"follows" muss ein Objekt sein.' };
+    }
+    const f = folgt;
+    if (!istText2(f.run_id)) {
+      return { ok: false, message: '"follows.run_id" fehlt oder ist leer.' };
+    }
+    if (f.run_id === record.run_id) {
+      return { ok: false, message: '"follows.run_id" zeigt auf den Lauf selbst.' };
+    }
+    if (!istText2(f.note)) {
+      return {
+        ok: false,
+        message: '"follows.note" fehlt oder ist leer \u2014 ohne Beanstandung ist ein Folgelauf nicht nachvollziehbar (D-89).'
+      };
+    }
+    if (f.user_instruction !== null && typeof f.user_instruction !== "string") {
+      return {
+        ok: false,
+        message: '"follows.user_instruction" muss eine Zeichenkette oder null sein.'
+      };
+    }
+  }
+  const reply = record.reply;
+  if (reply !== void 0 && !istText2(reply)) {
+    return {
+      ok: false,
+      message: `"reply" ist unbrauchbar: erwartet wird eine nicht leere Zeichenkette, angekommen ist ${JSON.stringify(reply)}. Ohne "reply" einreichen ist zulaessig.`
+    };
+  }
+  if (record.status === "failed") {
+    const failure = record.failure;
+    if (!failure || typeof failure !== "object") {
+      return {
+        ok: false,
+        message: 'Ein gescheiterter Lauf braucht ein "failure" \u2014 der Grund ist der Beleg.'
+      };
+    }
+    if (!FAILURE_CLASSES.includes(failure.class)) {
+      return {
+        ok: false,
+        message: `"failure.class" ist unbekannt: ${JSON.stringify(failure.class)}. Erlaubt sind ${FAILURE_CLASSES.join(", ")}.`
+      };
+    }
+    if (!istText2(failure.message)) {
+      return { ok: false, message: '"failure.message" fehlt oder ist leer.' };
+    }
+    if (Array.isArray(record.proposals) && record.proposals.length > 0) {
+      return {
+        ok: false,
+        message: 'Ein gescheiterter Lauf traegt keine "proposals" \u2014 er hat keine erzeugt.'
+      };
+    }
+    return { ok: true };
+  }
+  if (record.failure !== null && record.failure !== void 0) {
+    return { ok: false, message: 'Ein erfolgreicher Lauf traegt kein "failure".' };
+  }
+  if (!Array.isArray(record.proposals)) {
+    return { ok: false, message: '"proposals" muss eine Liste sein, auch eine leere.' };
+  }
+  for (const [index, vorschlag] of record.proposals.entries()) {
+    if (!vorschlag || typeof vorschlag !== "object") {
+      return { ok: false, message: `"proposals[${index}]" ist kein Vorschlag.` };
+    }
+    const typ = vorschlag.type;
+    if (!DERIVABLE_TYPES.includes(typ)) {
+      return {
+        ok: false,
+        message: `"proposals[${index}].type" ist ${JSON.stringify(typ)} \u2014 erlaubt sind ${DERIVABLE_TYPES.join(", ")}.`
+      };
+    }
+    const payload = vorschlag.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+      return { ok: false, message: `"proposals[${index}].payload" fehlt oder ist kein Objekt.` };
+    }
+    const titel = vorschlag.title;
+    if (titel !== void 0 && acceptProposalTitle(titel) === null) {
+      return {
+        ok: false,
+        message: `"proposals[${index}].title" ist unbrauchbar: erwartet wird eine nicht leere einzeilige Zeichenkette mit hoechstens ${MAX_PROPOSAL_TITLE_LENGTH} Zeichen, angekommen ist ${JSON.stringify(titel)}. Ohne Titel einreichen ist zulaessig (D-83).`
+      };
+    }
+    const status = vorschlag.status;
+    if (status !== void 0 && status !== "complete" && status !== "partial") {
+      return {
+        ok: false,
+        message: `"proposals[${index}].status" ist ${JSON.stringify(status)} \u2014 erlaubt sind complete und partial (D-82).`
+      };
+    }
+    const gaps = vorschlag.gaps;
+    if (status === "partial") {
+      if (!Array.isArray(gaps) || gaps.length === 0) {
+        return {
+          ok: false,
+          message: `"proposals[${index}]" ist partial, nennt aber keine gaps. Ein unvollstaendiger Vorschlag ohne benannte Luecken ist nicht uebernehmbar (D-82).`
+        };
+      }
+      for (const [gapIndex, luecke] of gaps.entries()) {
+        if (!luecke || typeof luecke !== "object" || !istText2(luecke.pointer) || !istText2(luecke.reason)) {
+          return {
+            ok: false,
+            message: `"proposals[${index}].gaps[${gapIndex}]" braucht pointer und reason.`
+          };
+        }
+      }
+    }
+    if (status !== "partial" && Array.isArray(gaps) && gaps.length > 0) {
+      return {
+        ok: false,
+        message: `"proposals[${index}]" nennt gaps, ist aber nicht partial (D-82).`
+      };
+    }
+  }
+  return { ok: true };
+}
+function checkSceneDerivationRecoveryRecord(candidate) {
+  if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return {
+      ok: false,
+      message: `Eine Arbeitsfassung muss ein Objekt sein, angekommen ist ${Array.isArray(candidate) ? "ein Array" : typeof candidate}.`
+    };
+  }
+  const record = candidate;
+  for (const feld of ["recovery_id", "run_id", "created_at"]) {
+    if (!istText2(record[feld])) {
+      return { ok: false, message: `"${feld}" fehlt oder ist leer.` };
+    }
+  }
+  if (typeof record.source_text !== "string") {
+    return {
+      ok: false,
+      message: '"source_text" fehlt \u2014 ohne ihn ist die Arbeitsfassung nicht nachvollziehbar.'
+    };
+  }
+  if (typeof record.edited !== "boolean") {
+    return {
+      ok: false,
+      message: '"edited" muss true oder false sein \u2014 ob der Text bearbeitet wurde, darf nicht offenbleiben (D-99).'
+    };
+  }
+  const RECOVERY_STATUS = ["usable", "partial", "invalid"];
+  if (!RECOVERY_STATUS.includes(record.status)) {
+    return {
+      ok: false,
+      message: `"status" muss usable, partial oder invalid sein, angekommen ist ${JSON.stringify(record.status)}.`
+    };
+  }
+  if (!Array.isArray(record.diagnostics)) {
+    return { ok: false, message: '"diagnostics" muss ein Array sein (auch ein leeres).' };
+  }
+  for (const [index, befund] of record.diagnostics.entries()) {
+    if (!befund || typeof befund !== "object" || !istText2(befund.code) || !istText2(befund.message)) {
+      return {
+        ok: false,
+        message: `"diagnostics[${index}]" braucht code und message.`
+      };
+    }
+    const schwere = befund.severity;
+    if (schwere !== "error" && schwere !== "warning") {
+      return {
+        ok: false,
+        message: `"diagnostics[${index}].severity" muss error oder warning sein.`
+      };
+    }
+  }
+  if (!Array.isArray(record.proposals)) {
+    return { ok: false, message: '"proposals" muss ein Array sein (auch ein leeres).' };
+  }
+  for (const [index, vorschlag] of record.proposals.entries()) {
+    if (!vorschlag || typeof vorschlag !== "object") {
+      return { ok: false, message: `"proposals[${index}]" ist kein Objekt.` };
+    }
+    const p = vorschlag;
+    if (!DERIVABLE_TYPES.includes(p.type)) {
+      return {
+        ok: false,
+        message: `"proposals[${index}].type" ist unbekannt: ${JSON.stringify(p.type)}.`
+      };
+    }
+    if (!p.payload || typeof p.payload !== "object" || Array.isArray(p.payload)) {
+      return { ok: false, message: `"proposals[${index}].payload" fehlt oder ist kein Objekt.` };
+    }
+    if (p.status !== "complete" && p.status !== "partial") {
+      return {
+        ok: false,
+        message: `"proposals[${index}].status" muss complete oder partial sein. Anders als bei einem Lauf von vor D-82 gibt es hier keine Altfaelle.`
+      };
+    }
+    const gaps = p.gaps;
+    if (p.status === "partial" && (!Array.isArray(gaps) || gaps.length === 0)) {
+      return {
+        ok: false,
+        message: `"proposals[${index}]" ist partial, nennt aber keine gaps (D-82).`
+      };
+    }
+    if (p.status !== "partial" && Array.isArray(gaps) && gaps.length > 0) {
+      return {
+        ok: false,
+        message: `"proposals[${index}]" nennt gaps, ist aber nicht partial (D-82).`
+      };
+    }
+    if (Array.isArray(gaps)) {
+      for (const [gapIndex, luecke] of gaps.entries()) {
+        if (!luecke || typeof luecke !== "object" || !istText2(luecke.pointer) || !istText2(luecke.reason)) {
+          return {
+            ok: false,
+            message: `"proposals[${index}].gaps[${gapIndex}]" braucht pointer und reason.`
+          };
+        }
+      }
+    }
+    if (p.title !== void 0 && acceptProposalTitle(p.title) === null) {
+      return {
+        ok: false,
+        message: `"proposals[${index}].title" ist unbrauchbar \u2014 leer, kein Text oder laenger als ${MAX_PROPOSAL_TITLE_LENGTH} Zeichen.`
+      };
+    }
+  }
+  if (record.status === "invalid" && record.proposals.length > 0) {
+    return {
+      ok: false,
+      message: '"status" ist invalid, es stehen aber Vorschlaege im Datensatz. Entweder ist etwas verwertbar oder nicht.'
+    };
+  }
+  if (record.status !== "invalid" && record.proposals.length === 0) {
+    return {
+      ok: false,
+      message: `"status" ist ${record.status}, es steht aber kein Vorschlag im Datensatz.`
+    };
+  }
+  if (record.status === "usable" && record.diagnostics.some((d) => d.severity === "error")) {
+    return {
+      ok: false,
+      message: '"status" ist usable, es stehen aber Fehlerbefunde im Datensatz. Vertragstreu und fehlerhaft zugleich gibt es nicht.'
+    };
+  }
+  return { ok: true };
+}
+export {
+  ALL_PUBLISH_RULES,
+  CATALOGUE_TYPES,
+  CHAIN_EDGES,
+  CHAIN_LINK_FIELDS,
+  CapabilityAnchorError,
+  ContractViolation,
+  DERIVABLE_TYPES,
+  ELEMENT_VERSION_SCHEMA_FILE,
+  PROBE_VERSION_ID,
+  REFERENCE_FIELD,
+  RULES_WITHOUT_CAPABILITY_EFFECT,
+  RULE_SCOPES,
+  ResolveTechnicalError,
+  SIMULATION_PROVIDER,
+  STYLE_PAYLOAD,
+  STYLE_PAYLOAD_V2,
+  SZENEN_ELEMENT_TYPES,
+  SZENEN_EVENT_PREFIX,
+  SZENEN_EVENT_TYPES,
+  SZENEN_ITEM_PREFIX,
+  SZENEN_SCHEMAS,
+  SzenenView,
+  UNCHECKED_PUBLISH_RULES,
+  UnsupportedSchemaError,
+  VersionDagError,
+  areasFor,
+  assessDerivationResponse,
+  buildSystemInstruction as buildDerivationSystemInstruction,
+  buildUserPrompt as buildDerivationUserPrompt,
+  buildSystemInstruction2 as buildSystemInstruction,
+  buildUserPrompt2 as buildUserPrompt,
+  buildVersionDag,
+  callOptional,
+  callableImageModelFor,
+  capabilitiesOf,
+  capabilityForTargetModel,
+  capabilityGate,
+  capabilityReport,
+  catalogueFor,
+  checkChainTargets,
+  checkCreateElementInput,
+  checkDerivationResponse,
+  checkDraftChainMeta,
+  checkElementType,
+  checkOptionalId,
+  checkParents,
+  checkPayloadPresent,
+  checkPromptRunRecord,
+  checkPublishVersionInput,
+  checkRequiredId,
+  checkReviseMetadataInput,
+  checkRevision,
+  checkRunResponse,
+  checkSceneDerivationRecord,
+  checkSceneDerivationRecoveryRecord,
+  checkSetPreferredHeadInput,
+  checkSzenenBatchOrigin,
+  checkTitle,
+  checkWriteDraftInput,
+  collectImageGenerationOrders,
+  collectPromptRuns,
+  collectProviderChecks,
+  collectSceneDerivationRecoveries,
+  collectSceneDerivations,
+  collectVersionRefs,
+  compileSchemas,
+  createBrowserTextGenerationPort,
+  createClientDerivationPort,
+  createClientRunPort,
+  createEventLogDerivationPersistence,
+  createEventLogRunPersistence,
+  createFakeTextGenerationPort,
+  createFlowSzenenViewPort,
+  createFlowTextGenerationPort,
+  createHfElementStore,
+  createHfEventChannel,
+  createHfImageLibrary,
+  createImageGenerationPort,
+  createInMemoryEventChannel,
+  createMemoryViewPort,
+  createSimulationSceneDerivationPort,
+  createSimulationTextGenerationPort,
+  derivationPoliciesOf,
+  deriveItemFromRun,
+  deriveLineage,
+  describeTargetModelFailure,
+  differentialSteps,
+  draftRevisionOf,
+  elementStoreContractChecks,
+  findImageGenerationOrder,
+  findPromptRun,
+  findProviderCheck,
+  findSceneDerivation,
+  findSceneDerivationRecovery,
+  firstError,
+  formatSchemaErrors,
+  freezeDraftChain,
+  getSzenenSchemas,
+  hasPlacementCapability,
+  isKnownElementType,
+  isOk,
+  isProjectionCurrent,
+  isSzenenItemId,
+  itemIdForRun,
+  linkFor,
+  logRevisionOf,
+  mergeSzenenBatchOrigin,
+  noticeFor,
+  ordersForPromptRun,
+  parseDerivationResponse,
+  parseRunResponse,
+  preferredHeadRevisionOf,
+  preferredVersionId,
+  publishedHeadsOf,
+  recoveriesForRun,
+  recoveryStatusOf,
+  reduceElementEvents,
+  resolveArea,
+  resolvePreferredHead,
+  resolveShot,
+  resolveShotPayload,
+  resolveTargetModelOver,
+  resolverFromQueries,
+  roundOfRun,
+  runElementStoreContract,
+  runPromptDerivation,
+  runPublishChecks,
+  runSceneDerivation,
+  runStoreDifferential,
+  scopeOfPath,
+  showChain,
+  simulatedAnswerFor,
+  totalModelCalls,
+  unclassifiedPublishRules,
+  unsupportedReason,
+  validateAgainst,
+  validateDerivationInput,
+  validateElementVersion,
+  validatePayload,
+  withReference
+};