@rslsp1/fa-app-tools 2.0.73 → 2.0.81

package/dist/szenen.d.mts

@@ -0,0 +1,2747 @@
+import { ac as SchemaError, Z as PublishFinding, Y as PublishCheckResult, aj as SzenenElementType, a2 as ReferenceResolver, ap as TargetModelResolution, I as ElementSnapshot, w as DerivationInputMode, M as ImageProvenance, s as DerivationFailure, n as DerivableType, N as NotDerivable, p as DerivationConflict, u as DerivationFollowUp, B as DraftChainMeta, q as DerivationDiagnostic, o as DerivationAssessment, h as ContextChainPort, a as AuthoritativeSzenenStore, ai as SzenenElementStore, v as DerivationImage, al as SzenenQueries, ah as SzenenCommands, ar as UnusableProposal } from './storeContract-B2BDgvhN.mjs';
+export { A as ALL_PUBLISH_RULES, C as CHAIN_EDGES, b as CHAIN_LINK_FIELDS, c as CatalogueEntry, d as ChainLinkField, e as ChainTarget, f as ChainVerdict, g as CompiledSchemas, i as ContractCheck, j as ContractCheckResult, k as ContractRunResult, l as ContractViolation, m as CreateElementInput, D as DERIVABLE_TYPES, r as DerivationEnvelope, t as DerivationFailureClass, x as DerivationPolicyPayload, y as DerivationProposal, z as DraftChainLink, E as DraftFork, F as DraftRecord, G as ElementMetadata, H as ElementRecord, J as ElementStoreContractHarness, K as ElementVersionValidation, L as FindingSeverity, O as OptionalCommand, P as PROBE_VERSION_ID, Q as ParentRelation, R as PreferredHeadOutcome, S as PreferredHeadResolution, T as PreferredHeadSelection, U as PreferredHeadSource, V as ProjectionState, W as ProjectionStatus, X as PublishCheckInput, _ as PublishRejected, $ as PublishVersionInput, a0 as PublishedVersion, a1 as REFERENCE_FIELD, a3 as ResolvePreferredHeadOptions, a4 as ResolvedVersion, a5 as ReviseMetadataInput, a6 as STYLE_PAYLOAD, a7 as STYLE_PAYLOAD_V2, a8 as SZENEN_ELEMENT_TYPES, a9 as SceneDerivationInput, aa as SceneDerivationOutcome, ab as SceneDerivationOutput, ad as SchemaValidationResult, ae as SetPreferredHeadInput, af as StoreAuthority, ag as SzenenCommandResult, ak as SzenenProjection, am as TargetModelCandidate, an as TargetModelQueries, ao as TargetModelQuery, aq as UnsupportedSchemaError, as as VersionDag, at as VersionDagError, au as VersionNode, av as VersionParentLink, aw as WriteConflict, ax as WriteDraftInput, ay as assessDerivationResponse, az as buildDerivationSystemInstruction, aA as buildDerivationUserPrompt, aB as buildVersionDag, aC as checkChainTargets, aD as checkDerivationResponse, aE as checkDraftChainMeta, aF as collectVersionRefs, aG as compileSchemas, aH as createSimulationSceneDerivationPort, aI as describeTargetModelFailure, aJ as elementStoreContractChecks, aK as formatSchemaErrors, aL as getSzenenSchemas, aM as isOk, aN as isProjectionCurrent, aO as linkFor, aP as parseDerivationResponse, aQ as preferredVersionId, aR as resolvePreferredHead, aS as resolveTargetModelOver, aT as resolverFromQueries, aU as runElementStoreContract, aV as runPublishChecks, aW as runSceneDerivation, aX as showChain, aY as validateAgainst, aZ as validateDerivationInput, a_ as validateElementVersion, a$ as validatePayload, b0 as withReference } from './storeContract-B2BDgvhN.mjs';
+import { T as TextGenerationPort, Q as QueryResult, C as CommandResult } from './contracts-DdYOMBl9.mjs';
+export { S as SIMULATION_PROVIDER, c as TextGenerationRequest, d as TextGenerationResult, g as createFakeTextGenerationPort, h as createSimulationTextGenerationPort, s as simulatedAnswerFor } from './contracts-DdYOMBl9.mjs';
+import { F as FlowGenerateText } from './flowTextGenerationPort-CeDUFutP.mjs';
+export { C as CreateFlowTextGenerationPortOptions, i as createFlowTextGenerationPort } from './flowTextGenerationPort-CeDUFutP.mjs';
+import React__default from 'react';
+
+/** Rohes JSON-Schema, wie es in der Spezifikation steht. */
+type RawSchema = Record<string, unknown>;
+/** Alle Typschemas der Domain, geschluesselt nach Dateiname wie in der Quelle. */
+declare const SZENEN_SCHEMAS: Readonly<Record<string, RawSchema>>;
+/** Dateiname des Umschlagschemas — Einstieg jeder Validierung. */
+declare const ELEMENT_VERSION_SCHEMA_FILE = "element-version.schema.json";
+
+/**
+ * Ist dieses Scene Setup platzierbar?
+ *
+ * Genau dann, wenn es ein `coordinate_system` trägt (D-65). Die frühere
+ * Fassung in `domain-model.md` §9 verlangte „strukturierte Positionen in
+ * `placements[]` **oder belastbare relative Constraints**" — nicht
+ * entscheidbar, weil „belastbar" kein Prädikat ist.
+ *
+ * **Rein lokal:** liest ein Feld der übergebenen Payload und braucht keinen
+ * Speicherzugriff. Deshalb lässt sich `can_place` auch ohne `ReferenceResolver`
+ * widerlegen — der Fähigkeitsbericht nutzt genau das.
+ *
+ * **Vertrag: die Payload muss bereits schemavalidiert sein.** Die Funktion
+ * prüft nur auf Anwesenheit, nicht auf den erlaubten Wert — `coordinate_system:
+ * 123` gälte hier als platzierbar, ist nach dem Schema aber ungültig. Beide
+ * Aufrufer halten das ein: Im Publish-Pfad läuft die Schemaprüfung vor P-07,
+ * und `capabilityReport` validiert selbst, bevor es hierher kommt. Wer die
+ * Funktion neu aufruft, muss dasselbe tun.
+ */
+declare function hasPlacementCapability(setupPayload: unknown): boolean;
+
+/**
+ * Zustand einer Fähigkeit.
+ *
+ * `unknown` ist ein eigener Zustand und **kein** `false` (D-64). Ein
+ * `boolean | null` würde im Aufrufer zu `if (!flag)` und damit still zu „kann
+ * nicht" — die stille Falschaussage, die Grundsatzregel 5 verbietet.
+ */
+type CapabilityState = 'yes' | 'no' | 'unknown';
+/** Warum ein Flag nicht `yes` ist. Nie leer, solange `state !== 'yes'`. */
+type CapabilityReason = 
+/** Die Payload verletzt das Schema des Elementtyps. */
+{
+    kind: 'schema';
+    error: SchemaError;
+}
+/** Eine Publish-Regel blockiert. */
+ | {
+    kind: 'blocked';
+    finding: PublishFinding;
+}
+/** Eine zuständige Regel konnte nicht geprüft werden. */
+ | {
+    kind: 'unchecked';
+    rule: string;
+    reason: string;
+}
+/** Eine Strukturbedingung ist verletzt oder unbestimmt. */
+ | {
+    kind: 'structure';
+    message: string;
+}
+/** Das Flag erbt das Ergebnis von `can_describe_scene`. */
+ | {
+    kind: 'inherited';
+    from: 'can_describe_scene';
+    message: string;
+};
+interface CapabilityFlag {
+    state: CapabilityState;
+    reasons: readonly CapabilityReason[];
+}
+interface CapabilityReportInput {
+    /**
+     * Elementtyp der Payload. **Pflicht** — er ist aus einer nackten Payload
+     * nicht ableitbar: `type` steht im Umschlag (`element-version.schema.json`),
+     * nicht im Payload-Schema. `runPublishChecks` bekommt ihn aus demselben
+     * Grund explizit.
+     */
+    type: SzenenElementType;
+    /** Payload eines `scene_setup` — veröffentlicht oder Entwurf. */
+    setupPayload: unknown;
+    /** Element, zu dem die Payload gehört; die referenzabhängigen Regeln brauchen es. */
+    elementId: string;
+    /** Vorgänger im Versions-DAG; P-03 und P-10 werten sie aus. */
+    parents?: readonly {
+        parent_version_id: string;
+        relation: string;
+    }[];
+    /** Fehlt er, ist kein Flag besser als `unknown`. Kein stiller Fallback. */
+    resolver?: ReferenceResolver;
+    /**
+     * Die Szene, vorab aufgelöst — Stufe 6.6, C1 (D-96).
+     *
+     * Ohne dieses Feld holt der Bericht die Szene über `setupPayload.scene_ref`
+     * aus einer veröffentlichten Version; das ist der bisherige und unveränderte
+     * Weg.
+     *
+     * Mit diesem Feld kommt sie von außen: Ein Setup einer Draft-Kette trägt
+     * `scene_ref` bewusst nicht in seiner Payload, sondern führt den Verweis
+     * daneben. Der Bericht bekommt dieselbe Szene, nur über einen anderen Weg —
+     * und dieselbe fehlende Referenz wird dann auch in seiner Schemaprüfung
+     * nicht als Mangel gewertet.
+     *
+     * **Es bleibt bei einem Regelwerk** (D-64): Die Publish-Prüfungen laufen
+     * unverändert. Geändert hat sich nur, woher die Szene kommt.
+     */
+    chainScene?: unknown;
+}
+interface CapabilityReport {
+    can_describe_scene: CapabilityFlag;
+    can_render_prompt: CapabilityFlag;
+    can_place: CapabilityFlag;
+    /** Der zugrundeliegende Prüflauf, unverändert weitergereicht. */
+    checks: PublishCheckResult;
+    /**
+     * Schemafehler der Payload. Leer, wenn sie dem Typschema entspricht.
+     *
+     * Steht getrennt von `checks`, weil die Schemaprüfung **vor** den
+     * Publish-Regeln läuft und eine andere Frage beantwortet: nicht „hält dieser
+     * Stand die Modellregeln ein", sondern „ist das überhaupt ein Scene Setup".
+     */
+    schemaErrors: readonly SchemaError[];
+}
+/** Ein falscher Anker ist ein Aufruffehler, kein Befund. */
+declare class CapabilityAnchorError extends Error {
+}
+type CapabilityScope = 'scene' | 'camera_rig' | 'placement' | 'global';
+/**
+ * Welche Bereiche eine Regel beim Anker `scene_setup` abdeckt.
+ *
+ * **Positive Liste, und das ist der Kern.** `unchecked` vermischt drei
+ * Sachverhalte — nachweisbar an den Meldungstexten in `publishChecks.ts`:
+ *
+ *   „kein ReferenceResolver uebergeben"  → echt unbestimmt
+ *   „Regel gilt nur fuer shot"           → nicht anwendbar
+ *   „Laufzeitregel der Aufloesung"       → keine Veröffentlichungsbedingung
+ *
+ * Eine Abbildung `unchecked → unknown` machte den Bericht deshalb **dauerhaft**
+ * unbestimmt: P-01 und P-12 stehen bei jedem Setup-Lauf unter `unchecked`, auch
+ * mit vollständig funktionierendem Resolver. Nur was hier steht, wirkt.
+ *
+ * Eine Regel kann **mehrere** Bereiche abdecken: P-04 prüft die Szenenreferenz
+ * und die Preset-Referenzen, P-05 die Node-Referenzen in Overrides, Placements
+ * und Kamerafeldern. Ein einzelner Scope-Wert je Regel wäre zu grob.
+ */
+declare const RULE_SCOPES: Readonly<Record<string, readonly CapabilityScope[]>>;
+/**
+ * Regeln, die beim Anker `scene_setup` bewusst kein Flag beeinflussen —
+ * jede mit dem Grund, aus dem sie ausgenommen ist.
+ *
+ * Zusammen mit `RULE_SCOPES` deckt diese Liste `ALL_PUBLISH_RULES` vollständig
+ * ab; ein Test wacht darüber. P-17 aus Stufe 3 hat ihn genau so zum Scheitern
+ * gebracht, bis sie unten eingeordnet war — eine neue Regel kann nicht
+ * stillschweigend wirkungslos bleiben.
+ */
+declare const RULES_WITHOUT_CAPABILITY_EFFECT: Readonly<Record<string, string>>;
+/** Welcher Scope ein Befund betrifft — abgeleitet aus seinem JSON-Pointer. */
+declare function scopeOfPath(path: string): CapabilityScope;
+/**
+ * Fähigkeitsbericht zu einem Scene Setup.
+ *
+ * Reihenfolge der Auswertung je Flag (§7.5 der Spezifikation), erste
+ * zutreffende Regel gewinnt:
+ *
+ *   0. Schemafehler im Scope                   → `no`
+ *   1. lokaler blockierender Befund im Scope   → `no`
+ *   2. verletzte lokale Strukturbedingung      → `no`
+ *   3. geerbtes `no` aus can_describe_scene    → `no`
+ *   4. eigene Regel ungeprüft / unbestimmte
+ *      Struktur / geerbtes `unknown`           → `unknown`
+ *   5. sonst                                   → `yes`
+ *
+ * `no` schlägt `unknown`: Ein nachgewiesener Blocker bleibt einer, auch wenn
+ * daneben eine Regel ungeprüft blieb.
+ */
+declare function capabilityReport(input: CapabilityReportInput): Promise<CapabilityReport>;
+/**
+ * Regeln, die weder eingeordnet noch begründet ausgenommen sind.
+ *
+ * Der Vollständigkeitstest ruft das auf. Als Funktion und nicht als Konstante,
+ * damit er gegen `ALL_PUBLISH_RULES` läuft und nicht gegen eine Kopie davon.
+ */
+declare function unclassifiedPublishRules(): readonly string[];
+
+/** Ein Beitrag zur Beschreibung eines Knotens, mit Herkunft (D-50). */
+interface NodeContribution {
+    source: 'component' | 'node_semantic' | 'setup_override';
+    element_id: string | null;
+    version_id: string | null;
+    role: string | null;
+    rank: number;
+    locale: string | null;
+    text: string;
+}
+/** Ein Knoten der aufgelösten Szene. */
+interface ResolvedNode {
+    node_id: string;
+    type: string;
+    /** Additiv nach `rank`, nie vorgemischt (D-50). */
+    contributions: readonly NodeContribution[];
+    properties: Record<string, unknown>;
+    /** `null`, solange `can_place` nicht gilt — der Renderer erfindet keine Koordinaten. */
+    placement: ResolvedPlacement | null;
+    /** Vom Shot ausgeblendet (D-40). Der Knoten bleibt im Graphen (D-21). */
+    hidden: boolean;
+}
+interface ResolvedPlacement {
+    position: readonly number[];
+    rotation_euler_deg?: readonly number[];
+    scale?: readonly number[];
+}
+interface ResolvedCamera {
+    camera_id: string;
+    name: string | null;
+    preset: unknown;
+    placement: unknown;
+    orientation: unknown;
+    framing: unknown;
+    focus: unknown;
+    /** Aufgelöste Pattern-Version, falls die Platzierung eines benutzt. */
+    pattern: unknown | null;
+}
+/** Die Renderer-Eingabe nach `prompt-derivation.md` §3a. */
+interface RendererInput {
+    shot: {
+        version_id: string;
+        element_id: string;
+        camera_id: string;
+        shot_concept: unknown | null;
+        user_instruction: string | null;
+        text_override: string | null;
+    };
+    scene: {
+        version_id: string;
+        nodes: readonly ResolvedNode[];
+        relations: readonly unknown[];
+        environment: unknown | null;
+        unit_system: unknown | null;
+    };
+    camera: ResolvedCamera;
+    styles: readonly {
+        role: string;
+        rank: number;
+        weight: number | null;
+        text: string;
+        locale: string | null;
+    }[];
+    policies: readonly {
+        subtype: string;
+        rank: number;
+        text: string;
+        locale: string | null;
+    }[];
+    fragments: readonly {
+        channel: string;
+        rank: number;
+        text: string;
+        locale: string | null;
+    }[];
+    target_model: unknown;
+    /**
+     * Fälle, in denen die Zielsprache nicht verfügbar war (D-48).
+     *
+     * **In Stufe 3 immer leer.** `version_localizations` ist spezifiziert
+     * (`versioning-and-sync.md` §5), aber weder als Tabelle noch als
+     * Portoperation umgesetzt. Statt so zu tun, als hätte jemand nachgesehen,
+     * steht der Umstand als Annahme in `assumptions`.
+     */
+    localization_notes: readonly unknown[];
+    /** Annahmen, unter denen diese Eingabe entstanden ist. */
+    assumptions: readonly string[];
+    /** Die Fähigkeiten, die die Auflösung gesehen hat — eingefroren (D-22). */
+    capabilities: {
+        can_describe_scene: string;
+        can_render_prompt: string;
+        can_place: string;
+    };
+    /** Die tatsächlich verwendete Kontextkette (§4.9.1). */
+    context_chain: readonly (string | null)[];
+    /** Wie das Zielmodell gefunden wurde (§4.9.1). */
+    target_model_resolution: {
+        element_id: string;
+        version_id: string;
+        chain_index: number;
+        head: unknown;
+        shadowed_retired: readonly {
+            element_id: string;
+            context_id: string | null;
+        }[];
+    };
+}
+/**
+ * Warum eine Auflösung nicht zustande kam.
+ *
+ * Alles hier ist **fachlich**. Technische Lesefehler werfen und werden nie zu
+ * einer dieser Klassen — sonst entstünde aus einer kränkelnden Datenbank eine
+ * Aussage über den Bestand (Grundsatzregel 5).
+ */
+type ResolveFailure = {
+    class: 'not_a_shot';
+    message: string;
+    type: string;
+} | {
+    class: 'shot_not_published';
+    message: string;
+    versionId: string;
+} | {
+    class: 'schema';
+    message: string;
+    where: 'shot' | 'scene_setup';
+    errors: readonly SchemaError[];
+} | {
+    class: 'capability_blocked';
+    message: string;
+    flag: string;
+    findings: readonly PublishFinding[];
+} | {
+    class: 'capability_undetermined';
+    message: string;
+    flag: string;
+    reasons: readonly CapabilityReason[];
+} | {
+    class: 'reference_unresolvable';
+    message: string;
+    versionId: string;
+    path: string;
+    reason: 'unknown' | 'invisible' | 'wrong_type';
+} | {
+    class: 'target_model_unresolvable';
+    message: string;
+    resolution: TargetModelResolution;
+};
+type ResolveResult = {
+    kind: 'resolved';
+    input: RendererInput;
+    report: CapabilityReport;
+} | {
+    kind: 'rejected';
+    failure: ResolveFailure;
+};
+/** Ein technischer Fehler der Auflösung. Kein fachlicher Befund. */
+declare class ResolveTechnicalError extends Error {
+}
+interface ResolveShotInput {
+    /** Eine **veröffentlichte** `shot`-Version. Entwürfe erzeugen keinen Lauf. */
+    shotVersionId: string;
+    resolver: ReferenceResolver;
+    /** Die wirksame Kontextkette des Shot-Elements; wird eingefroren (§4.9.1). */
+    contextChain: readonly (string | null)[];
+    /**
+     * Freie Anweisung des Aufrufers für **diesen** Lauf (§4.1).
+     *
+     * Sie überschreibt `prompt_render_settings.user_instruction` des Shots —
+     * zwei verschiedene Sachverhalte: die eine steht dauerhaft an der
+     * veröffentlichten Version, die andere gilt nur hier. Wird eine gesetzte
+     * Anweisung des Shots überschrieben, steht das in `assumptions`.
+     */
+    userInstruction?: string | null;
+}
+/**
+ * Löst einen Shot zur Renderer-Eingabe auf.
+ *
+ * Der Ablauf steht in §4.3 des Start-Events und wird hier Schritt für Schritt
+ * gegangen. Was scheitert, scheitert mit einer eigenen Klasse — es gibt keinen
+ * Sammelfehler „ging nicht".
+ */
+declare function resolveShot(input: ResolveShotInput): Promise<ResolveResult>;
+/** Eingabe der Trockenauflösung (§4.6). */
+interface ResolveShotPayloadInput {
+    /** Payload eines `shot` — **Entwurf oder veröffentlicht**. */
+    shotPayload: unknown;
+    /** Element, zu dem die Payload gehört; die Zielmodellsuche braucht es. */
+    shotElementId: string;
+    /** Kennung der Version, falls es eine gibt. Bei einem Entwurf leer. */
+    shotVersionId?: string;
+    resolver: ReferenceResolver;
+    contextChain: readonly (string | null)[];
+    /** Freie Anweisung des Aufrufers für diesen Lauf (§4.1). */
+    userInstruction?: string | null;
+    /**
+     * Vorab aufgelöste Kettenglieder — Stufe 6.6, C0 (D-95/D-96).
+     *
+     * Ohne dieses Feld holt die Auflösung Setup und Szene über
+     * `shot.scene_setup_ref` bzw. `setup.scene_ref` aus **veröffentlichten**
+     * Versionen; das ist der bisherige und unveränderte Weg.
+     *
+     * Mit diesem Feld kommen beide von außen. Genau so bekommt eine Draft-Kette
+     * ihren Prompt, ohne dass ein Knoten veröffentlicht sein muss: Der
+     * Draft-Loader lädt die Payloads über die Kettenlinks und reicht **dieselben
+     * fachlichen Inhalte** in **dieselbe** Zusammensetzung. Es gibt bewusst
+     * keinen zweiten Prompt-Zusammenbau und keine zweite Kamera- oder
+     * Zielmodell-Logik (Gate C0).
+     *
+     * Die `version_id` ist bei einem Draft leer — sie wird **nicht** erfunden
+     * (D-98/D-75). Alle übrigen Referenzen (Preset, Pattern, Styles, Policies,
+     * Zielmodell) bleiben veröffentlichungspflichtig: D-96 erlaubt genau zwei
+     * Draft-Kanten, nicht beliebige.
+     */
+    chain?: {
+        setup: {
+            element_id: string;
+            version_id: string;
+            payload: unknown;
+        };
+        scene: {
+            element_id: string;
+            version_id: string;
+            payload: unknown;
+        };
+    };
+}
+/**
+ * Löst eine Shot-**Payload** auf, ohne eine veröffentlichte Version zu verlangen.
+ *
+ * Das ist die Trockenauflösung aus §4.6: Ein Autor soll sehen können, was aus
+ * seinem Entwurf entstünde, ohne ihn zu veröffentlichen — genau wofür Stufe 2
+ * gebaut wurde („prüfen, bevor geschrieben wird"). Es wird nichts gespeichert
+ * und kein Modell gerufen.
+ *
+ * Die **Referenzen** müssen trotzdem veröffentlicht und sichtbar sein (D-03):
+ * Ein Entwurf darf auf nichts zeigen, was es noch nicht gibt.
+ */
+declare function resolveShotPayload(input: ResolveShotPayloadInput): Promise<ResolveResult>;
+/**
+ * Prüft ein Fähigkeits-Flag als Torwächter.
+ *
+ * `no` und `unknown` bekommen **verschiedene** Klassen. Die Ablehnung bei
+ * `unknown` sagt „das liess sich hier nicht feststellen", nicht „die Szene kann
+ * das nicht" — der Unterschied ist der ganze Grund, warum `unknown` in D-64 ein
+ * eigener Zustand ist.
+ */
+declare function capabilityGate(report: CapabilityReport, flag: 'can_render_prompt' | 'can_place'): ResolveFailure | null;
+
+interface VisibilityNode {
+    node_id: string;
+    state: string;
+    reason?: string;
+    confidence?: string;
+    assumption?: boolean;
+}
+interface PromptRunOutput {
+    positive: string;
+    negative: string | null;
+    /** Pflicht (D-55) — die Erläuterung für den Menschen. */
+    feedback: string;
+    visibility: {
+        basis: string;
+        nodes: readonly VisibilityNode[];
+        assumptions: readonly string[];
+    };
+    notes: readonly string[];
+}
+/** Warum ein Lauf gescheitert ist — die Klassen aus §4.9.1. */
+type RunFailureClass = 'response_parse' | 'response_schema' | 'safety_blocked' | 'finish_reason' | 'empty_content' | 'provider_error';
+interface RunFailure {
+    class: RunFailureClass;
+    message: string;
+    provider_detail?: unknown;
+}
+/**
+ * Ergebnis eines Laufs — **beide Ausgänge werden gespeichert**.
+ *
+ * Ein Fehlerlauf ist der Nachweis, dass eine bestimmte Kombination beim
+ * Provider anstößt (D-23 §6). Ihn zu verwerfen hieße, genau diese Information
+ * zu vernichten.
+ */
+type PromptRunOutcome = {
+    status: 'succeeded';
+    output: PromptRunOutput;
+    raw_output: string;
+    model_id: string;
+    provider: string;
+} | {
+    status: 'failed';
+    failure: RunFailure;
+    raw_output: string | null;
+    model_id: string;
+    provider: string;
+};
+/**
+ * Der Systemprompt des Renderers.
+ *
+ * Bewusst als eigene Funktion und mitgespeichert: D-22 verlangt, dass ein Lauf
+ * einfriert, unter welchen Annahmen er entstand — der Systemprompt gehört dazu.
+ * Ändert er sich, ist an einem alten Lauf noch erkennbar, was damals galt.
+ */
+declare function buildSystemInstruction(input: RendererInput): string;
+/** Die Nutzernachricht: die Renderer-Eingabe als JSON (D-47). */
+declare function buildUserPrompt(input: RendererInput): string;
+/**
+ * Löst das JSON aus dem Text.
+ *
+ * Bewusst **ohne** die für Prosa gedachte Bereinigung aus `cleanAiResponse`
+ * (D-56): Sie ist für Fließtext gebaut und darf ein JSON-Dokument nicht
+ * anfassen. Erlaubt ist einzig, einen umschließenden Markdown-Codeblock zu
+ * entfernen — das ist keine Interpretation des Inhalts, sondern das Auspacken
+ * eines Umschlags.
+ */
+declare function parseRunResponse(raw: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Prüft die geparste Antwort gegen ihr Schema **und** gegen die Pflichtdiagnosen.
+ *
+ * Handgeschrieben und nicht über die JSON-Schema-Registry: Die Registry führt
+ * die **Elementtypen** der Domain (`schemas/`), und die Antwort des Renderers
+ * ist kein Elementtyp. Sie dort einzuhängen hieße, den Schemasatz um etwas zu
+ * erweitern, das nie versioniert oder referenziert wird.
+ */
+declare function checkRunResponse(value: unknown, input: RendererInput): {
+    ok: true;
+    output: PromptRunOutput;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Führt den Prompt-Ableitungslauf aus.
+ *
+ * Gibt **immer** ein Ergebnis zurück — `succeeded` oder `failed`. Ein
+ * technischer Ausfall des Ports (Netz, Konfiguration) wirft dagegen; er ist
+ * kein Lauf, sondern ein Betriebsfehler und darf nicht als „das Modell hat
+ * abgelehnt" gespeichert werden.
+ */
+declare function runPromptDerivation(input: RendererInput, port: TextGenerationPort): Promise<PromptRunOutcome & {
+    system_prompt: string;
+}>;
+
+/** Präfix aller Events dieser Domain im gemeinsamen HF-Event-Kanal. */
+declare const SZENEN_EVENT_PREFIX = "szenen.";
+declare const SZENEN_EVENT_TYPES: {
+    readonly elementCreated: "szenen.element_created";
+    readonly elementRetired: "szenen.element_retired";
+    readonly metadataRevised: "szenen.element_metadata_revised";
+    readonly draftWritten: "szenen.element_draft_written";
+    readonly versionPublished: "szenen.element_version_published";
+    readonly preferredHeadSelected: "szenen.element_preferred_head_selected";
+    /**
+     * Ein Prompt-Ableitungslauf — Stufe 3, S6 (E-3b).
+     *
+     * Ein Lauf ist **kein Element**: keine Version, kein DAG, nicht
+     * referenzierbar. Er liegt trotzdem im selben autoritativen Log, weil er
+     * append-only und unveränderlich ist — genau die Form, die ein Ereignislog
+     * nativ trägt — und weil MySQL sonst zu einem zweiten fachlichen Speicher
+     * würde, den D-62 abgeschafft hat.
+     *
+     * Der Elementreducer ignoriert diesen Typ (`default:`-Zweig); die Läufe
+     * werden mit `collectPromptRuns` gelesen.
+     */
+    readonly promptRunRecorded: "szenen.prompt_run_recorded";
+    /**
+     * Ein Szenen-Rekonstruktionslauf — Stufe 6.5 (D-71).
+     *
+     * Derselbe Bauplan und dieselbe Begründung wie beim Prompt-Lauf: append-only,
+     * unveränderlich, **kein Element** — keine Version, kein DAG, nicht
+     * referenzierbar. Er liegt im autoritativen Log, weil er genau die Form hat,
+     * die ein Ereignislog nativ trägt.
+     *
+     * Bewusst ein zweiter Lauftyp und **kein** gemeinsamer: Ein Prompt-Lauf geht
+     * von einer veröffentlichten Shot-Version aus, ein Rekonstruktionslauf von
+     * einer Referenz, die noch zu gar keinem Element gehört. Sie in einen Typ zu
+     * zwingen hieße, beiden ihre Herkunftsfelder zu nehmen.
+     *
+     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig).
+     */
+    readonly sceneDerivationRecorded: "szenen.scene_derivation_recorded";
+    /**
+     * Ein ausdrücklich ausgelöster Lauf gegen den **echten** Provider.
+     *
+     * Er kostet Geld und wird deshalb nie beiläufig gefahren. Das Ereignis hält
+     * fest, was tatsächlich bezahlt wurde: wie viele Modellaufrufe, mit welchem
+     * Ausgang, in welcher Umgebung und von wem ausgelöst.
+     *
+     * Es ersetzt **nicht** die einzelnen Läufe — die werden regulär als
+     * `prompt_run_recorded` bzw. `scene_derivation_recorded` protokolliert. Es
+     * ist die Klammer darüber und der Grund, warum jemand später nachlesen kann,
+     * ob der Durchstich stattgefunden hat, ohne ihn erneut zu bezahlen.
+     */
+    readonly providerCheckRecorded: "szenen.provider_check_recorded";
+    /**
+     * Eine geprüfte Arbeitsfassung eines fehlgeschlagenen Rekonstruktionslaufs —
+     * Stufe 6.6 (D-99).
+     *
+     * Sie ist **kein Lauf**: kein Provideraufruf, keine Kosten, kein Zielmodell.
+     * Sie ist die lokal geprüfte Korrektur eines bereits bezahlten Ergebnisses
+     * und zeigt über `run_id` auf ihren Ursprung. Der `raw_output` jenes Laufs
+     * bleibt unangetastet — deshalb ein eigenes Ereignis statt einer Änderung am
+     * bestehenden, das es ohnehin nicht geben dürfte (D-71).
+     *
+     * Mehrere Rettungen zum selben Lauf sind zulässig und erwartet: Jede
+     * Korrekturrunde ist nachvollziehbare Arbeit, kein Update der vorigen.
+     *
+     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig).
+     */
+    readonly sceneDerivationRecoveryRecorded: "szenen.scene_derivation_recovery_recorded";
+    /**
+     * Ein bezahlter Bildgenerierungsauftrag beginnt — Stufe 6.7 (D-119).
+     *
+     * Append-only wie jedes andere Ereignis dieser Domain, geschrieben **vor**
+     * dem Provideraufruf. Es traegt **keine Bilddaten** — nur die Kennung, mit
+     * der die spaetere kanonische Batch-Persistenz (`saveGeneratedAssetBatch`,
+     * Teil C) wiedergefunden wird. Ein Crash zwischen diesem Ereignis und
+     * `imageGenerationFinished` loescht den Auftrag nicht: Er bleibt lesbar,
+     * ohne dass irgendein automatischer Retry darauf reagiert.
+     *
+     * Gilt nur fuer `generated_in_app` — ein externer Import (D-108/D-117)
+     * ruft keinen Provider und braucht deshalb kein `started`; sein Nachweis
+     * ist das gespeicherte Library-Item selbst.
+     *
+     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig); gelesen
+     * wird mit `collectImageGenerationOrders`.
+     */
+    readonly imageGenerationStarted: "szenen.image_generation_started";
+    /**
+     * Derselbe Bildgenerierungsauftrag endet — Stufe 6.7 (D-119).
+     *
+     * Erscheint erst **nach** der kanonischen Batch-Persistenz: Ein technischer
+     * Fehler zwischen Provideraufruf und Speichern darf nie als `succeeded`
+     * protokolliert werden, nur weil der Provider geantwortet hat. Traegt
+     * ebenfalls keine Bilddaten — nur Status, Zaehlung und die Item-Kennung,
+     * falls eine entstand.
+     */
+    readonly imageGenerationFinished: "szenen.image_generation_finished";
+};
+/**
+ * Ein Event, wie der Reducer es sieht.
+ *
+ * Nur `type`, `payload` und `clientId` sind fachlich. `ts` dient allein der
+ * **Lesereihenfolge** des Logs und darf nie eine fachliche Vorrangfrage
+ * entscheiden — sonst wäre es `MAX(ts)` durch die Hintertür (§2.5, R-3).
+ */
+interface ElementEvent<P = unknown> {
+    type: string;
+    payload: P;
+    clientId: string;
+    ts: number;
+}
+/** Ein Befund beim Falten: etwas ist widersprüchlich, aber der Zustand bleibt lesbar. */
+interface ReducerFinding {
+    code: 'unbekanntes_element' | 'version_doppelt' | 'version_veraendert' | 'draft_fork' | 'metadata_fork' | 'preferred_head_fork' | 'element_doppelt';
+    element_id: string;
+    message: string;
+}
+/** Abgeleiteter Zustand über alle Elemente. */
+interface ElementStoreState {
+    elements: ReadonlyMap<string, ElementSnapshot>;
+    findings: readonly ReducerFinding[];
+}
+/**
+ * Faltet den Event-Log zum Elementzustand.
+ *
+ * Der Reducer ist rein: gleiche Events, gleicher Zustand — unabhängig von der
+ * Eingabereihenfolge.
+ *
+ * @param events Alle bekannten Szenen-Events; fremde Typen werden übergangen.
+ */
+declare function reduceElementEvents(events: readonly ElementEvent[]): ElementStoreState;
+/** Aktuelle Revision des Entwurfs. `0`, wenn keiner existiert. */
+declare function draftRevisionOf(snapshot: ElementSnapshot | null | undefined): number;
+/**
+ * Quellrevision eines gelesenen Event-Logs (D-62 §2.4, D-63 §1.1.2).
+ *
+ * Die Projektion darf sich nur dann `current` nennen, wenn sie belegen kann,
+ * **bis wohin** sie reicht. Dieser Beleg ist die Quellrevision, und sie muss
+ * zwei Eigenschaften haben: aus dem Log allein berechenbar (sonst wäre sie eine
+ * zweite Buchführung) und für zwei verschiedene Logstände verschieden.
+ *
+ * Beides leistet `Anzahl@größter-Zeitstempel`. Der Log ist append-only — es
+ * verschwindet nie ein Event —, also wächst die Anzahl bei jedem Schreibvorgang.
+ * Der Zeitstempel kommt dazu, weil er den Stand für einen Menschen lesbar macht;
+ * entscheidend ist die Anzahl.
+ *
+ * Bewusst **kein** Hash über die Payloads: der wäre teurer und würde
+ * Gleichheit über die Zeit versprechen, die der Log ohnehin schon garantiert.
+ * Und bewusst hier, nicht im Server: der Projektor rechnet damit, und wer den
+ * Stand prüfen will, soll dieselbe Rechnung fahren (R-2).
+ */
+declare function logRevisionOf(events: readonly ElementEvent[]): string;
+/** Aktuelle Revision der Preferred-Head-Auswahl eines Kontexts. `0`, wenn keine existiert. */
+declare function preferredHeadRevisionOf(events: readonly ElementEvent[], elementId: string, contextId: string): number;
+
+/** Ein protokollierter Lauf, so wie er im Ereignis steht. */
+/**
+ * Woher die eingefrorene Eingabe eines Laufs stammt — Stufe 6.6 (D-98).
+ *
+ * Bis 6.5 gab es nur einen Fall, und er stand flach im Datensatz: eine
+ * veröffentlichte Shot-Version. Mit der Draft-Kette gibt es einen zweiten, und
+ * er hat keine Versionen — nur Entwürfe mit Kennung und Revision.
+ *
+ * Bewusst diskriminiert und **ohne** fingierte Versionskennungen: Ein Feld,
+ * das ehrlich fehlt, ist besser als eine UUID, die wie eine echte aussieht
+ * (D-75). `input_payload` bleibt die eigentliche eingefrorene Wahrheit des
+ * Laufs (D-22); `source` erklärt nur, woher sie kam.
+ */
+type PromptRunSource = {
+    kind: 'published';
+    shot_version_id: string;
+    scene_setup_version_id: string;
+} | {
+    kind: 'draft_chain';
+    chain_id: string;
+    nodes: readonly {
+        type: 'scene' | 'scene_setup' | 'shot';
+        element_id: string;
+        draft_id: string;
+        revision: number;
+    }[];
+    /**
+     * Der Rekonstruktionslauf, aus dem diese Kette entstand (D-123, A2).
+     *
+     * `DraftChainMeta.source_run_id` trägt das seit 6.6 bereits am Draft;
+     * beim Einfrieren wird es additiv in die unveränderliche `source` des
+     * entstehenden Prompt-Laufs übernommen, damit Stufe 6.7 die
+     * Rekonstruktions-Inputbilder auch dann noch findet, wenn die
+     * veränderliche Draft-Kette später nicht mehr existiert. Fehlt bei
+     * jedem Lauf von vor 6.7 — nichts wird nachträglich geraten.
+     */
+    derivation_run_id?: string;
+    /** Gesetzt, wenn die Kette aus einer Recovery-Arbeitsfassung kam (D-99). */
+    derivation_recovery_id?: string;
+};
+interface PromptRunRecord {
+    run_id: string;
+    /**
+     * Herkunft: die veröffentlichte Shot-Version, aus der der Lauf entstand.
+     *
+     * Bei einem Lauf aus einer Draft-Kette ist dieses Feld **leer** — dort gibt
+     * es keine Version, und eine erfundene wäre von einer echten nicht zu
+     * unterscheiden. Wer die Herkunft wissen will, liest `source`.
+     */
+    shot_version_id: string;
+    shot_element_id: string;
+    scene_setup_version_id: string;
+    camera_id: string;
+    target_model_version_id: string;
+    provider: string;
+    model_id: string;
+    system_prompt: string;
+    /** Die eingefrorene Zusammensetzung (D-22) — wörtlich, nicht referenziert. */
+    input_payload: RendererInput;
+    /**
+     * Der Ausgang. Ein `failed` ist ein **Erfolg des Systems**: der Nachweis,
+     * dass diese Kombination beim Provider anstößt (D-23 §6).
+     */
+    status: 'succeeded' | 'failed';
+    failure: RunFailure | null;
+    /** Bei `succeeded` gesetzt, bei `failed` immer `null`. */
+    output: PromptRunOutput | null;
+    /** Die rohe Modellantwort, soweit es eine gab. */
+    raw_output: string | null;
+    /**
+     * Woher die Eingabe kam (D-98).
+     *
+     * **Fehlt bei jedem Lauf von vor 6.6.** Alte Laufsätze werden nicht
+     * umgeschrieben — sie sind unveränderlich (E-3b) —, und `sourceOf()`
+     * normalisiert sie als `published`. Wer das Feld voraussetzt, bricht den
+     * Bestand.
+     */
+    source?: PromptRunSource;
+    created_at: string;
+}
+/** Nutzlast des Ereignisses. Identisch mit dem Datensatz — ein Lauf ändert sich nie. */
+type PromptRunRecordedPayload = PromptRunRecord;
+/**
+ * Liest alle Läufe aus dem Ereignislog.
+ *
+ * Bewusst ohne Reducer-Zustandsmaschine: Läufe sind unveränderlich, es gibt
+ * kein späteres Ereignis, das einen früheren Lauf ändert. Ein zweiter Eintrag
+ * mit derselben `run_id` wäre ein Datenfehler und wird **nicht** stillschweigend
+ * überschrieben — der erste gilt, und das ist ehrlich: er war zuerst da.
+ */
+declare function collectPromptRuns(events: readonly ElementEvent[]): readonly PromptRunRecord[];
+/** Ein einzelner Lauf aus dem Log, oder `null`. */
+declare function findPromptRun(events: readonly ElementEvent[], runId: string): PromptRunRecord | null;
+
+/**
+ * Ein Vorschlag, so wie er im Ereignis steht.
+ *
+ * `adopted_as` hält fest, ob aus diesem Vorschlag ein Draft geworden ist — es
+ * ist die einzige Verbindung vom Lauf zum Elementbestand. Sie zeigt auf das
+ * Element, nicht auf eine Version: Welche Version daraus später wird,
+ * entscheidet die Veröffentlichung, nicht der Lauf.
+ */
+interface RecordedProposal {
+    type: DerivableType;
+    payload: Record<string, unknown>;
+    /**
+     * `complete`: erfüllt das reguläre Element-Schema.
+     * `partial`: erfüllt es bis auf die in `gaps` benannten Pflichtfelder.
+     *
+     * Steht im Lauf, nicht nur im Arbeitsspeicher: Wer den Vorschlag später
+     * übernimmt, muss wissen, dass er einen unvollständigen Draft bekommt — und
+     * welche Stellen er zu ergänzen hat, bevor er veröffentlichen kann.
+     * Ältere Läufe tragen das Feld nicht; sie sind sämtlich `complete`, weil es
+     * vor dem Proposal-Vertrag nichts anderes geben konnte.
+     */
+    status?: 'complete' | 'partial';
+    gaps?: readonly {
+        pointer: string;
+        reason: string;
+    }[];
+    /**
+     * Der Namensvorschlag des Modells (D-83), sofern es einen brauchbaren gab.
+     *
+     * Fehlt bei Läufen vor D-83 und bei jedem Lauf, dessen Titel verworfen wurde
+     * — ein Titel ist Beiwerk und lässt den Lauf nie scheitern (D-84).
+     */
+    title?: string;
+}
+/**
+ * Die eingefrorene Eingabe — **ohne Bilddaten** (D-73).
+ *
+ * Base64 gehört nicht in dieses Log: Es ist der autoritative Speicher (D-62)
+ * und wird in Flow-FA Pure vollständig geladen. Ein Lauf bleibt über Digest
+ * und Herkunft identifizierbar; wiederherstellbar ist ein reiner Upload
+ * dadurch nicht, und das ist bewusst in Kauf genommen.
+ */
+interface RecordedDerivationInput {
+    mode: DerivationInputMode;
+    prompt_text: string | null;
+    images: readonly ImageProvenance[];
+}
+/** Ein protokollierter Rekonstruktionslauf. */
+interface SceneDerivationRecord {
+    run_id: string;
+    /** Herkunft der Regel: die veröffentlichte Policy-Version (Konzept §8). */
+    policy_version_id: string;
+    policy_element_id: string;
+    /** In welchem Kontext der Lauf entstand — er bestimmt, wo Drafts landen. */
+    context_id: string | null;
+    provider: string;
+    model_id: string;
+    system_prompt: string;
+    /** Die eingefrorene Eingabe (D-22/D-73) — wörtlich, nicht referenziert. */
+    input: RecordedDerivationInput;
+    /**
+     * Der Ausgang. Ein `failed` ist ein **Erfolg des Systems**: der Nachweis,
+     * dass diese Kombination beim Provider anstößt (D-23 §6).
+     */
+    status: 'succeeded' | 'failed';
+    failure: DerivationFailure | null;
+    /** Bei `succeeded` gesetzt, bei `failed` leer. */
+    proposals: readonly RecordedProposal[];
+    feedback: string | null;
+    assumptions: readonly string[];
+    not_derivable: readonly NotDerivable[];
+    conflicts: readonly DerivationConflict[];
+    /** Die rohe Modellantwort, soweit es eine gab. */
+    raw_output: string | null;
+    /**
+     * Woraus dieser Lauf folgt (D-88). Fehlt bei einem ersten Lauf.
+     *
+     * Ein Folgelauf ist ein eigener Lauf, kein zweiter Versuch im selben: Ein
+     * Lauf ist unveränderlich (D-71) und längst geschrieben, wenn der Mensch
+     * gefragt wird, ob eine Korrektur folgen soll.
+     */
+    follows?: DerivationFollowUp;
+    /** Antwort des Modells auf die Beanstandung (D-90). */
+    reply?: string;
+    created_at: string;
+}
+/** Nutzlast des Ereignisses. Identisch mit dem Datensatz — ein Lauf ändert sich nie. */
+type SceneDerivationRecordedPayload = SceneDerivationRecord;
+/**
+ * Liest alle Rekonstruktionsläufe aus dem Ereignislog.
+ *
+ * Bewusst ohne Reducer-Zustandsmaschine: Läufe sind unveränderlich, es gibt
+ * kein späteres Ereignis, das einen früheren Lauf ändert. Ein zweiter Eintrag
+ * mit derselben `run_id` wäre ein Datenfehler und wird **nicht** stillschweigend
+ * überschrieben — der erste gilt, und das ist ehrlich: er war zuerst da.
+ */
+declare function collectSceneDerivations(events: readonly ElementEvent[]): readonly SceneDerivationRecord[];
+/** Ein einzelner Lauf aus dem Log, oder `null`. */
+declare function findSceneDerivation(events: readonly ElementEvent[], runId: string): SceneDerivationRecord | null;
+
+/** Was bei einer einzelnen Prüfung herauskam. */
+interface ProviderCheckResult {
+    kind: string;
+    /**
+     * `skipped` heißt: **vor** dem Modellaufruf abgebrochen, also kostenlos.
+     * `error` heißt: technischer Ausfall — möglicherweise trotzdem bezahlt.
+     */
+    status: 'succeeded' | 'failed' | 'skipped' | 'error';
+    message?: string;
+    provider?: string;
+    model_id?: string;
+    /** Der reguläre Lauf, der dabei entstanden ist. */
+    run_id?: string | null;
+    persisted?: boolean;
+    failure?: unknown;
+    excerpt?: string | null;
+    proposal_types?: readonly string[];
+    not_derivable_count?: number;
+    conflict_count?: number;
+    duration_ms?: number;
+}
+interface ProviderCheckRecord {
+    check_id: string;
+    triggered_by: string;
+    environment: string;
+    /**
+     * Die Zahl der tatsächlich abgesetzten Modellaufrufe.
+     *
+     * Bewusst getrennt von `results.length`: Eine übersprungene Prüfung hat
+     * nichts gekostet, und wer später Kosten nachvollziehen will, darf beides
+     * nicht verwechseln.
+     */
+    model_calls: number;
+    results: readonly ProviderCheckResult[];
+    created_at: string;
+}
+type ProviderCheckRecordedPayload = ProviderCheckRecord;
+/**
+ * Liest alle Provider-Checks aus dem Ereignislog.
+ *
+ * Wie bei den Läufen ohne Reducer: ein Check ist unveränderlich, und ein
+ * zweiter Eintrag mit derselben `check_id` wäre ein Datenfehler — der erste
+ * gilt.
+ */
+declare function collectProviderChecks(events: readonly ElementEvent[]): readonly ProviderCheckRecord[];
+/** Ein einzelner Check aus dem Log, oder `null`. */
+declare function findProviderCheck(events: readonly ElementEvent[], checkId: string): ProviderCheckRecord | null;
+/**
+ * Die Zahl der Modellaufrufe über eine Menge von Checks.
+ *
+ * Eine Stelle, an der summiert wird — sonst zählt die UI anders als der
+ * Bericht, und niemand weiß, welche Zahl stimmt.
+ */
+declare function totalModelCalls(checks: readonly ProviderCheckRecord[]): number;
+
+/** Ein eingefrorener Kettenknoten — die Provenienz des Laufs (D-98). */
+interface FrozenChainNode {
+    type: DerivableType;
+    element_id: string;
+    draft_id: string;
+    revision: number;
+}
+interface FreezeSuccess {
+    kind: 'ok';
+    chainId: string;
+    nodes: readonly FrozenChainNode[];
+    input: RendererInput;
+    /**
+     * Der Rekonstruktionslauf, aus dem die Kette entstand (D-123, A2).
+     *
+     * Alle Knoten einer Kette teilen dieselben Kettenmetadaten (D-96) — die
+     * Übernahme entsteht aus **einer** Operation aus **einem** Ursprung —, daher
+     * genügt der Wert eines beliebigen erfassten Knotens, hier der des Shots.
+     */
+    sourceRunId: string;
+    /** Gesetzt, wenn der Inhalt der Kette aus einer Recovery-Arbeitsfassung kam. */
+    sourceRecoveryId?: string;
+}
+/**
+ * Warum eine Kette nicht eingefroren werden konnte.
+ *
+ * `conflict` ist bewusst von `rejected` getrennt: Das eine ist ein Wettlauf und
+ * beim nächsten Versuch weg, das andere ein Mangel der Kette, den jemand
+ * beheben muss. Sie gleich zu behandeln hieße, dem Nutzer „nochmal versuchen"
+ * für einen unvollständigen Shot anzubieten.
+ *
+ * `error` kam mit Stufe 6.7.1 (D-125) dazu: **technisch**, nicht fachlich —
+ * Netz, Drosselung, Speicher nicht erreichbar. Vor 6.7.1 landete ein solcher
+ * Lesefehler beim Einfrieren als `rejected`, und ein HF-429 sah dadurch wie
+ * ein Mangel der Kette aus (der reale 429-Durchstich vom 2026-08-13). HF671-10
+ * verlangt, dass er stattdessen hier ankommt.
+ */
+type FreezeFailure = {
+    kind: 'conflict';
+    message: string;
+    /** Der Knoten, der sich zwischen den beiden Lesedurchgängen änderte. */
+    node: {
+        type: DerivableType;
+        element_id: string;
+        draft_id: string;
+    };
+    expectedRevision: number;
+    actualRevision: number;
+} | {
+    kind: 'rejected';
+    message: string;
+    failure?: ResolveFailure;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+type FreezeResult = FreezeSuccess | FreezeFailure;
+/** Ein einzelnes Element aus einer Momentaufnahme — kein Netzzugriff mehr. */
+interface ChainSnapshot {
+    getElement(elementId: string): {
+        kind: string;
+        message?: string;
+        value?: {
+            element: {
+                element_id: string;
+                type: string;
+            };
+            draft: {
+                draft_id: string;
+                revision: number;
+                payload: unknown;
+                chain?: DraftChainMeta;
+            } | null;
+            draftFork?: unknown | null;
+        } | null;
+    };
+}
+/**
+ * Was das Einfrieren vom Elementspeicher braucht — bewusst schmal.
+ *
+ * Seit Stufe 6.7.1 (D-125) keine sechs unabhängigen `getElement()`-Aufrufe
+ * mehr, sondern genau zwei Momentaufnahmen: `readSnapshot({ fresh: false })`
+ * für Durchgang A, `readSnapshot({ fresh: true })` für Durchgang B. „Frisch"
+ * heißt dabei D-125 — inkrementell gegen den Kanal synchronisiert, nicht ein
+ * zweites Mal aus demselben TTL-Cache bedient (sonst könnte B den Konflikt aus
+ * HF671-8/9 nicht mehr sehen).
+ */
+interface ChainQueries {
+    readSnapshot(options: {
+        fresh: boolean;
+    }): Promise<ChainSnapshot>;
+}
+interface FreezeDraftChainInput {
+    /** Das Shot-**Element** der Kette. Eine Version gibt es hier gerade nicht. */
+    shotElementId: string;
+    store: ChainQueries;
+    resolver: ReferenceResolver;
+    contextChain: readonly (string | null)[];
+    userInstruction?: string | null;
+}
+/**
+ * Friert die vom Shot erreichbare Draft-Kette ein und baut die Renderer-Eingabe.
+ *
+ * Bei **jedem** Fehlausgang gilt: null Provideraufrufe. Diese Funktion ruft
+ * ohnehin kein Modell — sie liefert nur die Eingabe, und der Aufrufer entscheidet
+ * danach, ob er sie benutzt.
+ */
+declare function freezeDraftChain(input: FreezeDraftChainInput): Promise<FreezeResult>;
+
+/**
+ * Wie brauchbar das Material einer Arbeitsfassung ist.
+ *
+ * - `usable`  — die Antwort erfuellt den vollen Vertrag; jeder zugesagte
+ *               Vorschlag ist verwertbar.
+ * - `partial` — mindestens ein Vorschlag ist verwertbar, aber nicht alles.
+ * - `invalid` — nichts ist verwertbar. Der Text bleibt trotzdem erhalten: Er
+ *               ist die Grundlage der naechsten Korrektur.
+ */
+type RecoveryStatus = 'usable' | 'partial' | 'invalid';
+/** Eine geprüfte Arbeitsfassung eines fehlgeschlagenen Laufs. */
+interface SceneDerivationRecoveryRecord {
+    recovery_id: string;
+    /** Der Lauf, aus dem der Text stammt. Über ihn ist das Original erreichbar. */
+    run_id: string;
+    /**
+     * Der geprüfte Text.
+     *
+     * Ob er dem `raw_output` entspricht oder bearbeitet wurde, sagt `edited` —
+     * beides ist zulässig, aber es darf nicht verwechselbar sein. Das Original
+     * ist über `run_id` immer rekonstruierbar; es wird hier **nicht** kopiert
+     * (dieselbe Begründung wie bei D-88: dieselbe große Zeichenkette nicht
+     * zweimal pflegen).
+     */
+    source_text: string;
+    /** `true`, wenn `source_text` vom `raw_output` des Laufs abweicht. */
+    edited: boolean;
+    /** Jeder Befund der Bewertung, in Prüfreihenfolge (6.6/A1). */
+    diagnostics: readonly DerivationDiagnostic[];
+    /**
+     * Die **verwertbaren** Vorschläge, in derselben Form wie im Lauf.
+     *
+     * Bewusst dieselbe Form: Die Graph-Übernahme aus Teil B liest Lauf und
+     * Rettung über denselben Weg, und zwei Vorschlagsformen wären zwei
+     * Wahrheiten (R-2).
+     */
+    proposals: readonly RecordedProposal[];
+    status: RecoveryStatus;
+    created_at: string;
+}
+/** Nutzlast des Ereignisses. Identisch mit dem Datensatz — eine Rettung ändert sich nie. */
+type SceneDerivationRecoveryRecordedPayload = SceneDerivationRecoveryRecord;
+/**
+ * Leitet den Status aus der Bewertung ab.
+ *
+ * Bewusst genau drei Werte und kein `ok: boolean`: „alles gut", „etwas ist zu
+ * holen" und „hier ist nichts" sind drei verschiedene Auskünfte, und die
+ * mittlere ist die, für die es diese Stufe überhaupt gibt.
+ */
+declare function recoveryStatusOf(assessment: DerivationAssessment): RecoveryStatus;
+/**
+ * Liest alle Arbeitsfassungen aus dem Ereignislog.
+ *
+ * Wie bei den Läufen ohne Reducer: Eine Rettung ist unveränderlich, und es gibt
+ * kein späteres Ereignis, das eine frühere ändert. Ein zweiter Eintrag zur
+ * gleichen `recovery_id` ist ein Datenfehler; der erste gilt, weil er zuerst
+ * da war.
+ *
+ * **Mehrere Rettungen zum selben Lauf sind der Normalfall**, kein Fehler: Wer
+ * einen kaputten Rohtext zweimal korrigiert, hat zweimal gearbeitet, und beide
+ * Fassungen bleiben nachvollziehbar (D-99).
+ */
+declare function collectSceneDerivationRecoveries(events: readonly ElementEvent[]): readonly SceneDerivationRecoveryRecord[];
+/** Eine einzelne Arbeitsfassung aus dem Log, oder `null`. */
+declare function findSceneDerivationRecovery(events: readonly ElementEvent[], recoveryId: string): SceneDerivationRecoveryRecord | null;
+/** Alle Arbeitsfassungen zu einem Lauf, in Anhängereihenfolge. */
+declare function recoveriesForRun(events: readonly ElementEvent[], runId: string): readonly SceneDerivationRecoveryRecord[];
+
+/** Präfix jeder Item-Kennung dieser Domain (E4-4). */
+declare const SZENEN_ITEM_PREFIX = "szn-";
+/** Die Item-Kennung zu einem Lauf. Deterministisch — das ist der Zweck (E4-4). */
+declare function itemIdForRun(runId: string): string;
+/** Ob eine Item-Kennung aus dieser Domain stammt — ohne JSON-Zugriff erkennbar. */
+declare function isSzenenItemId(itemId: string): boolean;
+/**
+ * Die Herkunft eines Bild-Batches im vorhandenen `metadata.szenen`-Block
+ * (D-114) — erweitert, nicht dupliziert. Modell, Seed und Dimensionen bleiben
+ * bewusst aussen vor: Sie stehen in `item_images` und werden hier nicht
+ * gespiegelt.
+ *
+ * **Seit dem Nutzerentscheid vom 2026-08-15 kein eigener Namensraum mehr**:
+ * Ein Prompt-Lauf ist fachlich ein Prompt, unabhaengig davon, ob er als
+ * Stufe-4-„Runde" gespeichert oder in Stufe 6.7 bebildert wurde — beides
+ * landet im selben Item unter `itemIdForRun(runId)`. `generation_batch_ids`
+ * ist deshalb **plural und append-only**: jeder weitere Klick auf „Bilder
+ * erzeugen" fuer denselben Lauf haengt seine Bilder an dasselbe Item an,
+ * statt ein neues zu erzeugen. (Vormals `itemIdForBatch(runId, batchId)` und
+ * ein singulaeres `generation_batch_id` — D-113/D-121 wurden entsprechend
+ * korrigiert, siehe `decisions/register.md`.)
+ */
+interface SzenenBatchOrigin {
+    prompt_run_id: string;
+    generation_batch_ids: readonly string[];
+    source_kind: 'generated_in_app' | 'external_import';
+    /** Nur Anzeige, wenn fachlich sicher bestimmbar — nie Pflicht (D-121). */
+    round?: number;
+}
+type SzenenBatchOriginFailure = {
+    field: 'prompt_run_id' | 'generation_batch_id';
+    message: string;
+} | {
+    field: 'source_kind';
+    message: string;
+};
+type SzenenBatchOriginVerdict = {
+    kind: 'ok';
+    value: SzenenBatchOrigin;
+} | {
+    kind: 'rejected';
+    failure: SzenenBatchOriginFailure;
+};
+/**
+ * Prueft **einen einzelnen** neuen Batch-Beitrag, bevor er in
+ * `metadata.szenen` geschrieben wird.
+ *
+ * Bewusst schmal: Diese Funktion kennt weder den Lauf noch eine eventuell
+ * bereits bestehende Herkunft — sie prueft nur, ob DIESER eine Beitrag fuer
+ * sich genommen gueltig ist, und liefert ihn als Einzelelement-Array zurueck.
+ * Das Vereinigen mit einer bestehenden Herkunft (falls das Item schon
+ * existiert) uebernimmt `mergeSzenenBatchOrigin()` — der Aufrufer kennt den
+ * Bestand, diese Funktion nicht (D-109 — keine Textsuche hier).
+ */
+declare function checkSzenenBatchOrigin(candidate: {
+    prompt_run_id?: unknown;
+    generation_batch_id?: unknown;
+    source_kind?: unknown;
+    round?: unknown;
+}): SzenenBatchOriginVerdict;
+/**
+ * Vereinigt eine neu geprüfte Batch-Herkunft mit einer bereits am Item
+ * vorhandenen — der Kern des „ein Prompt bleibt ein Item"-Entscheids.
+ *
+ * `generation_batch_ids` wird vereinigt (keine Duplikate, bestehende
+ * Reihenfolge bleibt vorn). `source_kind` und `round` bleiben vom **ersten**
+ * Schreiber: Ein zweiter Batch soll nicht rückwirkend behaupten, die Herkunft
+ * sei eine andere gewesen. Fehlt `bestehend` (erster Schreiber überhaupt),
+ * gilt `neu` unverändert.
+ */
+declare function mergeSzenenBatchOrigin(bestehend: SzenenBatchOrigin | undefined, neu: SzenenBatchOrigin): SzenenBatchOrigin;
+/**
+ * Ein bereits gespeichertes Szenen-Item, so viel wie die Ableitung braucht.
+ *
+ * `sequence` ist die **Speicherreihenfolge** (im Server die `user_library.id`),
+ * nicht die Runde. Beide fallen im Normalfall zusammen und genau dann
+ * auseinander, wenn rückwärts gespeichert wurde — und dieser Fall ist der
+ * Grund, warum das Feld existiert.
+ */
+interface ExistingSzenenItem {
+    item_id: string;
+    prompt_run_id: string;
+    round: number;
+    generation: number;
+    lineage_root_id: string;
+    sequence: number;
+    valid: boolean;
+}
+interface DerivedLineage {
+    parent_item_id: string | null;
+    lineage_root_id: string;
+    generation: number;
+    /** Der Elternteil stammt aus einer **späteren** Runde als dieses Item (A3). */
+    out_of_order: boolean;
+}
+/** Die Prompt-Run-Referenz am Item (§4.4). Herkunft, kein Inhalt. */
+interface DerivedSzenenReference {
+    prompt_run_id: string;
+    shot_version_id: string;
+    shot_element_id: string;
+    scene_setup_version_id: string;
+    camera_id: string;
+    target_model_version_id: string;
+    provider: string;
+    model_id: string;
+    run_created_at: string;
+    /** Stand zum Speicherzeitpunkt — ausdrücklich nicht neu berechnen (§4.6). */
+    round: number;
+    /** Es gibt in Stufe 4 keinen Draft (E4-2). Das Feld hält den Vertrag offen. */
+    created_from_draft_id: string | null;
+    saved_at: string;
+}
+/** Eine Lineage-Kante im **Bestandsformat**, damit `LibraryTab` das Item sieht. */
+interface DerivedRelationship {
+    type: 'parent';
+    id: string;
+    role: string;
+}
+/**
+ * Der fertige Item-Entwurf.
+ *
+ * Bewusst in der Sprache des Bestands (`content`, `negative_prompt`, `title`),
+ * nicht in einer neuen: Der Aufrufer reicht das unverändert an
+ * `saveGeneratedAsset` weiter, und jede Umbenennung hier wäre eine
+ * Übersetzungsschicht, die auseinanderlaufen kann.
+ */
+interface DerivedItem {
+    item_id: string;
+    title: string;
+    /** Der positive Prompt — das bestehende Prompt-Feld (Kompatibilitätszusage §8). */
+    content: string;
+    negative_prompt: string | null;
+    notes: string;
+    rating: number;
+    fsk_level: string;
+    /** Immer leer: das Tag-System wird in den Stufen 1–4 nicht angefasst (R-6/E4-7). */
+    tags: readonly never[];
+    szenen: DerivedSzenenReference;
+    lineage: DerivedLineage;
+    relationships: readonly DerivedRelationship[];
+}
+type ItemDerivationFailureClass = 'run_failed' | 'run_without_output' | 'run_not_among_siblings';
+interface ItemDerivationFailure {
+    class: ItemDerivationFailureClass;
+    message: string;
+    /** Bei `run_failed`: warum der Lauf scheiterte — der Aufrufer soll es nennen. */
+    run_failure?: PromptRunRecord['failure'];
+}
+type ItemDerivationResult = {
+    kind: 'ok';
+    value: DerivedItem;
+} | {
+    kind: 'rejected';
+    failure: ItemDerivationFailure;
+};
+interface DeriveItemInput {
+    /** Der ausgewählte Lauf, aus dem autoritativen Log gelesen. */
+    run: PromptRunRecord;
+    /**
+     * **Alle** Läufe derselben `shot_version_id`, in der Reihenfolge, die
+     * `collectPromptRuns` liefert. Sie bestimmen die Rundennummer.
+     */
+    runsOfShot: readonly PromptRunRecord[];
+    /** Bereits gespeicherte Items desselben Shots — auch soft-gelöschte. */
+    existingItems: readonly ExistingSzenenItem[];
+    /** Titel des Shot-Elements, sofern bekannt. Wird nie geraten. */
+    shotTitle?: string | null;
+    /** Wahl des Aufrufers; leer bedeutet „ableiten". */
+    title?: string | null;
+    notes?: string | null;
+    rating?: number | null;
+    fskLevel?: string | null;
+    /** Zeitpunkt des Speicherns, ISO-8601. */
+    savedAt: string;
+}
+/**
+ * Die Rundennummer eines Laufs: sein 1-basierter Platz unter den Läufen des
+ * Shots.
+ *
+ * `0`, wenn der Lauf nicht dabei ist — das ist ein Aufrufer-Fehler und wird von
+ * `deriveItemFromRun` als solcher gemeldet, nicht mit einer erfundenen Nummer
+ * überdeckt.
+ */
+declare function roundOfRun(run: PromptRunRecord, runsOfShot: readonly PromptRunRecord[]): number;
+/**
+ * Bestimmt die Kette (§5.4).
+ *
+ * Maßgeblich ist die **Speicherreihenfolge**, nicht die Rundenreihenfolge —
+ * Annahme A3 des library-Events sagt das wörtlich für den Rückwärtsfall, und
+ * eine Regel, die nur im Normalfall gilt, ist keine.
+ *
+ * Soft-gelöschte Items scheiden aus: Der Nutzer hat sie entfernt, und jeder
+ * Lesepfad des Bestands filtert `valid = 1`. Ein unsichtbarer Elternteil
+ * erzeugte einen Baum mit Loch.
+ */
+declare function deriveLineage(ownItemId: string, ownRound: number, existingItems: readonly ExistingSzenenItem[]): DerivedLineage;
+/**
+ * Leitet aus einer ausgewählten Runde das Item ab.
+ *
+ * Gibt `rejected` zurück, wo ein Item fachlich nicht entstehen darf — und wirft
+ * nicht: Der Aufrufer soll den Grund in eine HTTP-Antwort übersetzen können,
+ * ohne einen Ausnahmetext zu zerlegen.
+ */
+declare function deriveItemFromRun(input: DeriveItemInput): ItemDerivationResult;
+
+/** Nutzlast von `imageGenerationStarted` — geschrieben vor dem Provideraufruf. */
+interface ImageGenerationStartedPayload {
+    generation_batch_id: string;
+    prompt_run_id: string;
+    /** Nur `generated_in_app`: ein externer Import braucht kein `started` (D-119). */
+    source_kind: 'generated_in_app';
+    request: {
+        image_count: number;
+        aspect_ratio?: string;
+        seeds?: readonly number[];
+        callable_model_id: string;
+    };
+    created_at: string;
+}
+/** Nutzlast von `imageGenerationFinished` — geschrieben nach der Batch-Persistenz. */
+interface ImageGenerationFinishedPayload {
+    generation_batch_id: string;
+    status: 'succeeded' | 'partial' | 'failed';
+    /** Gesetzt bei `succeeded`/`partial`; bei `failed` gibt es kein Item (D-111). */
+    item_id?: string;
+    produced_count: number;
+    diagnostic?: string;
+    finished_at: string;
+}
+/**
+ * Der Auftrag, wie ein Leser ihn sieht — die Faltung von `started` und dem
+ * (ggf. noch fehlenden) `finished`.
+ *
+ * `status: 'started'` deckt sowohl „laeuft gerade" als auch „zwischen den
+ * beiden Ereignissen abgebrochen" ab — aus dem Log allein ist das nicht
+ * unterscheidbar, und genau das ist beabsichtigt (D-119): Es gibt **keinen**
+ * automatischen Retry, der diese Unterscheidung bräuchte. Die Ansicht darf den
+ * Zustand als „gestartet/unterbrochen" beschriften; der Nutzer entscheidet
+ * sichtbar über einen neuen Versuch.
+ */
+interface ImageGenerationOrder {
+    generation_batch_id: string;
+    prompt_run_id: string;
+    source_kind: 'generated_in_app';
+    request: ImageGenerationStartedPayload['request'];
+    created_at: string;
+    status: 'started' | 'succeeded' | 'partial' | 'failed';
+    item_id?: string;
+    produced_count?: number;
+    diagnostic?: string;
+    finished_at?: string;
+}
+/**
+ * Liest alle Bildgenerierungsauftraege aus dem Ereignislog.
+ *
+ * Wie bei `collectPromptRuns`: bewusst ohne Reducer-Zustandsmaschine. Ein
+ * zweites `started` zur selben `generation_batch_id` ist ein Datenfehler und
+ * wird nicht stillschweigend ueberschrieben — das erste gilt. Ein `finished`
+ * ohne passendes `started` wird ignoriert: Fuer `generated_in_app` ist
+ * `started` durch D-119 zwingend vorgeschaltet, und ein Ereignis ohne
+ * Gegenstueck waere kein gueltiger Auftrag, den diese Projektion erfinden
+ * duerfte.
+ */
+declare function collectImageGenerationOrders(events: readonly ElementEvent[]): readonly ImageGenerationOrder[];
+/** Alle Auftraege eines Prompt-Laufs, in Erfassungsreihenfolge. */
+declare function ordersForPromptRun(events: readonly ElementEvent[], runId: string): readonly ImageGenerationOrder[];
+/** Ein einzelner Auftrag, oder `null`. */
+declare function findImageGenerationOrder(events: readonly ElementEvent[], batchId: string): ImageGenerationOrder | null;
+
+/**
+ * Zugang zum Event-Kanal. Bewusst schmal: lesen und anhängen.
+ *
+ * Der HF-Kanal kennt weder Transaktionen noch Preconditions — das ist keine
+ * Lücke dieser Schnittstelle, sondern die Eigenschaft, um die herum der
+ * Reducer gebaut ist.
+ */
+interface ElementEventChannel {
+    /** Alle Szenen-Events. Reihenfolge egal, der Reducer sortiert selbst. */
+    readEvents(): Promise<readonly ElementEvent[]>;
+    /** Hängt ein Event an. Der Kanal vergibt `clientId` und `ts`. */
+    appendEvent(type: string, payload: unknown): Promise<void>;
+}
+/** Erzeugt Kennungen. Injizierbar, damit Tests deterministisch bleiben. */
+interface IdFactory {
+    newId(): string;
+}
+interface CreateHfElementStoreOptions {
+    channel: ElementEventChannel;
+    ids?: IdFactory;
+    /**
+     * Die wirksame Kontextkette — Stufe 3, S1b.
+     *
+     * Wird sie übergeben, kann der Publish-Pfad P-17 tatsächlich prüfen. Fehlt
+     * sie, bleibt die Regel **ungeprüft** und besteht nicht still. Ein Host ohne
+     * Kontextgraph (Flow-FA Pure) lässt sie weg; der Server reicht seinen Adapter
+     * über `contexts/context_inheritance` herein.
+     */
+    contexts?: ContextChainPort;
+    /**
+     * Wie lange ein gelesener Zustand wiederverwendet werden darf, in
+     * Millisekunden. `0` liest bei jedem Zugriff neu. Der Cache ist reine
+     * Beschleunigung und **niemals** Grundlage einer Konfliktentscheidung —
+     * vor jedem Schreibversuch wird frisch gelesen.
+     */
+    cacheMs?: number;
+    now?: () => number;
+}
+/**
+ * Prüfungen, die dieser Port strukturell nicht leisten kann — **heute keine**.
+ *
+ * Bis D-58 stand hier P-01…P-16, mit der Begründung, sie bräuchten Graph- und
+ * Datenbankzugriff. Seitdem laufen sie wirklich, über den `ReferenceResolver`,
+ * den beide Speicher erfüllen; die Konstante ist leer und bleibt als leeres
+ * Rückgabefeld erhalten.
+ *
+ * Was in einem **konkreten** Lauf nicht anwendbar war, steht nicht hier,
+ * sondern in `PublishCheckResult.unchecked` — und nur dort ist es wahr. Die
+ * Konstante als Antwortfeld auszugeben war der Gegenprüffund P3: ein toter
+ * Pfad, der aussah wie eine Aussage.
+ */
+declare const UNCHECKED_PUBLISH_RULES: readonly string[];
+/**
+ * Baut den HF-Elementspeicher.
+ *
+ * Erfüllt `SzenenElementStore` vollständig — dieselbe Schnittstelle, die der
+ * MySQL-Port in Stufe 1d erfüllen muss (Contract-Test, Plan §7).
+ *
+ * Seit D-62 ist dieser Speicher der **autoritative**: HF ist der einzige
+ * Untergrund, den alle drei Hosts haben, und damit der einzige, in dem die eine
+ * fachliche Wahrheit liegen kann. Der Rückgabetyp sagt das jetzt.
+ */
+declare function createHfElementStore(options: CreateHfElementStoreOptions): AuthoritativeSzenenStore & ChainQueries;
+
+interface CreateHfEventChannelOptions {
+    /** HF-Namespace mit abschließendem Schrägstrich, wie in `hfStateService`. */
+    namespace: string;
+    token: string;
+    /**
+     * Nur Events ab diesem Zeitpunkt lesen. Vorgabe `0` — der vollständige Log.
+     *
+     * Ein Snapshot-Mechanismus wie `loadHFState` für Bilder gibt es für Elemente
+     * noch nicht; solange bleibt der volle Log die einzige Wahrheit. Das ist der
+     * Punkt, an dem der Server später beschleunigt (R-2), ohne die einzige
+     * Stelle zu werden, an der eine Invariante gilt.
+     */
+    sinceTs?: number;
+}
+/**
+ * Baut einen `ElementEventChannel` auf dem HF-Dataset.
+ *
+ * Erfordert nur einen HF-Token — kein Server, keine Datenbank. Das ist die
+ * Zusage von R-2 für Flow-FA Pure.
+ */
+declare function createHfEventChannel(options: CreateHfEventChannelOptions): ElementEventChannel;
+
+interface InMemoryEventChannel extends ElementEventChannel {
+    /** Der rohe Log, für Prüfungen. */
+    readonly events: readonly ElementEvent[];
+    /** Hängt ein Fremdevent an — der HF-Kanal wird von mehreren Domains geteilt. */
+    appendRaw(event: ElementEvent): void;
+    /** Ein zweiter Client auf demselben Log. */
+    withClient(clientId: string): InMemoryEventChannel;
+}
+interface CreateInMemoryEventChannelOptions {
+    clientId?: string;
+    /** Monoton steigender Zeitgeber. Der Vorgabewert genügt für Tests. */
+    now?: () => number;
+    /** Gemeinsamer Log, wenn mehrere Clients denselben Kanal teilen. */
+    shared?: ElementEvent[];
+}
+declare function createInMemoryEventChannel(options?: CreateInMemoryEventChannelOptions): InMemoryEventChannel;
+
+/** Ergebnis einer Eingabeprüfung. `null` heißt: in Ordnung. */
+type InputError = {
+    kind: 'error';
+    message: string;
+    retryable: false;
+} | null;
+/**
+ * Eine Revision, wie sie als Precondition taugt: ganzzahlig und nicht negativ.
+ *
+ * `NaN` ist der wichtigste Fall. `Number('abc')` ergibt ihn, und `NaN !== 0`
+ * ist wahr — ohne diese Prüfung wurde daraus ein **Konflikt** statt eines
+ * Eingabefehlers, gemeldet mit `expectedRevision: null`. Der Aufrufer bekam
+ * die Auskunft, jemand anders habe geschrieben; wer daraufhin der
+ * Konfliktregel folgte, scheiterte weiter.
+ */
+declare function checkRevision(value: unknown, field: string): InputError;
+/** Ein Elementtyp aus dem Katalog der zwölf. */
+declare function checkElementType(value: unknown): InputError;
+/** Ein nicht leerer Titel. Reine Leerzeichen zählen nicht. */
+declare function checkTitle(value: unknown): InputError;
+/** Eine optionale Kennung: `null`, `undefined` oder ein nicht leerer Text. */
+declare function checkOptionalId(value: unknown, field: string): InputError;
+/** Eine Kennung, die gesetzt sein muss. */
+declare function checkRequiredId(value: unknown, field: string): InputError;
+/**
+ * Die Parent-Liste einer Veröffentlichung.
+ *
+ * `parents: 'kaputt'` erzeugte zuvor einen `TypeError` aus dem eigenen Code
+ * (`parents.map is not a function`), der als „Dienst nicht verfügbar" beim
+ * Aufrufer ankam — samt interner Fehlermeldung.
+ */
+declare function checkParents(value: unknown): InputError;
+/** Eine Payload, die überhaupt eine sein kann. */
+declare function checkPayloadPresent(value: unknown): InputError;
+/** Die erste greifende Prüfung, oder `null`. */
+declare function firstError(...checks: readonly InputError[]): InputError;
+declare function checkCreateElementInput(input: {
+    type: unknown;
+    title: unknown;
+    subtype?: unknown;
+    contextId?: unknown;
+}): InputError;
+declare function checkWriteDraftInput(input: {
+    elementId: unknown;
+    payload: unknown;
+    expectedRevision: unknown;
+    baseVersionId?: unknown;
+}): InputError;
+declare function checkPublishVersionInput(input: {
+    elementId: unknown;
+    payload: unknown;
+    schemaVersion: unknown;
+    parents?: unknown;
+    publishedBy: unknown;
+}): InputError;
+declare function checkSetPreferredHeadInput(input: {
+    elementId: unknown;
+    contextId: unknown;
+    versionId: unknown;
+    expectedRevision: unknown;
+}): InputError;
+declare function checkReviseMetadataInput(input: {
+    elementId: unknown;
+    title: unknown;
+    expectedRevision: unknown;
+}): InputError;
+/** Bequemlichkeit für Aufrufer, die den Typ eng brauchen. */
+declare const isKnownElementType: (value: unknown) => value is SzenenElementType;
+
+/** Ein Schritt der verglichenen Befehlsfolge. */
+interface DifferentialStep {
+    name: string;
+    /** Führt den Schritt aus und gibt zurück, was verglichen werden soll. */
+    run(store: SzenenElementStore, state: StepState): Promise<unknown>;
+}
+/** Zwischenergebnisse einer Folge — je Port eigene Kennungen. */
+interface StepState {
+    elementId: string;
+    versionIds: string[];
+    draftId: string | null;
+}
+/** Ein Unterschied zwischen den beiden Läufen. */
+interface Divergence {
+    step: string;
+    left: string;
+    right: string;
+}
+interface DifferentialResult {
+    steps: number;
+    divergences: readonly Divergence[];
+    identical: boolean;
+}
+/** Die verglichene Befehlsfolge. Deckt Erfolg, Konflikt, Ablehnung und Lesen ab. */
+declare function differentialSteps(): readonly DifferentialStep[];
+/**
+ * Fährt dieselbe Folge gegen zwei Speicher und vergleicht die Ergebnisse.
+ *
+ * @param left Fabrik für den ersten Speicher, frisch und leer.
+ * @param right Fabrik für den zweiten.
+ */
+declare function runStoreDifferential(left: () => Promise<SzenenElementStore> | SzenenElementStore, right: () => Promise<SzenenElementStore> | SzenenElementStore): Promise<DifferentialResult>;
+
+/** Ein aufrufbares Bildmodell und seine Parametergrenzen. */
+interface CallableImageModel {
+    callable_model_id: string;
+    provider: string;
+    max_images: number;
+    aspect_ratios: readonly string[];
+    supports_seed: boolean;
+}
+/** Die katalogisierte Zuordnung für einen `target_model.key`, oder `null`. */
+declare function callableImageModelFor(targetModelKey: string): CallableImageModel | null;
+/** Der Ausgang der Fähigkeitsauskunft (D-115). */
+type ImageGenerationCapability = {
+    kind: 'supported';
+    target_model_key: string;
+    provider: string;
+    callable_model_id: string;
+    max_images: number;
+    aspect_ratios: readonly string[];
+    supports_seed: boolean;
+} | {
+    kind: 'unsupported';
+    target_model_key: string;
+    reason: string;
+};
+/**
+ * Ob **dieser Host** tatsächlich Zugang zu einem katalogisierten Bildmodell
+ * hat — die einzige Stelle, an der Host-Wissen einfließen darf, und zwar als
+ * Funktionsparameter, nicht als Verzweigung im gemeinsamen Code (R-1).
+ */
+type ImageProviderAccessCheck = (model: CallableImageModel) => boolean;
+/**
+ * Die Fähigkeitsauskunft: aus dem eingefrorenen `target_model` (D-103) und
+ * der Zugangsauskunft des Hosts entsteht `supported` oder `unsupported`.
+ *
+ * `unsupported` ist kein Fehler und blockiert nichts (D-104.5) — der
+ * Prompt-Lauf bleibt vollständig nutzbar und bekommt Ergebnisse über den
+ * externen Importpfad (Teil D).
+ */
+declare function capabilityForTargetModel(targetModel: unknown, hasAccess: ImageProviderAccessCheck): ImageGenerationCapability;
+
+/** Ein tatsächlich vom Provider geliefertes Bild. */
+interface GeneratedImage {
+    imageBase64: string;
+    /** Nur gesetzt, wenn der Provider ihn tatsächlich zurückliefert — nie erfunden (D-107). */
+    seed?: number;
+    model?: string;
+    width?: number;
+    height?: number;
+}
+/** Die Eingabe an den tatsächlichen Provideraufruf — abgeleitet aus dem eingefrorenen Lauf. */
+interface ImageProviderInput {
+    callableModelId: string;
+    provider: string;
+    positivePrompt: string;
+    negativePrompt?: string | null;
+    imageCount: number;
+    aspectRatio?: string;
+    seeds?: readonly number[];
+}
+/**
+ * Der tatsächliche Bildprovider — liegt im Client, wo die Credentials sind
+ * (D-116). Wirft bei einem technischen/Provider-Fehler; liefert bei einem
+ * Teilerfolg weniger Bilder als angefordert, statt zu werfen.
+ */
+interface ImageGenerationProviderPort {
+    generate(input: ImageProviderInput): Promise<{
+        images: readonly GeneratedImage[];
+    }>;
+}
+/** Nur die Lesefähigkeit, die dieser Port braucht — kein voller Run-Port. */
+interface ImageGenerationRunReader {
+    getRun(runId: string): Promise<QueryResult<PromptRunRecord | null>>;
+}
+/**
+ * Die kanonische Persistenz eines fertigen Batches — beim React-Host ein
+ * REST-Aufruf auf denselben Weg wie `SzenenImageBatchWritePort.importBatch`,
+ * nur mit `source_kind: 'generated_in_app'` (Teil C).
+ */
+interface ImageGenerationBatchPersistence {
+    persist(input: {
+        runId: string;
+        generationBatchId: string;
+        images: readonly GeneratedImage[];
+    }): Promise<CommandResult<PromptImageBatch>>;
+}
+/** Was der Auftragskanal (D-119) braucht — lesen und anhängen, wie `RunEventChannel`. */
+interface ImageGenerationEventChannel {
+    appendEvent(type: string, payload: unknown): Promise<void>;
+}
+interface StartImageGenerationInput {
+    runId: string;
+    /** Vom Aufrufer VOR dem Aufruf gebildet (D-113) — deterministisch mit dem Lauf verknüpft. */
+    generationBatchId: string;
+    imageCount: number;
+    aspectRatio?: string;
+    /** Je Bild, wenn das Modell Seeds kennt. */
+    seeds?: readonly number[];
+}
+/** Die vier Ausgänge aus D-111, plus `rejected` für einen ungültigen Lauf. */
+type ImageGenerationResult = {
+    kind: 'succeeded';
+    batch: PromptImageBatch;
+} | {
+    kind: 'partial';
+    batch: PromptImageBatch;
+    requested: number;
+    produced: number;
+} | {
+    kind: 'failed';
+    message: string;
+} | {
+    kind: 'unsupported';
+    targetModelKey: string;
+    reason: string;
+} | {
+    kind: 'rejected';
+    message: string;
+};
+interface SzenenImageGenerationPort {
+    capabilityForRun(runId: string): Promise<QueryResult<ImageGenerationCapability>>;
+    startFromPromptRun(input: StartImageGenerationInput): Promise<ImageGenerationResult>;
+}
+interface CreateImageGenerationPortOptions {
+    runs: ImageGenerationRunReader;
+    provider: ImageGenerationProviderPort;
+    batches: ImageGenerationBatchPersistence;
+    events: ImageGenerationEventChannel;
+    /** Ob dieser Host Zugang zu einem katalogisierten Bildmodell hat (D-115). */
+    hasAccess: ImageProviderAccessCheck;
+    now?: () => Date;
+}
+/** Der gemeinsame Bildgenerierungs-Port. */
+declare function createImageGenerationPort(options: CreateImageGenerationPortOptions): SzenenImageGenerationPort;
+
+/**
+ * Ein Prompt-Lauf starten.
+ *
+ * Die View übergibt, was der Nutzer gewählt hat — nicht, was daraus folgt. Sie
+ * baut **keinen** `RendererInput` und **keinen** Prompt: das tut
+ * `runPromptDerivation()` hinter dem Port, in jedem Host derselbe Code (U20).
+ */
+interface StartRunInput {
+    /** Die veröffentlichte Shot-Version, für die der Lauf läuft. */
+    shotVersionId: string;
+    /** Freitext des Nutzers, optional — geht als Anweisung in den Lauf. */
+    userInstruction?: string;
+    /**
+     * Arbeitskontext. Die wirksame Kette löst der Host über den
+     * `ContextChainPort` auf; die View kennt sie nicht.
+     */
+    contextId?: string | null;
+}
+/** Lesen und Starten von Prompt-Läufen. */
+interface SzenenRunPort {
+    /**
+     * Alle Läufe einer Shot-Version, chronologisch.
+     *
+     * Die **Rundenzählung** macht der Aufrufer mit `roundOfRun()` aus
+     * `itemDerivation.ts` — nicht dieser Port und nicht die View. Sonst gäbe es
+     * zwei Zählungen, und U23 verlangt eine stabile.
+     */
+    listRunsForShot(shotVersionId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+    /** Ein einzelner Lauf, oder `null` bei unbekannter Kennung. */
+    getRun(runId: string): Promise<QueryResult<PromptRunRecord | null>>;
+    /** Startet einen Lauf und liefert das Protokoll des Ergebnisses. */
+    startRun(input: StartRunInput): Promise<CommandResult<PromptRunRecord>>;
+    /**
+     * Startet einen Lauf aus einer **Draft-Kette** — Stufe 6.6, C3 (D-97/D-98).
+     *
+     * Bewusst eine eigene Operation statt eines diskriminierten `StartRunInput`:
+     * Die Bruchwirkung für bestehende Hosts und Tests ist null, und fachlich
+     * gehen beide Wege durch denselben Prompt-Use-Case — die Kette wird
+     * eingefroren, dann läuft dieselbe Ableitung wie bei einer veröffentlichten
+     * Version.
+     *
+     * Vor dem Provideraufruf wird eingefroren. Schlägt das fehl, gibt es **null**
+     * Provideraufrufe.
+     */
+    startRunFromDraft(input: StartRunFromDraftInput): Promise<StartRunFromDraftResult>;
+    /**
+     * Die Läufe einer Draft-Kette.
+     *
+     * `listRunsForShot` bleibt unverändert für veröffentlichte Versionen; ein
+     * Draft-Lauf hat keine, wäre dort also unauffindbar.
+     */
+    listRunsForChain(chainId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+}
+/**
+ * Warum ein Draft-Lauf nicht zustande kam — **drei** verschiedene Auskünfte.
+ *
+ * `CommandResult` kennt nur `error` mit `retryable`, und genau das hat am
+ * 2026-08-13 auf dev zu einer Falschaussage geführt: Ein HF-`429` landete im
+ * `error`-Zweig mit `retryable: true`, und die Ansicht meldete daraufhin „Ein
+ * Entwurf der Kette wurde zwischenzeitlich geändert" — eine Ursache, die es
+ * nicht gab.
+ *
+ * Deshalb sagt diese Operation, **was** los war:
+ *
+ * - `conflict`  — ein Knoten hat sich während des Einfrierens geändert (D-97).
+ *                 Beim nächsten Versuch weg.
+ * - `rejected`  — die Kette selbst ist mangelhaft (offenes Ende, fremde Kette,
+ *                 unvollständiger Shot). Wiederholen hilft nicht, hier muss
+ *                 jemand etwas ändern.
+ * - `error`     — technisch: Netz, Drosselung, Speicher nicht erreichbar. Der
+ *                 Bestand ist in Ordnung.
+ *
+ * In **allen** Fehlerfällen gilt: Es wurde kein Modell gerufen (G23).
+ */
+type StartRunFromDraftResult = {
+    kind: 'ok';
+    value: PromptRunRecord;
+} | {
+    kind: 'unsupported';
+    capability: string;
+} | {
+    kind: 'conflict';
+    message: string;
+    node: {
+        type: DerivableType;
+        element_id: string;
+        draft_id: string;
+    };
+    expectedRevision: number;
+    actualRevision: number;
+} | {
+    kind: 'rejected';
+    message: string;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+interface StartRunFromDraftInput {
+    /** Das Shot-**Element** der Kette. Eine Version gibt es hier gerade nicht. */
+    shotElementId: string;
+    userInstruction?: string;
+    contextId?: string | null;
+}
+/** Ein bereits gespeichertes Item zu einem Lauf. */
+interface RunItemReference {
+    itemId: string;
+    title: string;
+    /** Der abgeleitete Stand, wie ihn Stufe 4 gespeichert hat. */
+    item: DerivedItem | null;
+}
+interface SaveRunAsItemInput {
+    runId: string;
+    title?: string;
+    notes?: string;
+    rating?: number;
+    fskLevel?: string;
+}
+/**
+ * Runde als Item — **optional als Ganzes**.
+ *
+ * Flow-Pure hat keinen MySQL-Zugriff (E4-6) und lässt dieses Feld weg. Die View
+ * zeigt die Aktion dann nicht an. Das ist der `unsupported`-Fall aus R-1 und
+ * braucht in der View keine Zeile Sondercode (U26).
+ */
+interface SzenenItemPort {
+    /**
+     * Das Item zu einem Lauf, ohne es anzulegen.
+     *
+     * Getrennt vom Speichern, weil U25 verlangt, ein bestehendes Item zu
+     * **zeigen** — ein Aufruf, der nebenbei anlegt, könnte das nicht.
+     * Die Kennung ist deterministisch (`itemIdForRun()`); dieser Port schlägt sie
+     * nur nach und leitet nichts zweites ab.
+     */
+    getItemForRun(runId: string): Promise<QueryResult<RunItemReference | null>>;
+    /**
+     * Speichert eine erfolgreiche Runde als Item. Idempotent: eine Wiederholung
+     * liefert dasselbe Item mit `created: false` (U25).
+     */
+    saveRunAsItem(input: SaveRunAsItemInput): Promise<CommandResult<{
+        reference: RunItemReference;
+        created: boolean;
+    }>>;
+}
+/**
+ * Eine Rekonstruktion starten — Stufe 6.5.
+ *
+ * Die View übergibt, was der Nutzer gewählt hat: Regel, Eingang, Text und
+ * Bilder. Sie baut **keinen** Systemprompt und **keinen** Katalog — das tut
+ * `runSceneDerivation()` hinter dem Port, in jedem Host derselbe Code.
+ */
+interface StartDerivationInput {
+    /** Die veröffentlichte `scene_derivation_policy`-Version. */
+    policyVersionId: string;
+    mode: DerivationInputMode;
+    promptText?: string | null;
+    /** Bilder mit Daten **und** Herkunft. Gespeichert wird nur die Herkunft (D-73). */
+    images?: readonly DerivationImage[];
+    contextId?: string | null;
+    /**
+     * Setzt einen Lauf fort (D-87/D-88) — Korrektur nach einem Fehlschlag oder
+     * Ergänzung nach einem gelungenen Lauf. Ohne dieses Feld ist es ein erster
+     * Lauf.
+     *
+     * Die vorige Antwort wird **nicht** mitgeschickt: Der Port liest sie aus dem
+     * Vorgängerlauf. Zweimal übertragen hieße zwei Wahrheiten (R-2).
+     */
+    follows?: {
+        runId: string;
+        /** Was dem Modell vorgehalten wird — vom Menschen bearbeitbar (D-89). */
+        note: string;
+        /** Was nur der Mensch weiß. */
+        userInstruction?: string | null;
+    };
+}
+interface AdoptProposalInput {
+    runId: string;
+    type: DerivableType;
+    title?: string;
+    /**
+     * Die veröffentlichte Vorgängerversion, auf die der Vorschlag zeigt.
+     *
+     * Pflicht für `scene_setup` und `shot`: `versionRef` verlangt eine
+     * veröffentlichte Version (D-03), ein Entwurf genügt nicht (D-72).
+     */
+    referenceVersionId?: string;
+}
+/** Was aus einer Übernahme entsteht — ein **Draft**, nie eine Version. */
+interface AdoptedProposal {
+    runId: string;
+    type: DerivableType;
+    elementId: string;
+}
+interface AdoptGraphInput {
+    /**
+     * Der Ursprung — **genau einer**. Ein Lauf oder eine geprüfte
+     * Arbeitsfassung (D-99), nie beides: Zwei Quellen könnten sich
+     * widersprechen, und dann wäre nicht mehr sagbar, woraus ein Knoten
+     * entstanden ist.
+     */
+    runId?: string;
+    recoveryId?: string;
+    /**
+     * Welche Typen übernommen werden sollen. Ohne Angabe: alle verwertbaren
+     * Vorschläge des Ursprungs.
+     */
+    types?: readonly DerivableType[];
+    /** Titel je Typ, sonst der Vorschlag des Modells (D-83), sonst der Fallback. */
+    titles?: Partial<Record<DerivableType, string>>;
+}
+/** Ein Knoten der entstandenen Kette. */
+interface AdoptedGraphNode {
+    type: DerivableType;
+    elementId: string;
+    draftId: string;
+    revision: number;
+}
+/**
+ * Das Ergebnis einer Graph-Übernahme.
+ *
+ * `missing` ist der ehrliche Teil: Die Speicherports bieten **keine**
+ * Mehr-Element-Transaktion, und 6.6 täuscht deshalb keine Atomizität vor.
+ * Bricht ein Schreibvorgang mitten im Graphen ab, werden die bereits
+ * entstandenen Knoten genannt statt verschwiegen — sonst legte der nächste
+ * Versuch stille Dubletten an.
+ */
+interface AdoptedGraph {
+    chainId: string;
+    sourceRunId: string;
+    sourceRecoveryId?: string;
+    created: readonly AdoptedGraphNode[];
+    /** Typen, die nicht entstanden sind, je mit Grund. */
+    missing: readonly {
+        type: DerivableType;
+        reason: string;
+    }[];
+    /** `true`, wenn alle angeforderten Typen entstanden sind. */
+    complete: boolean;
+}
+/**
+ * Rekonstruktion — **optional als Ganzes**.
+ *
+ * Ein Host ohne Textgenerierungs-Port kann sie nicht anbieten und lässt das
+ * Feld weg. Die View zeigt den Bereich dann gar nicht, statt ihn leer
+ * darzustellen (R11). Das ist derselbe Mechanismus wie bei `items` und
+ * `media` und braucht keine Zeile Sondercode.
+ */
+interface SzenenDerivationPort {
+    /** Die verfügbaren Regeln, aus denen der Nutzer wählt. */
+    listPolicies(contextId?: string | null): Promise<QueryResult<readonly DerivationPolicyOption[]>>;
+    getDerivation(runId: string): Promise<QueryResult<SceneDerivationRecord | null>>;
+    startDerivation(input: StartDerivationInput): Promise<CommandResult<SceneDerivationRecord>>;
+    /**
+     * Übernimmt **einen** Vorschlag als regulären Draft. Kein Publish (6.5-D).
+     *
+     * Der Legacy-Einzelweg: Er verlangt für `scene_setup` und `shot` eine
+     * veröffentlichte Vorgängerversion und spielt damit die Publish-Treppe nach.
+     * Für den Normalfall gibt es seit 6.6 `adoptProposalGraph` — dieser hier
+     * bleibt, weil eine einzelne Übernahme in einen bestehenden, längst
+     * veröffentlichten Zusammenhang weiterhin sinnvoll ist.
+     */
+    adoptProposal(input: AdoptProposalInput): Promise<CommandResult<AdoptedProposal>>;
+    /**
+     * Übernimmt `scene`, `scene_setup` und `shot` als **eine** zusammenhängende
+     * Draft-Kette (D-95/D-96) — der Hauptweg seit 6.6.
+     *
+     * Ein einzelner Nutzerklick darf die alte Publish-Treppe nicht intern
+     * nachspielen. Deshalb ist das **eine** Fachoperation und keine Schleife über
+     * `adoptProposal`: Alle Verträge werden vor dem ersten Schreibzugriff
+     * geprüft, dann entsteht die Kette in einem Zug.
+     */
+    adoptProposalGraph(input: AdoptGraphInput): Promise<CommandResult<AdoptedGraph>>;
+    /**
+     * Prüft einen Text lokal gegen Regel und Katalog des Laufs, **ohne** ihn zu
+     * speichern und **ohne** Provideraufruf.
+     */
+    assessRawOutput(input: AssessRawOutputInput): Promise<QueryResult<RecoveryAssessment>>;
+    /** Speichert eine geprüfte Arbeitsfassung als unveränderlichen Datensatz. */
+    recordRecovery(input: AssessRawOutputInput): Promise<CommandResult<SceneDerivationRecoveryRecord>>;
+    getRecovery(recoveryId: string): Promise<QueryResult<SceneDerivationRecoveryRecord | null>>;
+    /** Alle Arbeitsfassungen eines Laufs, in Anhängereihenfolge. */
+    listRecoveries(runId: string): Promise<QueryResult<readonly SceneDerivationRecoveryRecord[]>>;
+}
+interface AssessRawOutputInput {
+    runId: string;
+    /**
+     * Der zu prüfende Text.
+     *
+     * Fehlt er, wird der unveränderte `raw_output` des Laufs geprüft — der
+     * häufigste erste Schritt: „Was ist an dem, was da steht, überhaupt dran?"
+     */
+    text?: string;
+}
+/**
+ * Das Ergebnis einer lokalen Prüfung — dasselbe, was eine gespeicherte
+ * Arbeitsfassung tragen würde, nur ohne `recovery_id` und `created_at`.
+ *
+ * Bewusst dieselbe Form: Wer erst prüft und dann speichert, soll nicht zwei
+ * verschiedene Ergebnisse anzuschauen bekommen.
+ */
+interface RecoveryAssessment {
+    runId: string;
+    source_text: string;
+    edited: boolean;
+    diagnostics: readonly DerivationDiagnostic[];
+    /** Die verwertbaren Vorschläge. */
+    proposals: readonly RecordedProposal[];
+    /** Die nicht verwertbaren, je mit Begründung. */
+    rejected: readonly UnusableProposal[];
+    status: RecoveryStatus;
+}
+/** Eine wählbare Regel, so wie die Auswahl sie zeigt. */
+interface DerivationPolicyOption {
+    elementId: string;
+    versionId: string;
+    title: string;
+    inputModes: readonly DerivationInputMode[];
+    produces: readonly DerivableType[];
+}
+/** Ein wählbares Bild aus dem Bestand. */
+interface LibraryImage {
+    /**
+     * Die **HF-Bildkennung** (D-93) — der Wert, unter dem das Bild als
+     * `images/<mediaRef>.<ext>` liegt und auf den beide Hosts sich beziehen.
+     *
+     * Ausdrücklich **keine** hostlokale Kennung: Der Laufsatz liegt im
+     * gemeinsamen Ereignislog (D-62), und ein Verweis, den nur die Hälfte der
+     * Leser auflösen kann, ist kein Verweis.
+     */
+    mediaRef: string;
+    title: string;
+    mimeType: string;
+    /** Anzeigbare Quelle für die Kachel, sofern der Host eine liefert. */
+    thumbUrl?: string | null;
+}
+/**
+ * Bilder wählen, auflösen und ablegen — **optional als Ganzes** (D-94).
+ *
+ * Dieselbe Bauform wie `items` und `media` (R11): Ein Host, der keinen
+ * Bildbestand hat, liefert das Feld nicht, und die Ansicht bietet dann nur den
+ * Upload an — sichtbar weniger, nicht stillschweigend kaputt.
+ *
+ * Beide heutigen Hosts liefern ihn: Flow schreibt direkt nach HF, React legt
+ * ein Library-Item mit dem Tag `hf-sync` an, das der bestehende Sync trägt.
+ */
+interface SzenenImageLibraryPort {
+    /** Wählbare Bilder, neueste zuerst. */
+    listImages(query?: {
+        search?: string;
+        limit?: number;
+    }): Promise<QueryResult<readonly LibraryImage[]>>;
+    /** Base64 **ohne** `data:`-Präfix und der MIME-Typ — die Modelleingabe. */
+    resolveImage(mediaRef: string): Promise<QueryResult<{
+        data: string;
+        mime_type: string;
+    }>>;
+    /** Legt ein hochgeladenes Bild ab und gibt seine Kennung zurück (D-91). */
+    putImage(input: {
+        data: string;
+        mime_type: string;
+        title: string;
+    }): Promise<CommandResult<LibraryImage>>;
+}
+interface VersionMedium {
+    assetId: string;
+    role: 'reference' | 'mask' | 'palette' | 'example';
+    position: number;
+    /** Anzeigbare Quelle, sofern der Host eine liefert. */
+    url?: string | null;
+}
+interface ItemMedium {
+    assetId: string;
+    role: string;
+    position: number;
+    url?: string | null;
+}
+/**
+ * Medien — **optional als Ganzes**, weil sie an Stufe 5 hängen.
+ *
+ * Der Port liest und ordnet zu. Er lädt nichts hoch und speichert keine Datei:
+ * das bleibt die Medien-Fassade aus Stufe 5 (`mediaAssetService`), und §6.6
+ * verbietet der UI ausdrücklich einen zweiten Upload-/Save-Weg.
+ */
+interface SzenenMediaPort {
+    listVersionMedia(versionId: string): Promise<QueryResult<readonly VersionMedium[]>>;
+    listItemMedia(itemId: string): Promise<QueryResult<readonly ItemMedium[]>>;
+    attachVersionMedium(input: {
+        versionId: string;
+        assetId: string;
+        role: VersionMedium['role'];
+        position?: number;
+    }): Promise<CommandResult<VersionMedium>>;
+    detachVersionMedium(input: {
+        versionId: string;
+        assetId: string;
+        role: VersionMedium['role'];
+    }): Promise<CommandResult<{
+        removed: boolean;
+    }>>;
+}
+/**
+ * Ein Bild eines Batches, wie der Lesepfad es liefert.
+ *
+ * `asset_id` ist die fachlich stabile Identität, soweit im Host bekannt;
+ * `media_ref` ist der im aktuellen Host auflösbare Locator (z. B. eine
+ * HF-Transportkennung wie `${item_id}-${idx}`). `position` ist Reihenfolge,
+ * keine Identität — sie ersetzt keins von beiden (D-118).
+ */
+interface PromptBatchImageRef {
+    asset_id?: string;
+    media_ref: string;
+    position: number;
+    file?: string;
+    model?: string | null;
+    seed?: number | null;
+    width?: number | null;
+    height?: number | null;
+}
+/**
+ * Ein Generierungsbatch, wie er aus der Library gelesen wird (D-105/D-114).
+ *
+ * Ein Lauf hat genau ein Item (D-113/D-121-Korrektur): wiederholte
+ * „Bilder erzeugen“-Aufrufe desselben Laufs hängen ihre Bilder an dasselbe
+ * Item an, statt eigene Items zu erzeugen. `generation_batch_ids` listet
+ * darum alle bisherigen Provideraufrufe dieses Items, nicht nur den letzten.
+ */
+interface PromptImageBatch {
+    item_id: string;
+    prompt_run_id: string;
+    generation_batch_ids: readonly string[];
+    source_kind: 'generated_in_app' | 'external_import';
+    title: string;
+    images: readonly PromptBatchImageRef[];
+}
+/**
+ * Batch-**Historie lesen** — getrennt vom Schreiben (D-122).
+ *
+ * Eine Host-Grenze beim Library-Schreiben darf die Historie nicht mit
+ * unsichtbar machen: ein Host ohne MySQL (Flow-Pure) liefert diesen Port
+ * heute nicht — der reguläre `unsupported`-Fall, keine Zeile Sondercode
+ * (D-115-Analogie: keine Host-Verzweigung im gemeinsamen Code).
+ */
+interface SzenenImageBatchHistoryPort {
+    /** Alle Batches eines Prompt-Laufs — gesucht über IDs, nicht über Titel/Zeit (D-109). */
+    listBatchesForPromptRun(runId: string): Promise<QueryResult<readonly PromptImageBatch[]>>;
+    /** Ein einzelner Batch über seine `generation_batch_id`, oder `null`. */
+    getBatch(batchId: string): Promise<QueryResult<PromptImageBatch | null>>;
+    /**
+     * Die protokollierten Bildgenerierungsaufträge eines Laufs (D-119).
+     *
+     * Bewusst **getrennt** von `listBatchesForPromptRun`, und nicht dieselbe
+     * Liste: Ein Batch ist ein gespeichertes Library-Item, ein Auftrag ist der
+     * Prozessnachweis eines bezahlten Providerlaufs. Genau der Auftrag, der
+     * zwischen `started` und `finished` abbrach, hat **kein** Item — er wäre in
+     * der Batchliste unsichtbar, und das ist der Fall, für den D-119 existiert.
+     *
+     * Optional, weil ein Host den Library-Read tragen kann, ohne an den
+     * autoritativen Ereignislog zu kommen. Fehlt die Operation, zeigt die
+     * Ansicht die Batches und benennt die fehlende Auftragshistorie als
+     * fehlende Fähigkeit — sie erfindet keine.
+     */
+    listOrdersForPromptRun?(runId: string): Promise<QueryResult<readonly ImageGenerationOrder[]>>;
+}
+/** Ein Bild für den externen Import — vom Nutzer bestätigte Metadaten, nie geraten (D-107/D-117). */
+interface ImportBatchImageInput {
+    imageBase64: string;
+    model?: string;
+    seed?: number;
+    aspectRatio?: string;
+    resolution?: string;
+    width?: number;
+    height?: number;
+}
+interface ImportBatchInput {
+    runId: string;
+    /** Vor dem Aufruf vom Aufrufer gebildet (D-113) — deterministisch mit dem Lauf verknüpft. */
+    generationBatchId: string;
+    images: readonly ImportBatchImageInput[];
+    title?: string;
+}
+interface AttachLibraryItemInput {
+    runId: string;
+    itemId: string;
+}
+/**
+ * Der Ausgang einer Zuordnung — bewusst **kein** `CommandResult`: D-117
+ * Punkt 6/7 verlangt, dass „gehört bereits zu einem anderen Lauf" ein
+ * sichtbarer, benannter Ausgang ist, kein technischer Fehler und kein
+ * stilles Umhängen.
+ */
+type AttachLibraryItemResult = {
+    kind: 'ok';
+    value: PromptImageBatch;
+} | {
+    kind: 'conflict';
+    message: string;
+    existingPromptRunId: string;
+} | {
+    kind: 'unsupported';
+    capability: string;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+/**
+ * Batch-**Schreiben** — getrennt vom Lesen (D-122), Teil D0-D2.
+ *
+ * Beide Operationen sind `generated_in_app` **nicht** gleichgestellt: Sie
+ * rufen keinen Provider, sie legen bereits vorhandene Bilder ab oder
+ * verknüpfen ein bestehendes Item. Ein Host ohne sicheren Batch-Schreibpfad
+ * liefert diesen Port nicht — die Aktion „Externe Bilder zuordnen“ entfällt
+ * dann sichtbar, statt eine Operation anzubieten, die verlorene Bilder
+ * hinterließe.
+ */
+interface SzenenImageBatchWritePort {
+    /** Neue externe Bilder ablegen — derselbe kanonische Schreibweg wie In-App-Batches (D-117). */
+    importBatch(input: ImportBatchInput): Promise<CommandResult<PromptImageBatch>>;
+    /**
+     * Ein bestehendes Library-Item einem Lauf zuordnen, ohne Bilder zu kopieren.
+     * `conflict`, wenn das Item bereits zu einem **anderen** Lauf gehört — kein
+     * stilles Umhängen (D-117 Punkt 6/7).
+     */
+    attachLibraryItem(input: AttachLibraryItemInput): Promise<AttachLibraryItemResult>;
+}
+/**
+ * Alles, was die `SzenenView` von ihrem Host braucht.
+ *
+ * `elements` und `context` sind die **unveränderten** Verträge aus Stufe 1–3.
+ * Sie werden hier nicht neu deklariert, sondern eingehängt: dieselben Typen,
+ * dieselben Implementierungen, dieselben Contract-Tests.
+ */
+interface SzenenViewPort {
+    /** Elementspeicher — Queries und Commands aus Stufe 1. */
+    elements: SzenenQueries & SzenenCommands;
+    /** Wirksame Kontextkette — eigener Port, weil die Vererbung nicht uns gehört. */
+    context: ContextChainPort;
+    /** Prompt-Läufe — Stufe 3/4. */
+    runs: SzenenRunPort;
+    /** Runde als Item — fehlt in Flow-Pure. */
+    items?: SzenenItemPort;
+    /** Medien — fehlt, solange ein Host Stufe 5 nicht anbietet. */
+    media?: SzenenMediaPort;
+    /** Bildbestand — fehlt, wenn ein Host keinen hat (D-94). */
+    imageLibrary?: SzenenImageLibraryPort;
+    /** Rekonstruktion — fehlt ohne Textgenerierungs-Port (Stufe 6.5). */
+    derivation?: SzenenDerivationPort;
+    /** Bild-Batch-Historie — fehlt, solange ein Host keinen MySQL-Zugriff hat (D-122). */
+    imageBatchHistory?: SzenenImageBatchHistoryPort;
+    /** Bild-Batch-Schreiben — fehlt ohne sicheren Batch-Schreibpfad (D-122). */
+    imageBatchWrite?: SzenenImageBatchWritePort;
+    /**
+     * Bildgenerierung aus einem Prompt-Lauf — fehlt, wenn Providerzugang
+     * und/oder sicherer Batch-Schreibpfad fehlen (D-122/Teil F1). Ein Host mit
+     * Provider, aber ohne kanonische Persistenz, darf keinen bezahlten
+     * Bildlauf starten und das Ergebnis danach verlieren.
+     */
+    imageGeneration?: SzenenImageGenerationPort;
+}
+/**
+ * Die Fähigkeiten eines Ports, wie die View sie abfragt.
+ *
+ * Bewusst **abgeleitet** und nicht gesetzt: es gibt kein Feld, das ein Host
+ * falsch befüllen könnte. Wer `items` mitliefert, kann Items — wer nicht, kann
+ * es nicht. Damit kann die Anzeige nie von der Wirklichkeit abweichen.
+ */
+interface SzenenViewCapabilities {
+    saveRunAsItem: boolean;
+    setPreferredHead: boolean;
+    reviseMetadata: boolean;
+    retireElement: boolean;
+    media: boolean;
+    derivation: boolean;
+    imageBatchHistory: boolean;
+    /** Auftragshistorie (D-119) — kann fehlen, obwohl die Batchhistorie da ist. */
+    imageOrderHistory: boolean;
+    imageBatchWrite: boolean;
+    imageGeneration: boolean;
+}
+declare function capabilitiesOf(port: SzenenViewPort): SzenenViewCapabilities;
+/**
+ * Der Grund, den die View anzeigt, wenn eine Aktion fehlt.
+ *
+ * §8 verlangt: fehlende Capability wird als **nicht verfügbare Aktion erklärt**,
+ * nicht als generischer Fehler. Und AGENTS.md Regel 8 verlangt konkrete
+ * Meldungen — deshalb steht die Fähigkeit im Text.
+ */
+declare function unsupportedReason(capability: string): string;
+/**
+ * Hilfsform für optionale Commands: liefert `unsupported` statt zu werfen, wenn
+ * der Host die Operation nicht hat.
+ *
+ * Damit steht der `unsupported`-Fall an genau einer Stelle, statt in jeder
+ * aufrufenden Komponente als `if (!port.items)` aufzutauchen.
+ */
+declare function callOptional<T>(capability: string, operation: (() => Promise<CommandResult<T>>) | undefined): Promise<CommandResult<T>>;
+
+interface CreateHfImageLibraryOptions {
+    namespace: string;
+    token: string;
+    /** Kennungen neuer Bilder. Ersetzbar, damit ein Test nicht würfelt. */
+    newImageId?: () => string;
+    /** Die Uhr — dieselbe Begründung. */
+    now?: () => number;
+}
+declare function createHfImageLibrary(options: CreateHfImageLibraryOptions): SzenenImageLibraryPort;
+
+interface CreateMemoryViewPortOptions {
+    /**
+     * Ob der Port Items anbietet. `false` bildet Flow-Pure nach: das Feld fehlt
+     * dann ganz, statt eine Operation zu haben, die `unsupported` zurückgibt.
+     * Der Unterschied ist der Punkt — U26 verlangt, dass die View damit ohne
+     * Sondercode umgeht.
+     */
+    items?: boolean;
+    /** Ob der Port Medien anbietet (Stufe 5 vorhanden). */
+    media?: boolean;
+    /**
+     * Ob der Port einen Bildbestand anbietet (D-94).
+     *
+     * `false` bildet einen Host ohne ihn ab: Der Bereich zeigt dann nur den
+     * Upload, und ein Folgelauf ohne Bild wird mit Grund abgelehnt.
+     */
+    imageLibrary?: boolean;
+    /** Vorbelegte Bilder des Bestands. */
+    images?: readonly LibraryImage[];
+    /**
+     * Ob der Port die Rekonstruktion anbietet (Stufe 6.5).
+     *
+     * `false` bildet einen Host ohne Textgenerierungs-Port ab. Der Bereich
+     * „0 · Rekonstruktion" fehlt dann ganz, statt leer zu erscheinen (R11).
+     */
+    derivation?: boolean;
+    /** Vorbelegte Regeln, aus denen die Auswahl liest. */
+    policies?: readonly DerivationPolicyOption[];
+    /** Erzeugt den Rekonstruktionslauf. Voreingestellt ein erfolgreicher. */
+    deriveScene?: (input: StartDerivationInput, runId: string) => SceneDerivationRecord;
+    /**
+     * Erzeugt den Lauf. Voreingestellt ist ein erfolgreicher Lauf mit
+     * erkennbarem Simulationsprovider — Pflichtnachweis 5 verlangt, dass eine
+     * Simulation als solche sichtbar bleibt.
+     */
+    deriveRun?: (input: StartRunInput, runId: string) => PromptRunRecord;
+    /** Vorbelegte Läufe. */
+    runs?: readonly PromptRunRecord[];
+    ids?: () => string;
+    /**
+     * Ob der Port Bild-Batch-Historie anbietet (Stufe 6.7, D-122).
+     *
+     * `false` bildet einen Host ohne MySQL-Zugriff ab (Flow-Pure): der
+     * Bereich zeigt dann keine Batch-Historie, statt leer zu erscheinen (R11).
+     */
+    imageBatchHistory?: boolean;
+    /** Vorbelegte Batches, aus denen `listBatchesForPromptRun`/`getBatch` lesen. */
+    batches?: readonly PromptImageBatch[];
+    /**
+     * Ob der Port Bild-Batch-Schreiben anbietet (Stufe 6.7, D-122, Teil D0-D2).
+     *
+     * `false` bildet einen Host ohne sicheren Batch-Schreibpfad ab: „Externe
+     * Bilder zuordnen" entfällt dann sichtbar, statt Bilder zu verlieren.
+     */
+    imageBatchWrite?: boolean;
+    /**
+     * Ob der Port Bildgenerierung anbietet (Stufe 6.7, Teil F1, D-122).
+     *
+     * `false` bildet einen Host ohne Providerzugang und/oder ohne sicheren
+     * Batch-Schreibpfad ab: „Bilder erzeugen" entfällt dann sichtbar.
+     */
+    imageGeneration?: boolean;
+    /** Simulierter Provideraufruf — Voreinstellung liefert `imageCount` Bilder. */
+    imageProvider?: ImageGenerationProviderPort;
+    /** Ob der simulierte Host Zugang zum katalogisierten Zielmodell hat. Default: immer. */
+    imageProviderHasAccess?: ImageProviderAccessCheck;
+}
+declare function createMemoryViewPort(options?: CreateMemoryViewPortOptions): SzenenViewPort;
+
+interface CreateFlowSzenenViewPortOptions {
+    /**
+     * Der Textzugang des Flow-SDK. Entfaellt, wenn `textPort` gesetzt ist — ein
+     * Browser ausserhalb von Flow hat kein `Flow.generate.text`.
+     */
+    generateText?: FlowGenerateText;
+    /**
+     * Ein fertiger Textgenerierungs-Port statt des Flow-SDK.
+     *
+     * Der React-Client im Canvas hat kein `Flow.generate.text`, wohl aber einen
+     * eigenen Zugang zum Modell. Er reicht seinen Port hier herein; alles
+     * andere — Elementspeicher, Lauf, Protokoll — ist in beiden Clients derselbe
+     * Code.
+     */
+    textPort?: TextGenerationPort;
+    /** Existing channel for tests or embedded hosts. Otherwise HF credentials are required. */
+    channel?: ElementEventChannel;
+    namespace?: string;
+    token?: string;
+    context?: ContextChainPort;
+    ids?: IdFactory;
+    /**
+     * Der Bildbestand (D-94). Ohne HF-Zugangsdaten gibt es keinen — dann fehlt
+     * das Feld, und die Ansicht bietet nur den Upload an.
+     */
+    imageLibrary?: SzenenImageLibraryPort;
+    newRunId?: () => string;
+    now?: () => Date;
+}
+/**
+ * Complete Flow adapter for the shared SzenenView: authoritative HF elements
+ * and runs plus Flow.generate.text. Server-only item commands stay absent.
+ */
+declare function createFlowSzenenViewPort(options: CreateFlowSzenenViewPortOptions): SzenenViewPort;
+
+interface CreateBrowserTextGenerationPortOptions {
+    /**
+     * Der Google-Schlüssel des Clients, falls vorhanden.
+     *
+     * **Fehlen ist hier kein Fehler**, anders als im Serveradapter. Ohne
+     * Schlüssel geht die Anfrage ohne `?key=` raus — das ist der Canvas-Modus,
+     * und er ist der eigentliche Zweck dieses Ports. Ein Browser, der irrtümlich
+     * ohne Schlüssel läuft, bekommt vom Provider ein HTTP 401 und damit einen
+     * sichtbaren `provider_error`; still erfundene Antworten gibt es nicht.
+     */
+    apiKey?: string | null;
+    modelId?: string;
+    /** Für Tests. Vorgabe ist das `fetch` der Umgebung. */
+    fetchImpl?: typeof fetch;
+}
+/** Baut den Textgenerierungs-Port für einen Browser mit Google-Zugang. */
+declare function createBrowserTextGenerationPort(options?: CreateBrowserTextGenerationPortOptions): TextGenerationPort;
+
+/**
+ * Der Speicher für Prompt-Läufe, host-neutral.
+ *
+ * Bewusst **kein** Ereigniskanal: Flow hat einen, React nicht. Ein
+ * `appendEvent` im Vertrag hätte React gezwungen, eines nachzubauen, und den
+ * REST-Weg zu einem Sonderfall gemacht. Was der Use-Case wirklich braucht, ist
+ * schmaler — einen fertigen Record ablegen und Läufe wiederfinden.
+ *
+ * Der Port **interpretiert nichts**: Er baut keinen Record, liest keine
+ * Providerantwort und leitet keine Runde ab. Er speichert, was er bekommt.
+ */
+interface PromptRunPersistencePort {
+    listForShot(shotVersionId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+    get(runId: string): Promise<QueryResult<PromptRunRecord | null>>;
+    /** Legt den fertigen Lauf autoritativ ab. Ohne Bestätigung gibt es keinen Lauf. */
+    record(record: PromptRunRecord): Promise<CommandResult<PromptRunRecord>>;
+    /**
+     * Die Läufe einer Draft-Kette — Stufe 6.6 (C3).
+     *
+     * Ein Draft-Lauf hat keine Shot-Version und wäre über `listForShot`
+     * unauffindbar. Der bestehende Vertrag bleibt für veröffentlichte Versionen
+     * unverändert.
+     */
+    listForChain(chainId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+}
+/** Was der Eventlog-Adapter vom Kanal braucht — lesen und anhängen. */
+interface RunEventChannel {
+    readEvents(): Promise<readonly ElementEvent[]>;
+    appendEvent(type: string, payload: unknown): Promise<void>;
+}
+/**
+ * Die Persistenz über das Ereignislog — der Weg, den Flow schon geht.
+ *
+ * Der Lauf ist append-only und unveränderlich; das Log trägt diese Form nativ
+ * (`promptRunStore.ts`). Gelesen wird mit **derselben** Projektion wie überall,
+ * damit ein zweiter Eintrag zur gleichen `run_id` hier nicht anders ausgelegt
+ * wird als dort.
+ */
+declare function createEventLogRunPersistence(channel: RunEventChannel): PromptRunPersistencePort;
+interface CreateClientRunPortOptions {
+    /** Leseseite des Elementspeichers — für Auflösung und Kontextermittlung. */
+    elements: SzenenQueries;
+    context: ContextChainPort;
+    text: TextGenerationPort;
+    runs: PromptRunPersistencePort;
+    newRunId?: () => string;
+    now?: () => Date;
+}
+/** Der gemeinsame Prompt-Lauf als `SzenenRunPort`. */
+declare function createClientRunPort(options: CreateClientRunPortOptions): SzenenRunPort;
+
+type IntegrityVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Prüft einen eingereichten Prompt-Lauf.
+ *
+ * Die Meldung nennt das Feld, um das es geht — eine Ablehnung, die nur „ungültig"
+ * sagt, lässt den Aufrufer raten (AGENTS.md Regel 8).
+ */
+declare function checkPromptRunRecord(candidate: unknown): IntegrityVerdict;
+/**
+ * Prüft einen eingereichten Rekonstruktionslauf.
+ *
+ * **Was hier nicht geprüft wird, und warum:** Ob die Vorschläge zur Aufgabe
+ * passen, entscheidet `checkDerivationResponse()` — die braucht aber Regel *und*
+ * Katalog, und beide stehen nicht im Record (D-73 friert die Eingabe ohne
+ * Katalog ein). Sie nachträglich neu zu bilden hieße, gegen einen inzwischen
+ * veränderten Bestand zu prüfen: dasselbe Ergebnis würde je nach Zeitpunkt
+ * anders beurteilt. Deshalb prüft die Annahmestelle die Zusagen, die im Record
+ * selbst nachweisbar sind — Struktur, Widerspruchsfreiheit, D-73 und D-82 —, und
+ * behauptet nicht mehr, als sie wissen kann.
+ */
+declare function checkSceneDerivationRecord(candidate: unknown): IntegrityVerdict;
+/**
+ * Prüft eine eingereichte Arbeitsfassung — Stufe 6.6, A3 (D-99).
+ *
+ * **Was hier nicht geprüft wird, und warum:** Ob die Vorschläge zur Aufgabe
+ * passen, kann die Annahmestelle so wenig entscheiden wie beim Lauf selbst —
+ * dafür bräuchte sie Regel *und* Katalog von jetzt, und beide stehen nicht im
+ * Datensatz. Geprüft wird deshalb, was im Datensatz nachweisbar ist: Struktur,
+ * der Zusammenhang von `status` und `proposals`, und dass jeder Befund die
+ * Form aus A1 hat.
+ *
+ * Ausdrücklich **nicht** geprüft wird, ob der Ursprungslauf existiert oder ob
+ * er einen `raw_output` hatte. Das ist eine Bestandsfrage, keine Formfrage,
+ * und sie gehört dorthin, wo der Bestand liegt — sonst prüfte diese Funktion
+ * gegen etwas, das sie nicht sehen kann.
+ */
+declare function checkSceneDerivationRecoveryRecord(candidate: unknown): IntegrityVerdict;
+
+/** Welche Elementtypen als Katalogeintrag für einen Vorschlag taugen. */
+declare const CATALOGUE_TYPES: readonly ["camera_preset", "camera_pattern", "style", "shot_concept", "target_model"];
+/** Der Ausschnitt eines Element-Stores, den die Auflösung braucht. */
+interface PublishedHeadSource {
+    listElements(filter: Record<string, unknown>): Promise<QueryResult<readonly {
+        element_id: string;
+        title?: string | null;
+    }[]>>;
+    getElement(elementId: string): Promise<QueryResult<{
+        element: {
+            context_id?: string | null;
+        };
+        metadata?: {
+            title?: string | null;
+        } | null;
+        versions?: readonly {
+            version_id: string;
+            payload?: unknown;
+        }[];
+        preferredHeads?: readonly unknown[];
+    } | null>>;
+}
+interface PublishedHead {
+    type: string;
+    element_id: string;
+    version_id: string;
+    title: string;
+    payload: unknown;
+}
+interface CatalogueEntry {
+    type: string;
+    element_id: string;
+    version_id: string;
+    title: string;
+}
+/**
+ * Die veröffentlichten Köpfe eines Elementtyps, mit Payload.
+ *
+ * Eine Stelle für zwei Aufrufer — den Katalog und die Regelauswahl. Die
+ * Elementliste allein genügt für beides nicht: sie trägt Stammsätze ohne
+ * Version und ohne Payload, und die Auflösung des Preferred Head ist eine
+ * fachliche Entscheidung (D-36), die nicht zweimal nachgebaut werden darf.
+ */
+declare function publishedHeadsOf(store: PublishedHeadSource, type: string, contextId?: string | null): Promise<PublishedHead[]>;
+/**
+ * Baut den Katalog wählbarer Versionen für einen Kontext.
+ *
+ * Ohne ihn müsste das Modell Versionskennungen erfinden, und eine erfundene
+ * UUID sieht aus wie eine echte. Es bekommt deshalb die Auswahl vorgelegt.
+ */
+declare function catalogueFor(store: PublishedHeadSource, contextId?: string | null): Promise<CatalogueEntry[]>;
+/** Die Regelauswahl der Rekonstruktion — dieselbe Auflösung, anderer Typ. */
+declare function derivationPoliciesOf(store: PublishedHeadSource, contextId?: string | null): Promise<Array<{
+    elementId: string;
+    versionId: string;
+    title: string;
+    inputModes: readonly string[];
+    produces: readonly DerivableType[];
+}>>;
+
+/** Was dieser Port vom Elementspeicher braucht. */
+interface ClientDerivationStore extends PublishedHeadSource {
+    getVersion(versionId: string): Promise<QueryResult<{
+        element_id: string;
+        type: string;
+        payload: Record<string, unknown>;
+        visible?: boolean;
+    } | null>>;
+    createElement(input: {
+        type: string;
+        subtype: string | null;
+        contextId: string | null;
+        title: string;
+        description?: string;
+    }): Promise<CommandResult<{
+        element_id: string;
+        revision?: number;
+    }>>;
+    writeDraft(input: {
+        elementId: string;
+        payload: Record<string, unknown>;
+        baseVersionId: string | null;
+        expectedRevision: number;
+        /** Kettenmetadaten (Stufe 6.6, D-96). Weggelassen laesst sie unveraendert. */
+        chain?: DraftChainMeta | null;
+    }): Promise<CommandResult<{
+        draft_id: string;
+        revision: number;
+    }>>;
+}
+/**
+ * Der Speicher für Rekonstruktionsläufe, host-neutral.
+ *
+ * Bewusst **kein** Ereigniskanal: Flow hat einen, React nicht — dort führt der
+ * Weg über REST zum Node-Server, der anhängt und projiziert. Ein `appendEvent`
+ * im Vertrag hätte React gezwungen, ein Log nachzubauen, und den REST-Weg zum
+ * Sonderfall gemacht.
+ *
+ * Der Port **interpretiert nichts**: Er baut keinen Record, liest keine
+ * Providerantwort und leitet keinen Draft ab. Er speichert, was er bekommt.
+ */
+interface SceneDerivationPersistencePort {
+    get(runId: string): Promise<QueryResult<SceneDerivationRecord | null>>;
+    /** Legt den fertigen Lauf autoritativ ab. Ohne Bestätigung gibt es keinen Lauf. */
+    record(record: SceneDerivationRecord): Promise<CommandResult<SceneDerivationRecord>>;
+    /** Eine einzelne Arbeitsfassung, oder `null`. */
+    getRecovery(recoveryId: string): Promise<QueryResult<SceneDerivationRecoveryRecord | null>>;
+    /** Alle Arbeitsfassungen eines Laufs, in Anhängereihenfolge. */
+    listRecoveries(runId: string): Promise<QueryResult<readonly SceneDerivationRecoveryRecord[]>>;
+    /** Legt eine Arbeitsfassung autoritativ ab. Sie überschreibt nie den Lauf. */
+    recordRecovery(record: SceneDerivationRecoveryRecord): Promise<CommandResult<SceneDerivationRecoveryRecord>>;
+}
+/** Was der Ereignislog-Adapter vom Kanal braucht — lesen und anhängen. */
+interface ClientDerivationChannel {
+    readEvents(): Promise<readonly ElementEvent[]>;
+    appendEvent(type: string, payload: unknown): Promise<void>;
+}
+/**
+ * Die Persistenz über das Ereignislog — der Weg, den Flow geht.
+ *
+ * Gelesen wird mit **derselben** Projektion wie überall
+ * (`collectSceneDerivations`), damit ein doppelter Eintrag zur gleichen `run_id`
+ * hier nicht anders ausgelegt wird als dort.
+ */
+declare function createEventLogDerivationPersistence(channel: ClientDerivationChannel): SceneDerivationPersistencePort;
+interface CreateClientDerivationPortOptions {
+    store: ClientDerivationStore;
+    derivations: SceneDerivationPersistencePort;
+    text: TextGenerationPort;
+    /**
+     * Der Bildbestand (D-91/D-94). Fehlt er, bleibt alles beim Alten: Uploads
+     * werden als `upload` eingefroren und sind nach der Sitzung weg.
+     *
+     * Ist er da, geht **jedes** hochgeladene Referenzbild vor dem Lauf in den
+     * Bestand, und der Lauf verweist darauf. Erst dadurch ist ein Folgelauf
+     * später überhaupt möglich (D-87).
+     */
+    images?: SzenenImageLibraryPort;
+    newRunId?: () => string;
+    now?: () => Date;
+}
+declare function createClientDerivationPort(options: CreateClientDerivationPortOptions): SzenenDerivationPort;
+
+type SzenenAreaId = 'derive' | 'elements' | 'scene' | 'setup' | 'shot' | 'media';
+interface SzenenArea {
+    id: SzenenAreaId;
+    title: string;
+    /** Was der Bereich leistet — auch die Erklärung, wenn er fehlt. */
+    description: string;
+}
+/**
+ * Die Bereiche, die dieser Host trägt.
+ *
+ * `media` und `derive` fallen weg, wenn der Port die zugehörige Fähigkeit nicht
+ * hat — die einzigen Stellen, an denen ein Bereich verschwinden kann, und beide
+ * lesen eine Fähigkeit, keinen Hostnamen. Alle anderen Bereiche gibt es immer:
+ * ein Host ohne Elementspeicher wäre kein Szenen-Host.
+ *
+ * Ein leerer Bereich wäre die schlechtere Antwort: Er verspräche eine Aktion,
+ * die dieser Host nicht ausführen kann, und der Nutzer suchte den Fehler bei
+ * sich.
+ */
+declare function areasFor(port: SzenenViewPort): readonly SzenenArea[];
+/** Ob eine gespeicherte Bereichswahl in diesem Host noch gilt. */
+declare function resolveArea(port: SzenenViewPort, gewuenscht: SzenenAreaId | null | undefined): SzenenAreaId;
+/**
+ * Wie ein Kommandoergebnis dem Nutzer erklärt wird.
+ *
+ * §8 verlangt getrennte Darstellung: ein Konflikt ist kein Fehler, eine
+ * abgelehnte Veröffentlichung ist kein Fehler, und eine fehlende Fähigkeit ist
+ * erst recht keiner. Diese Funktion ist die eine Stelle, an der aus einem
+ * Ergebnis ein Text wird — damit keine Komponente eigene Formulierungen und
+ * eigene Einordnungen erfindet.
+ */
+type NoticeTone = 'ok' | 'conflict' | 'rejected' | 'unsupported' | 'error';
+interface Notice {
+    tone: NoticeTone;
+    text: string;
+    /** Einzelbefunde, etwa Publish-Regelverstöße — nie zu einem Satz verklebt. */
+    details?: readonly string[];
+}
+declare function noticeFor(ergebnis: {
+    kind: string;
+    [k: string]: unknown;
+}, was: string): Notice;
+
+interface SzenenViewProps {
+    port: SzenenViewPort;
+    /** Arbeitskontext. Die wirksame Kette löst der Port auf, nicht die View. */
+    contextId?: string | null;
+    /** Startbereich; eine ungültige Angabe fällt auf den ersten verfügbaren zurück. */
+    initialArea?: SzenenAreaId;
+    /** Meldet Bereichswechsel nach außen, damit der Host sie merken kann. */
+    onAreaChange?: (area: SzenenAreaId) => void;
+}
+declare const SzenenView: React__default.FC<SzenenViewProps>;
+
+export { AuthoritativeSzenenStore, CATALOGUE_TYPES, type CallableImageModel, CapabilityAnchorError, type CapabilityFlag, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClientDerivationChannel, type ClientDerivationStore, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateImageGenerationPortOptions, type CreateMemoryViewPortOptions, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, type ElementEvent, type ElementEventChannel, ElementSnapshot, type ElementStoreState, type ExistingSzenenItem, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSuccess, type FrozenChainNode, type GeneratedImage, type IdFactory, type ImageGenerationBatchPersistence, type ImageGenerationCapability, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, ImageProvenance, type ImageProviderAccessCheck, type ImageProviderInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LibraryImage, type NodeContribution, NotDerivable, type Notice, type NoticeTone, type PromptRunOutcome, type PromptRunOutput, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, type ReducerFinding, ReferenceResolver, type RendererInput, type ResolveFailure, type ResolveResult, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_EVENT_PREFIX, SZENEN_EVENT_TYPES, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, SchemaError, type StartImageGenerationInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UnusableProposal, type VersionMedium, type VisibilityNode, areasFor, buildSystemInstruction, buildUserPrompt, callOptional, callableImageModelFor, capabilitiesOf, capabilityForTargetModel, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, collectImageGenerationOrders, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageLibrary, createImageGenerationPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, differentialSteps, draftRevisionOf, findImageGenerationOrder, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, freezeDraftChain, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, logRevisionOf, mergeSzenenBatchOrigin, noticeFor, ordersForPromptRun, parseRunResponse, preferredHeadRevisionOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveShot, resolveShotPayload, roundOfRun, runPromptDerivation, runStoreDifferential, scopeOfPath, totalModelCalls, unclassifiedPublishRules, unsupportedReason };