@rslsp1/fa-app-tools 10.0.1 → 10.3.2

package/dist/szenen.d.mts

@@ -1,9 +1,9 @@
-import { J as ElementEvent, ad as PublishFinding, av as SchemaError, ac as PublishCheckResult, aC as SzenenElementType, aj as ReferenceResolver, aJ as TargetModelResolution, a3 as PreferredHeadResolution, a0 as PageRequest, X as LibraryTagRef, a8 as PromptRunAnnotation, $ as Page, y as DerivationInputMode, U as ImageProvenance, u as DerivationFailure, p as DerivableType, Y as NotDerivable, r as DerivationConflict, w as DerivationFollowUp, F as DraftChainMeta, s as DerivationDiagnostic, q as DerivationAssessment, j as ContextChainPort, c as AuthoritativeSzenenStore, aB as SzenenElementStore, x as DerivationImage, aE as SzenenQueries, aA as SzenenCommands, aL as UnusableProposal, I as ElementAnnotation } from './storeContract-CJi0fpCA.mjs';
-export { A as ALL_PUBLISH_RULES, a as AngezeigterTag, b as AnnotateRunsOptions, C as CHAIN_EDGES, d as CHAIN_LINK_FIELDS, e as CatalogueEntry, f as ChainLinkField, g as ChainTarget, h as ChainVerdict, i as CompiledSchemas, k as ContractCheck, l as ContractCheckResult, m as ContractRunResult, n as ContractViolation, o as CreateElementInput, D as DERIVABLE_TYPES, t as DerivationEnvelope, v as DerivationFailureClass, z as DerivationPolicyPayload, B as DerivationProposal, E as DraftChainLink, G as DraftFork, H as DraftRecord, K as ElementListFilter, L as ElementMetadata, M as ElementRecord, N as ElementSnapshot, O as ElementStoreContractHarness, P as ElementStoreState, Q as ElementVersionValidation, R as FindingSeverity, S as ImageBatchPersistedImage, T as ImageBatchPersistedPayload, V as KEINE_BILDER, W as LOAD_MORE_PAGE_SIZE, Z as OptionalCommand, _ as PROBE_VERSION_ID, a1 as ParentRelation, a2 as PreferredHeadOutcome, a4 as PreferredHeadSelection, a5 as PreferredHeadSource, a6 as ProjectionState, a7 as ProjectionStatus, a9 as PromptRunPreviewImage, aa as PromptRunTagsSetPayload, ab as PublishCheckInput, ae as PublishRejected, af as PublishVersionInput, ag as PublishedVersion, ah as REFERENCE_FIELD, ai as ReducerFinding, ak as ResolvePreferredHeadOptions, al as ResolvedVersion, am as ReviseMetadataInput, an as STYLE_PAYLOAD, ao as STYLE_PAYLOAD_V2, ap as SZENEN_ELEMENT_TYPES, aq as SZENEN_EVENT_PREFIX, ar as SZENEN_EVENT_TYPES, as as SceneDerivationInput, at as SceneDerivationOutcome, au as SceneDerivationOutput, aw as SchemaValidationResult, ax as SetPreferredHeadInput, ay as StoreAuthority, az as SzenenCommandResult, aD as SzenenProjection, aF as TagHerkunft, aG as TargetModelCandidate, aH as TargetModelQueries, aI as TargetModelQuery, aK as UnsupportedSchemaError, aM as VersionDag, aN as VersionDagError, aO as VersionNode, aP as VersionParentLink, aQ as WriteConflict, aR as WriteDraftInput, aS as annotateElementsFromEvents, aT as annotateRunsFromEvents, aU as assessDerivationResponse, aV as buildDerivationSystemInstruction, aW as buildDerivationUserPrompt, aX as buildVersionDag, aY as checkChainTargets, aZ as checkDerivationResponse, a_ as checkDraftChainMeta, a$ as collectPromptRunTags, b0 as collectVersionRefs, b1 as compileSchemas, b2 as createSimulationSceneDerivationPort, b3 as describeTargetModelFailure, b4 as draftRevisionOf, b5 as elementStoreContractChecks, b6 as formatSchemaErrors, b7 as getSzenenSchemas, b8 as isOk, b9 as isProjectionCurrent, ba as labelsOf, bb as linkFor, bc as listElementsPageOver, bd as logRevisionOf, be as mergeRunTags, bf as pageOf, bg as pageRequestFrom, bh as parseDerivationResponse, bi as preferredHeadRevisionOf, bj as preferredVersionId, bk as promptRunTagsOf, bl as reduceElementEvents, bm as resolvePreferredHead, bn as resolveTargetModelOver, bo as resolverFromQueries, bp as runElementStoreContract, bq as runPublishChecks, br as runSceneDerivation, bs as showChain, bt as tagRefsAus, bu as validateAgainst, bv as validateDerivationInput, bw as validateElementVersion, bx as validatePayload, by as withReference } from './storeContract-CJi0fpCA.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 { g as HFStateSnapshot, F as FlowGenerateText } from './hfEventTypes-BUztJySs.mjs';
-export { C as CreateFlowTextGenerationPortOptions, r as createFlowTextGenerationPort } from './hfEventTypes-BUztJySs.mjs';
+import { K as ElementEvent, a9 as PromptConstructionTag, G as DraftChainMeta, am as ReferenceResolver, q as DerivableType, a4 as PreferredHeadResolution, ag as PublishFinding, ay as SchemaError, af as PublishCheckResult, aF as SzenenElementType, aM as TargetModelResolution, a1 as PageRequest, Y as LibraryTagRef, aa as PromptRunAnnotation, a0 as Page, Q as ElementStoreState, z as DerivationInputMode, V as ImageProvenance, v as DerivationFailure, Z as NotDerivable, s as DerivationConflict, x as DerivationFollowUp, t as DerivationDiagnostic, r as DerivationAssessment, k as ContextChainPort, d as AuthoritativeSzenenStore, aE as SzenenElementStore, y as DerivationImage, aH as SzenenQueries, aD as SzenenCommands, aO as UnusableProposal, J as ElementAnnotation } from './storeContract-Cc8tFavd.mjs';
+export { A as ALL_PUBLISH_RULES, a as AngezeigterTag, b as AnnotateElementsOptions, c as AnnotateRunsOptions, C as CHAIN_EDGES, e as CHAIN_LINK_FIELDS, f as CatalogueEntry, g as ChainLinkField, h as ChainTarget, i as ChainVerdict, j as CompiledSchemas, l as ContractCheck, m as ContractCheckResult, n as ContractRunResult, o as ContractViolation, p as CreateElementInput, D as DERIVABLE_TYPES, u as DerivationEnvelope, w as DerivationFailureClass, B as DerivationPolicyPayload, E as DerivationProposal, F as DraftChainLink, H as DraftFork, I as DraftRecord, L as ElementListFilter, M as ElementMetadata, N as ElementRecord, O as ElementSnapshot, P as ElementStoreContractHarness, R as ElementVersionValidation, S as FindingSeverity, T as ImageBatchPersistedImage, U as ImageBatchPersistedPayload, W as KEINE_BILDER, X as LOAD_MORE_PAGE_SIZE, _ as OptionalCommand, $ as PROBE_VERSION_ID, a2 as ParentRelation, a3 as PreferredHeadOutcome, a5 as PreferredHeadSelection, a6 as PreferredHeadSource, a7 as ProjectionState, a8 as ProjectionStatus, ab as PromptRunPreviewImage, ac as PromptRunTagsSetPayload, ad as PromptTagSelector, ae as PublishCheckInput, ah as PublishRejected, ai as PublishVersionInput, aj as PublishedVersion, ak as REFERENCE_FIELD, al as ReducerFinding, an as ResolvePreferredHeadOptions, ao as ResolvedVersion, ap as ReviseMetadataInput, aq as STYLE_PAYLOAD, ar as STYLE_PAYLOAD_V2, as as SZENEN_ELEMENT_TYPES, at as SZENEN_EVENT_PREFIX, au as SZENEN_EVENT_TYPES, av as SceneDerivationInput, aw as SceneDerivationOutcome, ax as SceneDerivationOutput, az as SchemaValidationResult, aA as SetPreferredHeadInput, aB as StoreAuthority, aC as SzenenCommandResult, aG as SzenenProjection, aI as TagHerkunft, aJ as TargetModelCandidate, aK as TargetModelQueries, aL as TargetModelQuery, aN as UnsupportedSchemaError, aP as VersionDag, aQ as VersionDagError, aR as VersionNode, aS as VersionParentLink, aT as WriteConflict, aU as WriteDraftInput, aV as annotateElementsFromEvents, aW as annotateRunsFromEvents, aX as annotatedElementsPageOver, aY as assessDerivationResponse, aZ as buildDerivationSystemInstruction, a_ as buildDerivationUserPrompt, a$ as buildVersionDag, b0 as checkChainTargets, b1 as checkDerivationResponse, b2 as checkDraftChainMeta, b3 as collectPromptRunTags, b4 as collectVersionRefs, b5 as compileSchemas, b6 as createSimulationSceneDerivationPort, b7 as describeTargetModelFailure, b8 as draftRevisionOf, b9 as effectivePromptVocabulary, ba as elementStoreContractChecks, bb as elementsByActivity, bc as formatSchemaErrors, bd as getSzenenSchemas, be as isOk, bf as isProjectionCurrent, bg as labelsOf, bh as linkFor, bi as listElementsPageOver, bj as logRevisionOf, bk as mergeRunTags, bl as pageOf, bm as pageRequestFrom, bn as parseDerivationResponse, bo as preferredHeadRevisionOf, bp as preferredVersionId, bq as promptRunTagsOf, br as promptTagGroup, bs as reduceElementEvents, bt as resolvePreferredHead, bu as resolvePromptConstructionTags, bv as resolveTargetModelOver, bw as resolverFromQueries, bx as runElementStoreContract, by as runPublishChecks, bz as runSceneDerivation, bA as showChain, bB as tagRefsAus, bC as validateAgainst, bD as validateDerivationInput, bE as validateElementVersion, bF as validatePayload, bG as withReference } from './storeContract-Cc8tFavd.mjs';
+import { T as TextGenerationImage, c as TextGenerationPort, Q as QueryResult, C as CommandResult } from './contracts-B3AbzYQ4.mjs';
+export { S as SIMULATION_PROVIDER, d as TextGenerationRequest, e as TextGenerationResult, h as createFakeTextGenerationPort, i as createSimulationTextGenerationPort, s as simulatedAnswerFor } from './contracts-B3AbzYQ4.mjs';
+import { e as HFMetadataEntry, g as HFStateSnapshot, F as FlowGenerateText } from './hfEventTypes-DQPjEP4T.mjs';
+export { C as CreateFlowTextGenerationPortOptions, r as createFlowTextGenerationPort } from './hfEventTypes-DQPjEP4T.mjs';
 import React__default from 'react';
 
 /** Aktuelle Fassung des Dateiformats. */
@@ -104,147 +104,562 @@ declare const SZENEN_SCHEMAS: Readonly<Record<string, RawSchema>>;
 /** Dateiname des Umschlagschemas — Einstieg jeder Validierung. */
 declare const ELEMENT_VERSION_SCHEMA_FILE = "element-version.schema.json";
 
+/** Der Subtyp, der ohne jede weitere Bedingung gilt (Auftrag §1). */
+declare const GENERAL_POLICY_SUBTYPE = "general";
 /**
- * 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.
+ * Eine automatisch aufgeloeste Policy — mit vollstaendiger Provenienz (D-22).
  *
- * **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.
+ * `chain_index` ist **nicht** Teil des `RendererInput`: Er ordnet, er ist kein
+ * Herkunftsnachweis der Regel. Die entstandene Reihenfolge friert der Lauf
+ * ohnehin woertlich ein.
  */
-declare function hasPlacementCapability(setupPayload: unknown): boolean;
-
+interface ResolvedScenePolicy {
+    element_id: string;
+    version_id: string;
+    subtype: string;
+    rank: number;
+    text: string;
+    locale: string | null;
+    /** Glied der Kontextkette, auf dem das Element liegt. `0` = Arbeitskontext. */
+    chain_index: number;
+}
 /**
- * Ein fachlicher Befund des Promptpfads, der den Lauf **nicht** verhindert hat.
+ * Das Ergebnis der Aufloesung — drei Ausgaenge, drei Sachverhalte.
  *
- * Er wird im Lauf mit eingefroren (D-22): Wer spaeter fragt, warum ein Prompt
- * ohne Kameravorgabe entstand, findet die Antwort im Lauf und nicht in einem
- * Logfile, das es nicht mehr gibt.
+ * `rejected` ist fachlich (ein Fork, ueber den jemand entscheiden muss),
+ * `error` technisch bzw. ein Datenfehler. Sie zusammenzulegen hiesse, einen
+ * Speicherdefekt als Normalzustand anzuzeigen.
  */
-interface PromptDiagnostic {
-    /** Regel-ID (`P-07`) oder Kennung einer Aufloesungsentscheidung. */
-    code: string;
-    /** Woher der Befund stammt. */
-    origin: 'rule' | 'schema' | 'resolution';
-    /** JSON-Pointer auf die betroffene Stelle, soweit bestimmbar. */
-    path: string;
+type ScenePolicyResult = {
+    kind: 'ok';
+    policies: readonly ResolvedScenePolicy[];
+} | {
+    kind: 'rejected';
+    message: string;
+    element_id: string;
+    heads: readonly string[];
+} | {
+    kind: 'error';
     message: string;
+    retryable: boolean;
+};
+/** Ein Lesevorgang der Momentaufnahme, so schmal wie moeglich beschrieben. */
+interface SnapshotRead<T> {
+    kind: string;
+    message?: string;
+    value?: T;
+}
+/** Der Ausschnitt einer Momentaufnahme, den diese Aufloesung braucht. */
+interface PolicySnapshot {
+    getElement(elementId: string): SnapshotRead<{
+        element: {
+            element_id: string;
+            type: string;
+            context_id?: string | null;
+        };
+        versions?: readonly {
+            version_id: string;
+            element_id: string;
+            payload: unknown;
+        }[];
+        preferredHeads?: readonly {
+            context_id: string | null;
+            version_id?: string;
+        }[];
+    } | null>;
+    /**
+     * Die Elemente eines Kettenglieds — **optional im Typ, nicht im Betrieb.**
+     *
+     * Optional, weil der Shot-Pfad dieselbe Momentaufnahme benutzt und dort
+     * keine Liste braucht. Fehlt sie im Szene-Direktlauf, ist das ein
+     * unvollstaendiger Hostadapter und wird laut gemeldet — nicht als „keine
+     * Policy vorhanden" ausgelegt (Grundsatzregel 4).
+     */
+    listElements?(filter: {
+        contextId: string | null;
+        type: string;
+    }): SnapshotRead<readonly {
+        element_id: string;
+        type: string;
+    }[]>;
 }
 /**
- * Was ein Regelbefund im **Promptpfad** bewirkt.
+ * Die deterministische Ordnung automatisch gefundener Policies (Auftrag §6).
  *
- * `blocker` steht bewusst in keiner Zeile der Tabelle unten: Kein Befund aus
- * P-01…P-17 verhindert fuer sich genommen einen Textauftrag. Die echten
- * Prompt-Blocker sind keine Regelbefunde, sondern Zustaende — kein
- * verwertbarer Inhalt, ein Revisionskonflikt, eine technisch unlesbare
- * Eingabe, eine nicht endlich aufloesbare Pflichtstruktur. Sie stehen dort,
- * wo sie entstehen (`resolve.ts`, `freezeDraftChain.ts`), nicht hier.
+ * Eine automatisch entdeckte Menge hat keine gespeicherte Array-Reihenfolge;
+ * `rank` allein reicht deshalb nicht aus, sobald zwei Regeln denselben Rang
+ * tragen. Keine Deduplizierung nach `name`: verschiedene Elemente sind
+ * verschiedene Regeln.
  */
-type PromptEffect = 'diagnostic' | 'blocker' | 'not_applicable';
+declare function sortScenePolicies(policies: readonly ResolvedScenePolicy[]): readonly ResolvedScenePolicy[];
 /**
- * Die Zielrichtung aus Schritt 07 §6, als ausfuehrbare Tabelle.
+ * Der Vergleichswert zweier Aufloesungen — fuer die A/B-Stabilitaetspruefung.
  *
- * Vollstaendig ueber `ALL_PUBLISH_RULES` — ein Test wacht darueber. Eine neue
- * Regel muss hier eingeordnet werden, sonst faellt sie im Promptpfad
- * stillschweigend unter den Tisch, und genau das war der Fehler, den die
- * positive Liste in `capabilities.ts` schon einmal verhindert hat.
+ * Verglichen wird Element **und** Version in der entstandenen Reihenfolge:
+ * Genau dann ist der Policy-Satz derselbe, den der Nutzer gesehen hat. Der
+ * Text gehoert nicht hinein — eine veroeffentlichte Version ist
+ * unveraenderlich, und ein abweichender Text bei gleicher Kennung waere ein
+ * Speicherdefekt, kein Wettlauf.
  */
-declare const PROMPT_RULE_EFFECT: Readonly<Record<string, PromptEffect>>;
-/** Regeln, die weder eingeordnet noch als unzuständig benannt sind. */
-declare function rulesWithoutPromptEffect(alleRegeln: readonly string[]): readonly string[];
+declare function scenePolicyFingerprint(policies: readonly ResolvedScenePolicy[]): string;
 /**
- * Macht aus einem Publish-Befund einen Prompt-Diagnostic.
+ * Die allgemeinen Policies, die fuer einen Szene-Direktlauf gelten.
  *
- * Der Text des Befundes bleibt woertlich stehen. Ihn umzuformulieren hiesse,
- * dieselbe Sache an zwei Stellen zu erklaeren — und die zweite Fassung waere
- * irgendwann die falsche.
- */
-declare function diagnosticOfFinding(finding: PublishFinding): PromptDiagnostic;
-/** Macht aus einem Schemabefund einen Prompt-Diagnostic (Schritt 07 §7). */
-declare function diagnosticOfSchemaError(error: SchemaError, where: string): PromptDiagnostic;
-/**
- * Alle Prompt-Diagnostics eines Prueflaufs.
+ * Ausgewertet wird die **vollstaendige** Kontextkette: Arbeitskontext, geerbte
+ * Kontexte, global. Je sichtbarem `prompt_policy`-Element wird die wirksame
+ * Version ausschliesslich mit der vorhandenen Preferred-Head-Logik bestimmt
+ * (D-36) — hier wird nichts neu ausgelegt und nichts geraten.
  *
- * `advisory` und `blocking` werden hier **gleich** behandelt: Fuer den
- * Promptlauf ist der Unterschied bedeutungslos, weil keiner von beiden ihn
- * verhindert. Der Unterschied bleibt dort erhalten, wo er zaehlt — im
- * Publish-Pfad, der `PublishCheckResult.ok` liest.
+ * Kein Netzzugriff: Gelesen wird genau die uebergebene Momentaufnahme. Das ist
+ * die Voraussetzung dafuer, dass die Auswahl in dieselbe Konsistenzgrenze
+ * faellt wie das Einfrieren der Szene (Gegenpruefung P2).
  */
-declare function promptDiagnosticsOf(checks: PublishCheckResult): PromptDiagnostic[];
+declare function resolveGeneralScenePolicies(snapshot: PolicySnapshot, contextChain: readonly (string | null)[], 
 /**
- * Der **einzige** inhaltliche Prompt-Blocker: Gibt dieser Arbeitsstand
- * ueberhaupt etwas her, das sich beschreiben laesst?
- *
- * „Tolerant" heisst nicht „aus nichts wird ein Lauf" (Goal §5.3). Verwertbar
- * ist eine Szene, wenn mindestens **eine** dieser Quellen Text traegt:
- *
- *   * ein Knoten mit `semantic.description`,
- *   * ein Knoten mit mindestens einer Komponentenreferenz — der Text steht
- *     dann in der referenzierten Komponente,
- *   * ein Umgebungstext oder eine Umgebungsreferenz.
+ * Das gewaehlte Zielmodell dieses Laufs, oder `null` fuer einen generischen.
  *
- * Bewusst **nicht** die blosse Knotenzahl: Ein Knoten ohne jede Beschreibung
- * ist ein Platzhalter, kein Inhalt, und ein Prompt daraus waere die leere
- * Behauptung, die §5.3 ausschliesst.
+ * Nur seinetwegen kommen `target_model`-Policies ueberhaupt in Betracht;
+ * ohne Zielmodell bleibt die Auswahl exakt die von Schritt 03.
  */
-declare function describableContent(scenePayload: unknown): {
-    ok: true;
-} | {
-    ok: false;
-    message: string;
-};
+targetModelElementId?: string | null): ScenePolicyResult;
 
+/** 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;
+}
 /**
- * Zustand einer Fähigkeit.
+ * Warum eine Kette nicht eingefroren werden konnte.
  *
- * `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.
+ * `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 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';
+type FreezeFailure = {
+    kind: 'conflict';
     message: string;
-}
-/** Das Flag erbt das Ergebnis von `can_describe_scene`. */
- | {
-    kind: 'inherited';
-    from: 'can_describe_scene';
+    /** 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;
-};
-interface CapabilityFlag {
-    state: CapabilityState;
-    reasons: readonly CapabilityReason[];
+    failure?: ResolveFailure;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+type FreezeResult = FreezeSuccess | FreezeFailure;
+/** Ein einzelnes Element aus einer Momentaufnahme — kein Netzzugriff mehr. */
+interface ChainSnapshot {
+    promptConstructionTags?(): readonly PromptConstructionTag[];
+    referenceSentenceTags?(): readonly ReferenceSentenceTag[];
+    getElement(elementId: string): {
+        kind: string;
+        message?: string;
+        value?: {
+            element: {
+                element_id: string;
+                type: string;
+                context_id?: string | null;
+            };
+            draft: {
+                draft_id: string;
+                revision: number;
+                payload: unknown;
+                chain?: DraftChainMeta;
+            } | null;
+            draftFork?: unknown | null;
+            /**
+             * Veröffentlichte Versionen — für den Szene-Direktpfad (D-135).
+             *
+             * Eine Draft-Kette friert ausschließlich Entwürfe ein; eine Szene kann
+             * dagegen längst veröffentlicht sein und gar keinen Entwurf mehr haben.
+             * Beide Hosts liefern die Liste bereits mit (`ElementSnapshot`), sie war
+             * hier nur nicht deklariert.
+             */
+            versions?: readonly {
+                version_id: string;
+                element_id: string;
+                payload: unknown;
+                parents?: unknown;
+            }[];
+            preferredHeads?: readonly {
+                context_id: string | null;
+                version_id?: string;
+            }[];
+        } | null;
+    };
+    /**
+     * Die Elemente eines Kettenglieds — fuer die allgemeinen Kontext-Policies
+     * des Szene-Direktlaufs (Schritt 03 §3).
+     *
+     * Optional im Typ, weil der Shot-Pfad dieselbe Momentaufnahme benutzt und
+     * dort keine Liste braucht. Im Szene-Direktlauf ist sie **Pflicht**: Fehlt
+     * sie, meldet die Policy-Aufloesung einen Fehler, statt „keine Policy"
+     * zu behaupten (Grundsatzregel 4).
+     *
+     * Aus **derselben** Momentaufnahme wie `getElement` — genau das haelt die
+     * Policy-Auswahl in der A/B-Konsistenzgrenze und verhindert einen dritten
+     * Live-Leseweg (Gegenpruefung P2).
+     */
+    listElements?(filter: {
+        contextId: string | null;
+        type: string;
+    }): {
+        kind: string;
+        message?: string;
+        value?: readonly {
+            element_id: string;
+            type: string;
+        }[];
+    };
+}
+/**
+ * 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;
+        withReferenceSentence?: boolean;
+        withPromptTags?: boolean;
+    }): Promise<ChainSnapshot>;
+}
+interface FreezeDraftChainInput {
+    withCameraPreview?: boolean;
+    /** 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>;
+/**
+ * Was eingefroren wurde — **eines** von beidem, nie beides und nie erfunden.
+ *
+ * Ein Entwurf hat `draft_id` und `revision` und keine `version_id`; eine
+ * veröffentlichte Version genau umgekehrt. Ein Feld, das ehrlich `null` ist,
+ * ist besser als eine Kennung, die wie eine echte aussieht (D-75/D-98).
+ */
+interface FrozenSceneState {
+    element_id: string;
+    draft_id: string | null;
+    revision: number | null;
+    version_id: string | null;
+}
+interface FreezeSceneSuccess {
+    kind: 'ok';
+    scene: FrozenSceneState;
+    input: RendererInput;
+    /**
+     * Die automatisch aufgeloesten allgemeinen Kontext-Policies (Schritt 03).
+     *
+     * Redundant zu `input.policies` und trotzdem hier: Der Aufrufer sieht so den
+     * Satz **mit** `chain_index`, ohne die Ordnung nachbauen zu muessen. Der
+     * eingefrorene Lauf traegt weiterhin ausschliesslich `input`.
+     */
+    policies: readonly ResolvedScenePolicy[];
+    /**
+     * Das eingefrorene Zielmodell, oder `null` fuer einen generischen Lauf.
+     *
+     * Wie `policies` redundant zu `input` und trotzdem hier: Der Aufrufer sieht
+     * die Provenienz, ohne sie aus `renderer_input` zurueckrechnen zu muessen.
+     */
+    targetModel: FrozenSceneTargetModel | null;
+}
+type FreezeSceneResult = FreezeSceneSuccess | FreezeFailure;
+interface FreezeSceneWorkingStateInput {
+    /** Das Szenen-**Element**. Ob Entwurf oder Version, entscheidet der Bestand. */
+    sceneElementId: string;
+    store: ChainQueries;
+    resolver: ReferenceResolver;
+    contextChain: readonly (string | null)[];
+    userInstruction?: string | null;
+    /**
+     * Das gewaehlte Zielmodell (Kette `szenen-direktlauf-target-model-policy`).
+     *
+     * Optional: Ohne Angabe bleibt der Ablauf exakt der generische von D-135 —
+     * kein Zielmodell im `RendererInput`, keine `target_model`-Policy.
+     */
+    targetModelElementId?: string | null;
+}
+/**
+ * Das gewaehlte Zielmodell eines Szene-Direktlaufs — Kette
+ * `szenen-direktlauf-target-model-policy`, Schritt 01.
+ *
+ * **Warum ueber die `element_id` und nicht ueber den Key.** Der Shot-Pfad sucht
+ * ein Zielmodell ueber `prompt_render_settings.target_model_id`, also ueber
+ * einen freien Key entlang der Kette — mit allen Ausgaengen, die dazugehoeren
+ * (`not_found`, `ambiguous`, `retired`, `fork`). Der Szene-Direktlauf bekommt
+ * das Modell dagegen von einem Menschen ausgewaehlt, und der waehlt es aus
+ * einer Liste, die schon aufgeloest ist. Die Kennung ist damit eindeutig, und
+ * sie ist dieselbe, die eine `target_model`-Policy in
+ * `applicable_target_models` nennt. Eine zweite Suche ueber einen geratenen
+ * Namen waere fehleranfaelliger als die Kennung, die vorliegt.
+ *
+ * Die **Version** waehlt trotzdem niemand von Hand: Sie kommt aus derselben
+ * D-36-Preferred-Head-Aufloesung wie der Arbeitsstand der Szene daneben.
+ */
+interface FrozenSceneTargetModel {
+    element_id: string;
+    version_id: string;
+    /** Glied der Kontextkette, auf dem das Element liegt. `0` = Arbeitskontext. */
+    chain_index: number;
+    payload: unknown;
+    head: PreferredHeadResolution;
+}
+/**
+ * Friert den Arbeitsstand **einer Szene** ein und baut die Renderer-Eingabe
+ * (D-135).
+ *
+ * Dasselbe optimistische Zwei-Durchgang-Verfahren wie bei der Draft-Kette
+ * (D-97): lesen, kopieren, frisch nachlesen, Revision vergleichen, und den
+ * Snapshot aus den **kopierten** Inhalten bauen. Ein Konflikt bleibt ein
+ * echter Blocker — **vor** dem kostenpflichtigen Provideraufruf. Dieser Goal
+ * lockert daran nichts (Goal §8.1).
+ *
+ * Eine veröffentlichte Version ist unveränderlich; für sie kann Durchgang B
+ * keinen Revisionskonflikt finden. Er läuft trotzdem: Verschwindet die Version
+ * zwischen den Durchgängen aus der wirksamen Sicht — stillgelegt, ein anderer
+ * Preferred Head —, ist der Stand nicht mehr der, den der Nutzer gesehen hat.
+ */
+declare function freezeSceneWorkingState(input: FreezeSceneWorkingStateInput): Promise<FreezeSceneResult>;
+
+interface ReferenceSentenceTag {
+    category: string;
+    label: string;
+    value: string;
+    context_id: string | null;
+}
+interface FrozenReferenceSentence {
+    tag: string;
+    tag_context_id: string | null;
+    /** Historical runs may carry provenance of the former fragment link. */
+    element_id?: string;
+    version_id?: string;
+    template_text: string;
+    text: string;
+    reference_image_token: string;
+}
+
+interface CameraPreviewContext {
+    camera_id: string;
+    background_color: string;
+    composition_reference_sent: boolean;
+    reference_image_token: string | null;
+    coordinate_system: 'blender_z_up_meters';
+    objects: {
+        node_id: string;
+        label: string;
+        type: string;
+        preview_color: {
+            hex: string;
+            name: string;
+        };
+        proxy: {
+            primitive: string;
+            dimensions_m: readonly number[];
+            position_m: readonly number[];
+            rotation_euler_deg: readonly number[];
+            scale: readonly number[];
+        };
+        contributions: RendererInput['scene']['nodes'][number]['contributions'];
+        properties: Record<string, unknown>;
+        image_references: NonNullable<RendererInput['scene']['nodes'][number]['media_refs']>;
+        solid_color_pixels?: number;
+    }[];
+    excluded_hidden_node_ids: string[];
+}
+/** Built from precisely the same frame and palette as the PNG, without interpreting image contents. */
+declare function buildCameraPreviewContext(input: RendererInput, pixels?: Readonly<Record<string, number>>): CameraPreviewContext;
+
+/**
+ * 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;
+
+/**
+ * Ein fachlicher Befund des Promptpfads, der den Lauf **nicht** verhindert hat.
+ *
+ * Er wird im Lauf mit eingefroren (D-22): Wer spaeter fragt, warum ein Prompt
+ * ohne Kameravorgabe entstand, findet die Antwort im Lauf und nicht in einem
+ * Logfile, das es nicht mehr gibt.
+ */
+interface PromptDiagnostic {
+    /** Regel-ID (`P-07`) oder Kennung einer Aufloesungsentscheidung. */
+    code: string;
+    /** Woher der Befund stammt. */
+    origin: 'rule' | 'schema' | 'resolution';
+    /** JSON-Pointer auf die betroffene Stelle, soweit bestimmbar. */
+    path: string;
+    message: string;
+}
+/**
+ * Was ein Regelbefund im **Promptpfad** bewirkt.
+ *
+ * `blocker` steht bewusst in keiner Zeile der Tabelle unten: Kein Befund aus
+ * P-01…P-17 verhindert fuer sich genommen einen Textauftrag. Die echten
+ * Prompt-Blocker sind keine Regelbefunde, sondern Zustaende — kein
+ * verwertbarer Inhalt, ein Revisionskonflikt, eine technisch unlesbare
+ * Eingabe, eine nicht endlich aufloesbare Pflichtstruktur. Sie stehen dort,
+ * wo sie entstehen (`resolve.ts`, `freezeDraftChain.ts`), nicht hier.
+ */
+type PromptEffect = 'diagnostic' | 'blocker' | 'not_applicable';
+/**
+ * Die Zielrichtung aus Schritt 07 §6, als ausfuehrbare Tabelle.
+ *
+ * Vollstaendig ueber `ALL_PUBLISH_RULES` — ein Test wacht darueber. Eine neue
+ * Regel muss hier eingeordnet werden, sonst faellt sie im Promptpfad
+ * stillschweigend unter den Tisch, und genau das war der Fehler, den die
+ * positive Liste in `capabilities.ts` schon einmal verhindert hat.
+ */
+declare const PROMPT_RULE_EFFECT: Readonly<Record<string, PromptEffect>>;
+/** Regeln, die weder eingeordnet noch als unzuständig benannt sind. */
+declare function rulesWithoutPromptEffect(alleRegeln: readonly string[]): readonly string[];
+/**
+ * Macht aus einem Publish-Befund einen Prompt-Diagnostic.
+ *
+ * Der Text des Befundes bleibt woertlich stehen. Ihn umzuformulieren hiesse,
+ * dieselbe Sache an zwei Stellen zu erklaeren — und die zweite Fassung waere
+ * irgendwann die falsche.
+ */
+declare function diagnosticOfFinding(finding: PublishFinding): PromptDiagnostic;
+/** Macht aus einem Schemabefund einen Prompt-Diagnostic (Schritt 07 §7). */
+declare function diagnosticOfSchemaError(error: SchemaError, where: string): PromptDiagnostic;
+/**
+ * Alle Prompt-Diagnostics eines Prueflaufs.
+ *
+ * `advisory` und `blocking` werden hier **gleich** behandelt: Fuer den
+ * Promptlauf ist der Unterschied bedeutungslos, weil keiner von beiden ihn
+ * verhindert. Der Unterschied bleibt dort erhalten, wo er zaehlt — im
+ * Publish-Pfad, der `PublishCheckResult.ok` liest.
+ */
+declare function promptDiagnosticsOf(checks: PublishCheckResult): PromptDiagnostic[];
+/**
+ * Der **einzige** inhaltliche Prompt-Blocker: Gibt dieser Arbeitsstand
+ * ueberhaupt etwas her, das sich beschreiben laesst?
+ *
+ * „Tolerant" heisst nicht „aus nichts wird ein Lauf" (Goal §5.3). Verwertbar
+ * ist eine Szene, wenn mindestens **eine** dieser Quellen Text traegt:
+ *
+ *   * ein Knoten mit `semantic.description`,
+ *   * ein Knoten mit mindestens einer Komponentenreferenz — der Text steht
+ *     dann in der referenzierten Komponente,
+ *   * ein Umgebungstext oder eine Umgebungsreferenz.
+ *
+ * Bewusst **nicht** die blosse Knotenzahl: Ein Knoten ohne jede Beschreibung
+ * ist ein Platzhalter, kein Inhalt, und ein Prompt daraus waere die leere
+ * Behauptung, die §5.3 ausschliesst.
+ */
+declare function describableContent(scenePayload: unknown): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+
+/**
+ * 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 {
     /**
@@ -391,125 +806,6 @@ declare function sceneOnlyCapabilities(scenePayload: unknown): {
     can_place: CapabilityFlag;
 };
 
-/** Der Subtyp, der ohne jede weitere Bedingung gilt (Auftrag §1). */
-declare const GENERAL_POLICY_SUBTYPE = "general";
-/**
- * Eine automatisch aufgeloeste Policy — mit vollstaendiger Provenienz (D-22).
- *
- * `chain_index` ist **nicht** Teil des `RendererInput`: Er ordnet, er ist kein
- * Herkunftsnachweis der Regel. Die entstandene Reihenfolge friert der Lauf
- * ohnehin woertlich ein.
- */
-interface ResolvedScenePolicy {
-    element_id: string;
-    version_id: string;
-    subtype: string;
-    rank: number;
-    text: string;
-    locale: string | null;
-    /** Glied der Kontextkette, auf dem das Element liegt. `0` = Arbeitskontext. */
-    chain_index: number;
-}
-/**
- * Das Ergebnis der Aufloesung — drei Ausgaenge, drei Sachverhalte.
- *
- * `rejected` ist fachlich (ein Fork, ueber den jemand entscheiden muss),
- * `error` technisch bzw. ein Datenfehler. Sie zusammenzulegen hiesse, einen
- * Speicherdefekt als Normalzustand anzuzeigen.
- */
-type ScenePolicyResult = {
-    kind: 'ok';
-    policies: readonly ResolvedScenePolicy[];
-} | {
-    kind: 'rejected';
-    message: string;
-    element_id: string;
-    heads: readonly string[];
-} | {
-    kind: 'error';
-    message: string;
-    retryable: boolean;
-};
-/** Ein Lesevorgang der Momentaufnahme, so schmal wie moeglich beschrieben. */
-interface SnapshotRead<T> {
-    kind: string;
-    message?: string;
-    value?: T;
-}
-/** Der Ausschnitt einer Momentaufnahme, den diese Aufloesung braucht. */
-interface PolicySnapshot {
-    getElement(elementId: string): SnapshotRead<{
-        element: {
-            element_id: string;
-            type: string;
-            context_id?: string | null;
-        };
-        versions?: readonly {
-            version_id: string;
-            element_id: string;
-            payload: unknown;
-        }[];
-        preferredHeads?: readonly {
-            context_id: string | null;
-            version_id?: string;
-        }[];
-    } | null>;
-    /**
-     * Die Elemente eines Kettenglieds — **optional im Typ, nicht im Betrieb.**
-     *
-     * Optional, weil der Shot-Pfad dieselbe Momentaufnahme benutzt und dort
-     * keine Liste braucht. Fehlt sie im Szene-Direktlauf, ist das ein
-     * unvollstaendiger Hostadapter und wird laut gemeldet — nicht als „keine
-     * Policy vorhanden" ausgelegt (Grundsatzregel 4).
-     */
-    listElements?(filter: {
-        contextId: string | null;
-        type: string;
-    }): SnapshotRead<readonly {
-        element_id: string;
-        type: string;
-    }[]>;
-}
-/**
- * Die deterministische Ordnung automatisch gefundener Policies (Auftrag §6).
- *
- * Eine automatisch entdeckte Menge hat keine gespeicherte Array-Reihenfolge;
- * `rank` allein reicht deshalb nicht aus, sobald zwei Regeln denselben Rang
- * tragen. Keine Deduplizierung nach `name`: verschiedene Elemente sind
- * verschiedene Regeln.
- */
-declare function sortScenePolicies(policies: readonly ResolvedScenePolicy[]): readonly ResolvedScenePolicy[];
-/**
- * Der Vergleichswert zweier Aufloesungen — fuer die A/B-Stabilitaetspruefung.
- *
- * Verglichen wird Element **und** Version in der entstandenen Reihenfolge:
- * Genau dann ist der Policy-Satz derselbe, den der Nutzer gesehen hat. Der
- * Text gehoert nicht hinein — eine veroeffentlichte Version ist
- * unveraenderlich, und ein abweichender Text bei gleicher Kennung waere ein
- * Speicherdefekt, kein Wettlauf.
- */
-declare function scenePolicyFingerprint(policies: readonly ResolvedScenePolicy[]): string;
-/**
- * Die allgemeinen Policies, die fuer einen Szene-Direktlauf gelten.
- *
- * Ausgewertet wird die **vollstaendige** Kontextkette: Arbeitskontext, geerbte
- * Kontexte, global. Je sichtbarem `prompt_policy`-Element wird die wirksame
- * Version ausschliesslich mit der vorhandenen Preferred-Head-Logik bestimmt
- * (D-36) — hier wird nichts neu ausgelegt und nichts geraten.
- *
- * Kein Netzzugriff: Gelesen wird genau die uebergebene Momentaufnahme. Das ist
- * die Voraussetzung dafuer, dass die Auswahl in dieselbe Konsistenzgrenze
- * faellt wie das Einfrieren der Szene (Gegenpruefung P2).
- */
-declare function resolveGeneralScenePolicies(snapshot: PolicySnapshot, contextChain: readonly (string | null)[], 
-/**
- * Das gewaehlte Zielmodell dieses Laufs, oder `null` fuer einen generischen.
- *
- * Nur seinetwegen kommen `target_model`-Policies ueberhaupt in Betracht;
- * ohne Zielmodell bleibt die Auswahl exakt die von Schritt 03.
- */
-targetModelElementId?: string | null): ScenePolicyResult;
-
 /** Ein Beitrag zur Beschreibung eines Knotens, mit Herkunft (D-50). */
 interface NodeContribution {
     source: 'component' | 'node_semantic' | 'setup_override';
@@ -523,6 +819,18 @@ interface NodeContribution {
 /** Ein Knoten der aufgelösten Szene. */
 interface ResolvedNode {
     node_id: string;
+    label?: string;
+    media_refs?: readonly {
+        asset_id: string;
+        role: string;
+        position?: number;
+    }[];
+    /** Die wirksame einfache Geometrie desselben Nodes (#569). */
+    proxy_3d?: {
+        primitive: string;
+        dimensions: readonly number[];
+    } | null;
+    anchors?: Readonly<Record<string, readonly number[]>>;
     type: string;
     /** Additiv nach `rank`, nie vorgemischt (D-50). */
     contributions: readonly NodeContribution[];
@@ -532,6 +840,19 @@ interface ResolvedNode {
     /** Vom Shot ausgeblendet (D-40). Der Knoten bleibt im Graphen (D-21). */
     hidden: boolean;
 }
+/**
+ * Die aufgelöste Umgebung der Szene (#563).
+ *
+ * Dieselbe Form wie bei einem Knoten: `environment.component_refs` werden zu
+ * Beiträgen mit Herkunft aufgelöst, statt als rohe Versionskennungen an den
+ * Renderer zu gehen. Mit Kennungen allein kann das Modell nichts formulieren.
+ */
+interface ResolvedEnvironment {
+    text: string | null;
+    /** Nur `source: 'component'`, additiv nach `rank` (D-50). */
+    contributions: readonly NodeContribution[];
+    properties: Record<string, unknown>;
+}
 interface ResolvedPlacement {
     position: readonly number[];
     rotation_euler_deg?: readonly number[];
@@ -539,6 +860,8 @@ interface ResolvedPlacement {
 }
 interface ResolvedCamera {
     camera_id: string;
+    /** Historische Kameras ohne Format behalten die Abwesenheit des Feldes. */
+    aspect_ratio?: string;
     name: string | null;
     /** `null`, wenn das Preset nicht auflösbar war — kein erfundenes Objektiv. */
     preset: unknown;
@@ -563,6 +886,10 @@ interface ResolvedCamera {
  * es nichts zu formulieren (Goal §5.3).
  */
 interface RendererInput {
+    preview_instruction?: PromptConstructionTag;
+    camera_preview_context?: CameraPreviewContext;
+    /** Eingefrorener Texttag, nur bei einem Kamera-Referenzlauf (D-22). */
+    reference_sentence?: FrozenReferenceSentence;
     /** `null` bei einem Lauf ohne Shot (Szene-Direktpfad). */
     shot: {
         version_id: string;
@@ -597,7 +924,7 @@ interface RendererInput {
         version_id: string;
         nodes: readonly ResolvedNode[];
         relations: readonly unknown[];
-        environment: unknown | null;
+        environment: ResolvedEnvironment | null;
         unit_system: unknown | null;
     };
     /** `null`, wenn der Lauf ohne konkrete Kamera entstand. */
@@ -631,6 +958,7 @@ interface RendererInput {
         text: string;
         locale: string | null;
     }[];
+    prompt_tags?: readonly PromptConstructionTag[];
     fragments: readonly {
         channel: string;
         rank: number;
@@ -706,6 +1034,9 @@ interface RendererInput {
  * für Aufrufer bildet, die eine Fähigkeit ausdrücklich als Tor benutzen wollen.
  */
 type ResolveFailure = {
+    class: 'prompt_tags_unresolvable';
+    message: string;
+} | {
     class: 'not_a_shot';
     message: string;
     type: string;
@@ -896,6 +1227,38 @@ declare function resolveScenePayload(input: ResolveScenePayloadInput): Promise<R
  */
 declare function capabilityGate(report: CapabilityReport, flag: 'can_render_prompt' | 'can_place'): ResolveFailure | null;
 
+declare const CAMERA_ASPECT_RATIOS: readonly ["1:1", "4:3", "3:4", "16:9", "9:16"];
+/** Kein Default: Ein historischer Stand ohne Format ist keine 1:1-Kamera. */
+declare function cameraAspectRatioValue(aspectRatio: string): number;
+/**
+ * Additiver Leservertrag, strenger Schreibabschluss: Neue/geänderte Kameras
+ * brauchen ein Format. Unveränderte historische Kameras bleiben erhalten.
+ * Eltern sind explizite eigene Basis-/Parent-Payloads, keine geratene Version.
+ * Entwürfe dürfen weiterhin unvollständig sein; spätestens Publish prüft dies.
+ */
+declare function checkCameraAspectRatioChanges(type: string, payload: unknown, previousPayloads?: readonly unknown[]): SchemaError[];
+/** Optik ausschließlich aus dem aufgelösten Preset, Format aus der Kamera. */
+declare function cameraPerspective(camera: ResolvedCamera): {
+    aspect_ratio: string;
+    aspect: number;
+    focal_length_mm: number;
+    sensor_width_mm: number;
+    vertical_fov_deg: number;
+};
+/** Das eingefrorene Kameraformat ist autoritativ, auch nach einem Reload. */
+declare function frozenCameraAspectRatio(input: unknown): string | undefined;
+
+interface CameraPreview extends TextGenerationImage {
+    solid_color_pixels?: Readonly<Record<string, number>>;
+    width: number;
+    height: number;
+    camera_id: string;
+    sha256: string;
+}
+type CameraPreviewDescriptor = Omit<CameraPreview, 'data' | 'solid_color_pixels'>;
+type CameraPreviewRenderer = (input: RendererInput) => Promise<CameraPreview>;
+declare function supportsCompositionReference(model: unknown): boolean;
+
 interface VisibilityNode {
     node_id: string;
     state: string;
@@ -991,7 +1354,13 @@ declare function checkRunResponse(value: unknown, input: RendererInput): {
  * kein Lauf, sondern ein Betriebsfehler und darf nicht als „das Modell hat
  * abgelehnt" gespeichert werden.
  */
-declare function runPromptDerivation(input: RendererInput, port: TextGenerationPort): Promise<PromptRunOutcome & {
+/** Shared by the pre-generation inspector and the actual provider call. */
+declare function preparePromptDerivation(input: RendererInput, preview?: CameraPreview): {
+    input: RendererInput;
+    system_prompt: string;
+    prompt: string;
+};
+declare function runPromptDerivation(input: RendererInput, port: TextGenerationPort, preview?: CameraPreview): Promise<PromptRunOutcome & {
     system_prompt: string;
 }>;
 
@@ -1053,6 +1422,7 @@ type PromptRunSource = {
     };
 };
 interface PromptRunRecord {
+    camera_preview?: CameraPreviewDescriptor;
     run_id: string;
     /**
      * Herkunft: die veröffentlichte Shot-Version, aus der der Lauf entstand.
@@ -1200,6 +1570,13 @@ declare function groupKeyOf(run: PromptRunPageRecord): string;
  * zweite Wahrheit.
  */
 declare function siblingsOf(run: PromptRunRecord, alle: readonly PromptRunRecord[]): readonly PromptRunRecord[];
+/** Index ausschließlich veröffentlichter, unveränderlicher Szenenversionen. */
+declare function sceneVersionElementsOf(state: ElementStoreState): ReadonlyMap<string, string>;
+interface SceneRunState {
+    key: string;
+    /** Chronologischer Stand im gesamten Szenenbestand, unabhängig vom Seitenschnitt. */
+    number: number | null;
+}
 /**
  * Das Element, das einen Lauf **benennt** — oder `null`.
  *
@@ -1280,10 +1657,9 @@ declare function selectPromptRuns(alle: readonly PromptRunRecord[], filter?: Pro
 /**
  * Woher die Laeufe einer Seite kommen.
  *
- * Genau die vier Einstiege, die es ohnehin gibt — `listAllRuns` und die drei
- * verankerten Abfragen. Hier entsteht **keine** fuenfte Herkunft und keine
- * neue Zuordnungsregel: `'all'` heisst „ohne Anker", die drei anderen
- * vergleichen denselben `groupKeyOf`, den auch die Geschwister benutzen.
+ * `scene_history` liest den eingefrorenen Szeneninput über alle Herkünfte.
+ * `scene`, `draft_chain` und `published` behalten ihre bisherige
+ * Herkunftsauswahl über `groupKeyOf`; `all` liest ohne Anker.
  */
 type PromptRunPageSource = {
     kind: 'all';
@@ -1296,6 +1672,11 @@ type PromptRunPageSource = {
 } | {
     kind: 'scene';
     sceneElementId: string;
+}
+/** Fachliche Szenenhistorie über alle technischen Herkünfte. */
+ | {
+    kind: 'scene_history';
+    sceneElementId: string;
 };
 /** Der Herkunftsfilter der gemeinsamen Sicht — dieselben Namen wie `PromptRunGroup`. */
 type PromptRunOriginFilter = PromptRunGroup['kind'];
@@ -1304,6 +1685,8 @@ interface PromptRunPageFilter extends PromptRunFilter {
     origin?: PromptRunOriginFilter;
 }
 interface PromptRunPageInput {
+    /** Host-Index für alte eingefrorene Inputs ohne element_id; keine aktuellen Heads. */
+    sceneVersionElements?: ReadonlyMap<string, string>;
     source?: PromptRunPageSource;
     filter?: PromptRunPageFilter;
     /** Ohne Angabe wird nicht geschnitten — dann ist die Seite der ganze Bestand. */
@@ -1321,521 +1704,280 @@ interface PromptRunPageInput {
     tags?: ReadonlyMap<string, readonly LibraryTagRef[]>;
     /**
      * Bildanzahl, Vorschau und Library-Tags je Lauf — wie
-     * `annotateRunsFromEvents()` sie liefert.
-     *
-     * Auch das geht **hier** hinein und nicht in einen Aufruf je Karte: Die
-     * Bild-Batches liegen in demselben Log wie die Laeufe, und die Seite bringt
-     * die Zahlen ihrer zehn Laeufe mit.
-     */
-    annotations?: ReadonlyMap<string, PromptRunAnnotation>;
-    /**
-     * Der Titel je **Element**, wie ihn der gefaltete Bestand kennt.
-     *
-     * Aus demselben Grund hier wie Tags und Bildzahlen: Der Name eines Laufs ist
-     * der Titel des Elements, aus dem er entstand (`namingElementOf`), und der
-     * steht in demselben Log. Ihn je Karte einzeln zu lesen hiess bisher, nach
-     * der Seite noch einmal **je Element** eine Abfrage zu stellen — nacheinander,
-     * weil eine Liste sonst zehn gleichzeitig ausloeste.
-     *
-     * Fehlt die Angabe, traegt die Seite keine Titel; die Ansicht loest sie dann
-     * weiterhin selbst auf. Es entsteht keine zweite Namensregel: **welches**
-     * Element benennt, entscheidet nach wie vor `namingElementOf()`.
-     */
-    titles?: ReadonlyMap<string, string>;
-}
-/**
- * Eine Seite Laeufe, **neueste zuerst**, mit allem, was die Anzeige sonst aus
- * dem Gesamtbestand hatte.
- *
- * Warum die Rundennummern mitkommen: Die Runde ist der Platz eines Laufs unter
- * seinen Geschwistern (U23) — sie laesst sich aus zehn von achthundert Laeufen
- * nicht ausrechnen. Statt dafuer wieder alles zu uebertragen, rechnet die Seite
- * sie dort aus, wo der volle Bestand ohnehin liegt, und schickt genau die
- * Nummern der gezeigten Laeufe mit. Es entsteht keine zweite Zaehlung: dieselbe
- * Gruppierung, dieselbe Reihenfolge, derselbe 1-basierte Platz wie
- * `roundOfRun(lauf, siblingsOf(lauf, alle))`.
- */
-interface PromptRunPage extends Omit<PromptRunListing, 'runs'>, Page<PromptRunPageRecord> {
-    /**
-     * Dieselben Saetze wie `items` — `runs` bleibt der Name der Laufliste.
-     *
-     * Ueber eine Leitung sind es Listenprojektionen (`detail_omitted`), im
-     * lokal faltenden Host volle Saetze. Die Ansicht unterscheidet das mit
-     * `detailFehlt()` und laedt nur im ersten Fall nach.
-     */
-    runs: readonly PromptRunPageRecord[];
-    /** Rundennummer je `run_id`, nur fuer die Laeufe dieser Seite. */
-    rounds: Readonly<Record<string, number>>;
-    /** Laeufe, die der Herkunftsfilter ausgeblendet hat. */
-    hiddenByOrigin: number;
-    /**
-     * Die **direkten** Tags je `run_id`, nur fuer die Laeufe dieser Seite.
-     *
-     * Ein Lauf ohne Eintrag hat keine Prompt-Tags. Getrennt von `annotations`
-     * gefuehrt, weil diese Tags aus demselben Log stammen wie die Laeufe und
-     * jeder Host sie hat — auch einer ohne Library-Bestand.
-     */
-    promptTags: Readonly<Record<string, readonly LibraryTagRef[]>>;
-    /**
-     * Der Anzeigename je `run_id`, nur fuer die Laeufe dieser Seite und nur, wo
-     * das benennende Element einen Titel hat.
-     *
-     * Ein Lauf ohne Eintrag bleibt titellos und heisst „Runde n" — ein aus der
-     * `run_id` gebastelter Name saehe aus wie ein echter (D-75).
-     */
-    titles?: Readonly<Record<string, string>>;
-    /**
-     * Bildanzahl, Vorschau und Library-Tags je `run_id` — nur wenn der Host sie
-     * liefern kann. Fehlt das Feld, weiss die Ansicht es nicht und sagt das.
-     */
-    annotations?: Readonly<Record<string, PromptRunAnnotation>>;
-}
-/**
- * Die Rundennummer **jedes** Laufs des uebergebenen Bestands.
- *
- * Gerechnet auf der chronologischen Reihenfolge, die `collectPromptRuns`
- * liefert — nicht auf der Anzeigereihenfolge. Die Anzeige dreht sich um; die
- * Rundenzaehlung tut es nicht, sonst hiesse derselbe Lauf morgen anders.
- */
-declare function roundsOf(alle: readonly PromptRunRecord[]): ReadonlyMap<string, number>;
-/**
- * Der eine Seitenschnitt fuer Prompt-Laeufe — Server wie Client.
- *
- * Reine Funktion ueber einem bereits gelesenen Bestand, genau wie
- * `selectPromptRuns`, das sie benutzt. Damit gilt der Bezugsrahmen (Status,
- * Kontext) an beiden Enden unveraendert; dazu kommen Herkunft, Umkehrung und
- * Schnitt.
- *
- * @param alle Der Bestand in der Reihenfolge von `collectPromptRuns`.
- * @throws Wenn der Cursor in der gefilterten Liste nicht vorkommt (`pageOf`).
- */
-declare function pagePromptRuns(alle: readonly PromptRunRecord[], input?: PromptRunPageInput): PromptRunPage;
-/**
- * Eine Seite, wie sie **ueber eine Leitung** geht — Kette `szenen-promptliste-transport`.
- *
- * Zwei Dinge fallen weg, beide gemessen an `GET /api2/szenen/prompt-runs/page`
- * auf dev mit zehn Laeufen (203 kB):
- *
- * 1. **`items`.** Die Seite trug die Laufliste zweimal: einmal als `runs`,
- *    einmal als `items` aus dem `Page<T>`-Vertrag. Im JSON sind das zwei
- *    vollstaendige Kopien — 100 der 203 kB. Der Vertrag bleibt: Der Adapter
- *    auf der anderen Seite setzt `items` aus `runs` wieder zusammen, statt es
- *    zu uebertragen.
- * 2. **Die Detailfelder** (`PROMPT_RUN_DETAIL_FIELDS`). 74 der uebrigen 100 kB,
- *    und keines davon zeigt die Liste. Was bleibt, ist als
- *    `PromptRunListRecord` **markiert**, damit die Ansicht ein fehlendes Feld
- *    nicht fuer eine Aussage ueber den Lauf haelt.
- *
- * Rein und ohne Host: `items` wegzulassen ist eine Transportentscheidung, und
- * sie gehoert neben den Seitenschnitt, nicht in einen Controller.
- */
-declare function promptRunPageForTransport(seite: PromptRunPage): Omit<PromptRunPage, 'items'>;
-/**
- * Die Gegenrichtung: `items` aus `runs` zuruecklegen.
- *
- * Der `Page<T>`-Vertrag gilt im Client unveraendert — er wurde nur nicht
- * uebertragen. Ohne diesen Schritt fehlte `items` still, und jeder kuenftige
- * Aufrufer von `Page<T>` saehe eine leere Seite statt eines Fehlers.
- */
-declare function promptRunPageFromTransport(roh: Omit<PromptRunPage, 'items'>): PromptRunPage;
-
-/**
- * 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;
+     * `annotateRunsFromEvents()` sie liefert.
+     *
+     * Auch das geht **hier** hinein und nicht in einen Aufruf je Karte: Die
+     * Bild-Batches liegen in demselben Log wie die Laeufe, und die Seite bringt
+     * die Zahlen ihrer zehn Laeufe mit.
+     */
+    annotations?: ReadonlyMap<string, PromptRunAnnotation>;
     /**
-     * Die Zahl der tatsächlich abgesetzten Modellaufrufe.
+     * Der Titel je **Element**, wie ihn der gefaltete Bestand kennt.
      *
-     * Bewusst getrennt von `results.length`: Eine übersprungene Prüfung hat
-     * nichts gekostet, und wer später Kosten nachvollziehen will, darf beides
-     * nicht verwechseln.
+     * Aus demselben Grund hier wie Tags und Bildzahlen: Der Name eines Laufs ist
+     * der Titel des Elements, aus dem er entstand (`namingElementOf`), und der
+     * steht in demselben Log. Ihn je Karte einzeln zu lesen hiess bisher, nach
+     * der Seite noch einmal **je Element** eine Abfrage zu stellen — nacheinander,
+     * weil eine Liste sonst zehn gleichzeitig ausloeste.
+     *
+     * Fehlt die Angabe, traegt die Seite keine Titel; die Ansicht loest sie dann
+     * weiterhin selbst auf. Es entsteht keine zweite Namensregel: **welches**
+     * Element benennt, entscheidet nach wie vor `namingElementOf()`.
      */
-    model_calls: number;
-    results: readonly ProviderCheckResult[];
-    created_at: string;
+    titles?: ReadonlyMap<string, 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 Seite Laeufe, **neueste zuerst**, mit allem, was die Anzeige sonst aus
+ * dem Gesamtbestand hatte.
  *
- * Eine Stelle, an der summiert wird — sonst zählt die UI anders als der
- * Bericht, und niemand weiß, welche Zahl stimmt.
+ * Warum die Rundennummern mitkommen: Die Runde ist der Platz eines Laufs unter
+ * seinen Geschwistern (U23) — sie laesst sich aus zehn von achthundert Laeufen
+ * nicht ausrechnen. Statt dafuer wieder alles zu uebertragen, rechnet die Seite
+ * sie dort aus, wo der volle Bestand ohnehin liegt, und schickt genau die
+ * Nummern der gezeigten Laeufe mit. Es entsteht keine zweite Zaehlung: dieselbe
+ * Gruppierung, dieselbe Reihenfolge, derselbe 1-basierte Platz wie
+ * `roundOfRun(lauf, siblingsOf(lauf, alle))`.
  */
-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;
+interface PromptRunPage extends Omit<PromptRunListing, 'runs'>, Page<PromptRunPageRecord> {
     /**
-     * Der Rekonstruktionslauf, aus dem die Kette entstand (D-123, A2).
+     * Dieselben Saetze wie `items` — `runs` bleibt der Name der Laufliste.
      *
-     * 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.
+     * Ueber eine Leitung sind es Listenprojektionen (`detail_omitted`), im
+     * lokal faltenden Host volle Saetze. Die Ansicht unterscheidet das mit
+     * `detailFehlt()` und laedt nur im ersten Fall nach.
      */
-    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;
-                context_id?: string | null;
-            };
-            draft: {
-                draft_id: string;
-                revision: number;
-                payload: unknown;
-                chain?: DraftChainMeta;
-            } | null;
-            draftFork?: unknown | null;
-            /**
-             * Veröffentlichte Versionen — für den Szene-Direktpfad (D-135).
-             *
-             * Eine Draft-Kette friert ausschließlich Entwürfe ein; eine Szene kann
-             * dagegen längst veröffentlicht sein und gar keinen Entwurf mehr haben.
-             * Beide Hosts liefern die Liste bereits mit (`ElementSnapshot`), sie war
-             * hier nur nicht deklariert.
-             */
-            versions?: readonly {
-                version_id: string;
-                element_id: string;
-                payload: unknown;
-                parents?: unknown;
-            }[];
-            preferredHeads?: readonly {
-                context_id: string | null;
-                version_id?: string;
-            }[];
-        } | null;
-    };
+    runs: readonly PromptRunPageRecord[];
+    /** Rundennummer je `run_id`, nur fuer die Laeufe dieser Seite. */
+    rounds: Readonly<Record<string, number>>;
+    sceneStates?: Readonly<Record<string, SceneRunState>>;
+    sceneImageCount?: number;
+    /** Laeufe, die der Herkunftsfilter ausgeblendet hat. */
+    hiddenByOrigin: number;
     /**
-     * Die Elemente eines Kettenglieds — fuer die allgemeinen Kontext-Policies
-     * des Szene-Direktlaufs (Schritt 03 §3).
+     * Die **direkten** Tags je `run_id`, nur fuer die Laeufe dieser Seite.
      *
-     * Optional im Typ, weil der Shot-Pfad dieselbe Momentaufnahme benutzt und
-     * dort keine Liste braucht. Im Szene-Direktlauf ist sie **Pflicht**: Fehlt
-     * sie, meldet die Policy-Aufloesung einen Fehler, statt „keine Policy"
-     * zu behaupten (Grundsatzregel 4).
+     * Ein Lauf ohne Eintrag hat keine Prompt-Tags. Getrennt von `annotations`
+     * gefuehrt, weil diese Tags aus demselben Log stammen wie die Laeufe und
+     * jeder Host sie hat — auch einer ohne Library-Bestand.
+     */
+    promptTags: Readonly<Record<string, readonly LibraryTagRef[]>>;
+    /**
+     * Der Anzeigename je `run_id`, nur fuer die Laeufe dieser Seite und nur, wo
+     * das benennende Element einen Titel hat.
      *
-     * Aus **derselben** Momentaufnahme wie `getElement` — genau das haelt die
-     * Policy-Auswahl in der A/B-Konsistenzgrenze und verhindert einen dritten
-     * Live-Leseweg (Gegenpruefung P2).
+     * Ein Lauf ohne Eintrag bleibt titellos und heisst „Runde n" — ein aus der
+     * `run_id` gebastelter Name saehe aus wie ein echter (D-75).
      */
-    listElements?(filter: {
-        contextId: string | null;
-        type: string;
-    }): {
-        kind: string;
-        message?: string;
-        value?: readonly {
-            element_id: string;
-            type: string;
-        }[];
-    };
+    titles?: Readonly<Record<string, string>>;
+    /**
+     * Bildanzahl, Vorschau und Library-Tags je `run_id` — nur wenn der Host sie
+     * liefern kann. Fehlt das Feld, weiss die Ansicht es nicht und sagt das.
+     */
+    annotations?: Readonly<Record<string, PromptRunAnnotation>>;
 }
 /**
- * Was das Einfrieren vom Elementspeicher braucht — bewusst schmal.
+ * Die Rundennummer **jedes** Laufs des uebergebenen Bestands.
  *
- * 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).
+ * Gerechnet auf der chronologischen Reihenfolge, die `collectPromptRuns`
+ * liefert — nicht auf der Anzeigereihenfolge. Die Anzeige dreht sich um; die
+ * Rundenzaehlung tut es nicht, sonst hiesse derselbe Lauf morgen anders.
  */
-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;
-}
+declare function roundsOf(alle: readonly PromptRunRecord[]): ReadonlyMap<string, number>;
 /**
- * Friert die vom Shot erreichbare Draft-Kette ein und baut die Renderer-Eingabe.
+ * Der eine Seitenschnitt fuer Prompt-Laeufe — Server wie Client.
  *
- * 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.
+ * Reine Funktion ueber einem bereits gelesenen Bestand, genau wie
+ * `selectPromptRuns`, das sie benutzt. Damit gilt der Bezugsrahmen (Status,
+ * Kontext) an beiden Enden unveraendert; dazu kommen Herkunft, Umkehrung und
+ * Schnitt.
+ *
+ * @param alle Der Bestand in der Reihenfolge von `collectPromptRuns`.
+ * @throws Wenn der Cursor in der gefilterten Liste nicht vorkommt (`pageOf`).
  */
-declare function freezeDraftChain(input: FreezeDraftChainInput): Promise<FreezeResult>;
+declare function pagePromptRuns(alle: readonly PromptRunRecord[], input?: PromptRunPageInput): PromptRunPage;
+/**
+ * Eine Seite, wie sie **ueber eine Leitung** geht — Kette `szenen-promptliste-transport`.
+ *
+ * Zwei Dinge fallen weg, beide gemessen an `GET /api2/szenen/prompt-runs/page`
+ * auf dev mit zehn Laeufen (203 kB):
+ *
+ * 1. **`items`.** Die Seite trug die Laufliste zweimal: einmal als `runs`,
+ *    einmal als `items` aus dem `Page<T>`-Vertrag. Im JSON sind das zwei
+ *    vollstaendige Kopien — 100 der 203 kB. Der Vertrag bleibt: Der Adapter
+ *    auf der anderen Seite setzt `items` aus `runs` wieder zusammen, statt es
+ *    zu uebertragen.
+ * 2. **Die Detailfelder** (`PROMPT_RUN_DETAIL_FIELDS`). 74 der uebrigen 100 kB,
+ *    und keines davon zeigt die Liste. Was bleibt, ist als
+ *    `PromptRunListRecord` **markiert**, damit die Ansicht ein fehlendes Feld
+ *    nicht fuer eine Aussage ueber den Lauf haelt.
+ *
+ * Rein und ohne Host: `items` wegzulassen ist eine Transportentscheidung, und
+ * sie gehoert neben den Seitenschnitt, nicht in einen Controller.
+ */
+declare function promptRunPageForTransport(seite: PromptRunPage): Omit<PromptRunPage, 'items'>;
+/**
+ * Die Gegenrichtung: `items` aus `runs` zuruecklegen.
+ *
+ * Der `Page<T>`-Vertrag gilt im Client unveraendert — er wurde nur nicht
+ * uebertragen. Ohne diesen Schritt fehlte `items` still, und jeder kuenftige
+ * Aufrufer von `Page<T>` saehe eine leere Seite statt eines Fehlers.
+ */
+declare function promptRunPageFromTransport(roh: Omit<PromptRunPage, 'items'>): PromptRunPage;
+
 /**
- * Was eingefroren wurde — **eines** von beidem, nie beides und nie erfunden.
+ * Ein Vorschlag, so wie er im Ereignis steht.
  *
- * Ein Entwurf hat `draft_id` und `revision` und keine `version_id`; eine
- * veröffentlichte Version genau umgekehrt. Ein Feld, das ehrlich `null` ist,
- * ist besser als eine Kennung, die wie eine echte aussieht (D-75/D-98).
+ * `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 FrozenSceneState {
-    element_id: string;
-    draft_id: string | null;
-    revision: number | null;
-    version_id: string | null;
-}
-interface FreezeSceneSuccess {
-    kind: 'ok';
-    scene: FrozenSceneState;
-    input: RendererInput;
+interface RecordedProposal {
+    type: DerivableType;
+    payload: Record<string, unknown>;
     /**
-     * Die automatisch aufgeloesten allgemeinen Kontext-Policies (Schritt 03).
+     * `complete`: erfüllt das reguläre Element-Schema.
+     * `partial`: erfüllt es bis auf die in `gaps` benannten Pflichtfelder.
      *
-     * Redundant zu `input.policies` und trotzdem hier: Der Aufrufer sieht so den
-     * Satz **mit** `chain_index`, ohne die Ordnung nachbauen zu muessen. Der
-     * eingefrorene Lauf traegt weiterhin ausschliesslich `input`.
+     * 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.
      */
-    policies: readonly ResolvedScenePolicy[];
+    status?: 'complete' | 'partial';
+    gaps?: readonly {
+        pointer: string;
+        reason: string;
+    }[];
     /**
-     * Das eingefrorene Zielmodell, oder `null` fuer einen generischen Lauf.
+     * Der Namensvorschlag des Modells (D-83), sofern es einen brauchbaren gab.
      *
-     * Wie `policies` redundant zu `input` und trotzdem hier: Der Aufrufer sieht
-     * die Provenienz, ohne sie aus `renderer_input` zurueckrechnen zu muessen.
+     * 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).
      */
-    targetModel: FrozenSceneTargetModel | null;
+    title?: string;
 }
-type FreezeSceneResult = FreezeSceneSuccess | FreezeFailure;
-interface FreezeSceneWorkingStateInput {
-    /** Das Szenen-**Element**. Ob Entwurf oder Version, entscheidet der Bestand. */
-    sceneElementId: string;
-    store: ChainQueries;
-    resolver: ReferenceResolver;
-    contextChain: readonly (string | null)[];
-    userInstruction?: string | null;
+/**
+ * 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;
     /**
-     * Das gewaehlte Zielmodell (Kette `szenen-direktlauf-target-model-policy`).
+     * 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.
      *
-     * Optional: Ohne Angabe bleibt der Ablauf exakt der generische von D-135 —
-     * kein Zielmodell im `RendererInput`, keine `target_model`-Policy.
+     * 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.
      */
-    targetModelElementId?: string | null;
+    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;
 /**
- * Das gewaehlte Zielmodell eines Szene-Direktlaufs — Kette
- * `szenen-direktlauf-target-model-policy`, Schritt 01.
- *
- * **Warum ueber die `element_id` und nicht ueber den Key.** Der Shot-Pfad sucht
- * ein Zielmodell ueber `prompt_render_settings.target_model_id`, also ueber
- * einen freien Key entlang der Kette — mit allen Ausgaengen, die dazugehoeren
- * (`not_found`, `ambiguous`, `retired`, `fork`). Der Szene-Direktlauf bekommt
- * das Modell dagegen von einem Menschen ausgewaehlt, und der waehlt es aus
- * einer Liste, die schon aufgeloest ist. Die Kennung ist damit eindeutig, und
- * sie ist dieselbe, die eine `target_model`-Policy in
- * `applicable_target_models` nennt. Eine zweite Suche ueber einen geratenen
- * Namen waere fehleranfaelliger als die Kennung, die vorliegt.
+ * Liest alle Rekonstruktionsläufe aus dem Ereignislog.
  *
- * Die **Version** waehlt trotzdem niemand von Hand: Sie kommt aus derselben
- * D-36-Preferred-Head-Aufloesung wie der Arbeitsstand der Szene daneben.
+ * 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.
  */
-interface FrozenSceneTargetModel {
-    element_id: string;
-    version_id: string;
-    /** Glied der Kontextkette, auf dem das Element liegt. `0` = Arbeitskontext. */
-    chain_index: number;
-    payload: unknown;
-    head: PreferredHeadResolution;
+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;
 /**
- * Friert den Arbeitsstand **einer Szene** ein und baut die Renderer-Eingabe
- * (D-135).
+ * Liest alle Provider-Checks aus dem Ereignislog.
  *
- * Dasselbe optimistische Zwei-Durchgang-Verfahren wie bei der Draft-Kette
- * (D-97): lesen, kopieren, frisch nachlesen, Revision vergleichen, und den
- * Snapshot aus den **kopierten** Inhalten bauen. Ein Konflikt bleibt ein
- * echter Blocker — **vor** dem kostenpflichtigen Provideraufruf. Dieser Goal
- * lockert daran nichts (Goal §8.1).
+ * 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 veröffentlichte Version ist unveränderlich; für sie kann Durchgang B
- * keinen Revisionskonflikt finden. Er läuft trotzdem: Verschwindet die Version
- * zwischen den Durchgängen aus der wirksamen Sicht — stillgelegt, ein anderer
- * Preferred Head —, ist der Stand nicht mehr der, den der Nutzer gesehen hat.
+ * Eine Stelle, an der summiert wird — sonst zählt die UI anders als der
+ * Bericht, und niemand weiß, welche Zahl stimmt.
  */
-declare function freezeSceneWorkingState(input: FreezeSceneWorkingStateInput): Promise<FreezeSceneResult>;
+declare function totalModelCalls(checks: readonly ProviderCheckRecord[]): number;
 
 /**
  * Wie brauchbar das Material einer Arbeitsfassung ist.
@@ -2119,6 +2261,7 @@ interface ImageGenerationStartedPayload {
     request: {
         image_count: number;
         aspect_ratio?: string;
+        reference_asset_ids?: readonly string[];
         seeds?: readonly number[];
         callable_model_id: string;
         /**
@@ -2235,6 +2378,9 @@ interface IdFactory {
     newId(): string;
 }
 interface CreateHfElementStoreOptions {
+    readPromptConstructionTags?: () => Promise<readonly PromptConstructionTag[]>;
+    /** Host-injected read of the existing Library vocabulary, no second tag store. */
+    readReferenceSentenceTags?: () => Promise<readonly ReferenceSentenceTag[]>;
     channel: ElementEventChannel;
     ids?: IdFactory;
     /**
@@ -2432,6 +2578,7 @@ declare function checkSetPreferredHeadInput(input: {
 declare function checkReviseMetadataInput(input: {
     elementId: unknown;
     title: unknown;
+    cover_media_ref?: unknown;
     expectedRevision: unknown;
 }): InputError;
 /** Bequemlichkeit für Aufrufer, die den Typ eng brauchen. */
@@ -2524,6 +2671,7 @@ interface ImageExecutionRoute {
 }
 /** Ein Zielmodell, so wie die Auswahl es braucht. */
 interface ExecutionTargetModel {
+    supportedControlInputs?: readonly string[];
     key: string;
     title: string;
     provider: string | null;
@@ -2534,6 +2682,7 @@ interface ExecutionTargetModel {
 }
 /** Eine wirklich ausführbare Kombination aus Zielmodell und Profil. */
 interface ExecutableImageModel {
+    accepts_reference_image?: boolean;
     /** Kennung der Auswahl: Zielmodell **und** Profil, weil beides zählt. */
     selection_id: string;
     target_model_key: string;
@@ -2638,6 +2787,11 @@ interface GeneratedImage {
 }
 /** Die Eingabe an den tatsächlichen Provideraufruf — abgeleitet aus dem eingefrorenen Lauf. */
 interface ImageProviderInput {
+    referenceImages?: readonly {
+        data: string;
+        mime_type: string;
+        asset_id: string;
+    }[];
     /** Das Zielmodell, mit dem ausgeführt wird — die fachliche Kennung (D-131). */
     targetModelKey: string;
     /** Der Aufrufweg aus dem gewählten Profil; der Adapter prüft, ob er ihn hat. */
@@ -2750,6 +2904,9 @@ interface SzenenImageGenerationPort {
     startFromPromptRun(input: StartImageGenerationInput): Promise<ImageGenerationResult>;
 }
 interface CreateImageGenerationPortOptions {
+    loadCameraPreview?(runId: string): Promise<QueryResult<CameraPreview & {
+        asset_id: string;
+    }>>;
     runs: ImageGenerationRunReader;
     provider: ImageGenerationProviderPort;
     batches: ImageGenerationBatchPersistence;
@@ -3144,6 +3301,26 @@ interface RequestMoreImagesInput {
     sourceJobId: string;
     /** Wie viele Bilder der **neue** Auftrag anfordert. */
     imageCount: number;
+    /**
+     * Ein **anderes** Zielmodell als das des Ausgangsauftrags (Schritt 06).
+     *
+     * Fehlt es, gilt das des Ausgangsauftrags — das ist der Normalfall und die
+     * Vorbelegung der Oberflaeche. Gesetzt heisst: Der Nutzer hat bewusst
+     * gewechselt. Geprueft wird in beiden Faellen gegen dieselbe heute gueltige
+     * Auswahl; ein gewaehltes Modell wird so wenig geraten wie ein uebernommenes.
+     *
+     * `executionProfileId` gehoert dazu — ein Zielmodell kann mehrere Profile
+     * tragen, und welches gemeint ist, entscheidet nicht der Port.
+     */
+    executionTargetModelKey?: string;
+    executionProfileId?: string;
+    /**
+     * Ein anderes Seitenverhaeltnis. Fehlt es, gilt das des Ausgangsauftrags.
+     *
+     * `null` heisst ausdruecklich **ohne** Seitenverhaeltnis — das ist etwas
+     * anderes als „nicht angegeben" und wird deshalb unterschieden (Regel 4).
+     */
+    aspectRatio?: string | null;
     /** Die Kennung des neuen Auftrags. Ersetzbar, damit ein Test nicht wuerfelt. */
     jobId?: string;
 }
@@ -3267,6 +3444,13 @@ interface StartRunInput {
 }
 /** Lesen und Starten von Prompt-Läufen. */
 interface SzenenRunPort {
+    supportsCameraPreview?: boolean;
+    /** Wiederholt ausschließlich die Medienablage eines bereits gespeicherten Laufs. */
+    retryCameraPreview?(runId: string, render: CameraPreviewRenderer): Promise<CommandResult<PromptRunRecord>>;
+    /** Das gespeicherte Kamera-Preview eines Laufs zum Anzeigen; fehlt, wenn der Host es nicht lesen kann. */
+    loadCameraPreview?(runId: string): Promise<QueryResult<CameraPreview & {
+        asset_id: string;
+    }>>;
     /**
      * Alle Läufe einer Shot-Version, chronologisch.
      *
@@ -3476,8 +3660,10 @@ type StartRunFromDraftResult = {
     kind: 'error';
     message: string;
     retryable: boolean;
+    storedRunId?: string;
 };
 interface StartRunFromDraftInput {
+    previewRenderer?: CameraPreviewRenderer;
     /** Das Shot-**Element** der Kette. Eine Version gibt es hier gerade nicht. */
     shotElementId: string;
     userInstruction?: string;
@@ -3840,6 +4026,17 @@ interface SzenenMediaPort {
     }): Promise<CommandResult<{
         removed: boolean;
     }>>;
+    /**
+     * Eine anzeigbare Vorschau (`<img src>`-faehig) fuer ein Medien-Asset —
+     * Kette `szenen-design`, P4: die Referenzbilder am Szenen-Node
+     * (`sceneNode.media_refs[].asset_id`).
+     *
+     * Optional (R11): Ein Host, der `media_assets` nicht aufloesen kann, laesst
+     * die Operation weg, und die Ansicht nennt dann den Grund statt einer leeren
+     * Kachel. Aufgeloest wird nur, was der Nutzer selbst fuehrt; ein fremdes
+     * oder unbekanntes Asset ist ein `error` mit Begruendung, kein leeres Bild.
+     */
+    loadAssetPreview?(assetId: string): Promise<QueryResult<string>>;
 }
 /**
  * Ein Bild eines Batches, wie der Lesepfad es liefert.
@@ -3851,6 +4048,8 @@ interface SzenenMediaPort {
  */
 interface PromptBatchImageRef {
     asset_id?: string;
+    /** Rolle am Item; `reference` ist ein Kamera-Preview und kein Ergebnisbild. */
+    role?: string;
     media_ref: string;
     position: number;
     file?: string;
@@ -4213,7 +4412,7 @@ interface HfImageStore {
      * wäre für jeden Leser ein Fehler; umgekehrt ist es nur eine Datei, die noch
      * kein Ereignis kennt.
      */
-    putWithId(id: string, base64: string, mimeType: string, titel?: string): Promise<void>;
+    putWithId(id: string, base64: string, mimeType: string, prompt?: string, provenance?: Pick<HFMetadataEntry, 'source' | 'flow_provenance' | 'title'>): Promise<void>;
     /** Löst eine Kennung auf. `mimeType` ist ein Hinweis, kein Zwang. */
     resolve(id: string, mimeType?: string | null): Promise<AufgeloestesBild>;
     /**
@@ -4364,7 +4563,7 @@ interface LadeVorschauenOptionen {
  * als ein Wähler ohne Kacheln, und ob das Bild wirklich fehlt, entscheidet der
  * Lauf selbst über `resolveImage()`.
  */
-declare function ladeVorschauen(port: SzenenImageLibraryPort, mediaRefs: readonly string[], fertig: (mediaRef: string, quelle: string) => void, optionen?: LadeVorschauenOptionen): Promise<void>;
+declare function ladeVorschauen(port: Pick<SzenenImageLibraryPort, 'loadPreview'>, mediaRefs: readonly string[], fertig: (mediaRef: string, quelle: string) => void, optionen?: LadeVorschauenOptionen): Promise<void>;
 
 /**
  * Der Anbieter eines manuell erfassten Laufs.
@@ -4477,6 +4676,14 @@ interface CreateMemoryViewPortOptions {
     items?: boolean;
     /** Ob der Port Medien anbietet (Stufe 5 vorhanden). */
     media?: boolean;
+    /**
+     * Anzeigbare Vorschauen je `asset_id` (Kette `szenen-design`, P4).
+     *
+     * Gesetzt bietet der Medienport `loadAssetPreview()` an und beantwortet eine
+     * unbekannte Kennung mit einem Fehler. Fehlt die Angabe, fehlt auch die
+     * Operation — wie in einem Host, der Assets nicht aufloesen kann (R11).
+     */
+    assetPreviews?: Readonly<Record<string, string>>;
     /**
      * Ob der Port einen Bildbestand anbietet (D-94).
      *
@@ -4591,7 +4798,7 @@ declare const FLOW_EXECUTION_PATH = "google_flow";
 /**
  * Ein Provideraufruf je Bild — dieselbe Begründung wie beim React-Adapter
  * (`reactImageProvider.ts`): Das SDK kennt keinen Mehrbild-Parameter
- * (`howto-flow-sdk.md`, CONVERGE-Fundstelle „4 Varianten gleichzeitig").
+ * (the Flow SDK host contract, CONVERGE-Fundstelle „4 Varianten gleichzeitig").
  * Teilfehler verwerfen nichts: Bricht der k-te Aufruf ab, werden die ersten
  * k-1 Bilder zurückgegeben; nur wenn **kein** Bild zustande kam, wirft der
  * Adapter.
@@ -4615,6 +4822,8 @@ interface CreateFlowSzenenViewPortOptions {
     textPort?: TextGenerationPort;
     /** Existing channel for tests or embedded hosts. Otherwise HF credentials are required. */
     channel?: ElementEventChannel;
+    readPromptConstructionTags?: () => Promise<readonly PromptConstructionTag[]>;
+    readReferenceSentenceTags?: () => Promise<readonly ReferenceSentenceTag[]>;
     namespace?: string;
     token?: string;
     context?: ContextChainPort;
@@ -4711,6 +4920,11 @@ declare function createBrowserTextGenerationPort(options?: CreateBrowserTextGene
  * Providerantwort und leitet keine Runde ab. Er speichert, was er bekommt.
  */
 interface PromptRunPersistencePort {
+    storeCameraPreview?(runId: string, preview: CameraPreview): Promise<CommandResult<void>>;
+    /** Liest genau das am Run-Item gespeicherte Preview (geprüft gegen den Lauf). */
+    loadCameraPreview?(runId: string): Promise<QueryResult<CameraPreview & {
+        asset_id: string;
+    }>>;
     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. */
@@ -5000,6 +5214,7 @@ interface SelectableTargetModel {
      * Kombinationen trifft `executableImageModels()`, nicht diese Datei.
      */
     executionProfiles: readonly unknown[];
+    supportedControlInputs?: readonly string[];
     /** Glied der Kette, auf dem der Treffer lag. `0` = Arbeitskontext. */
     chainIndex: number;
 }
@@ -5449,6 +5664,91 @@ declare function noticeFor(ergebnis: {
     [k: string]: unknown;
 }, was: string): Notice;
 
+/** Was der Host über den Lauf wissen muss, um einen Auftrag anzubieten. */
+interface SzenenServerJobKontext {
+    cameraAspectRatio?: string;
+    needsCameraReference?: boolean;
+    /** Wie der Prompt das Referenzbild nennt — aus dem eingefrorenen Zielmodell des Laufs. */
+    cameraReferenceToken?: string | null;
+    /** Das gespeicherte Kamera-Preview zum Anzeigen (Data-URL), sobald geladen. */
+    cameraPreviewSrc?: string | null;
+    /** Der Promptlauf — Ziel der kanonischen Speicherung. */
+    runId: string;
+    /** Das Element, aus dem der Lauf stammt — die Herkunft des Auftrags. */
+    elementId: string | null;
+    /** Der eingefrorene positive Prompt dieses Laufs (D-103). */
+    prompt: string;
+    /**
+     * Die auf diesem Host ausführbaren Modelle des Laufs — dieselbe Auswahl,
+     * die auch die eingebaute Bilderzeugung anbietet.
+     *
+     * Der Host bekommt sie **fertig aufgelöst** statt einer Rohliste von
+     * Profilen: `execution_path` und `execution_model_id` stehen darin
+     * unverändert so, wie das Ausführungsprofil sie führt. Was der Host damit
+     * macht — ob er sie auf einen eigenen Katalog abbildet und was passiert,
+     * wenn das nicht aufgeht —, ist seine Sache und nicht die der Domain.
+     */
+    models: readonly ExecutableImageModel[];
+    /**
+     * Sagt der Laufansicht, dass sich ihr Bildbestand geändert hat.
+     *
+     * Der Host speichert außerhalb dieser Ansicht — sein Auftrag läuft auf einem
+     * Server weiter, während der Nutzer hier steht. Ohne diesen Rückruf bliebe
+     * die Ansicht auf dem Stand von vorhin stehen: Das Bild ist gespeichert und
+     * über `listRunBatches` auch abrufbar, aber niemand fragt danach. Genau das
+     * sah in der Abnahme wie „das Bild ist verloren" aus — zwölf Bilder vor dem
+     * Lauf, zwölf danach, obwohl das dreizehnte längst im Bestand lag.
+     *
+     * Der Host ruft ihn, wenn ein Auftrag Bilder kanonisch abgelegt hat.
+     */
+    onBestandGeaendert: () => void;
+    /**
+     * Meldet die Serverauftraege des Hosts an die gemeinsame Zeitleiste der
+     * Laufansicht (Kette `szenen-design`, P5, Entscheidung 4).
+     *
+     * Die Laufansicht kennt den Serverjobpfad nicht; sie zeigt nur, was der
+     * Host hier als fertige Zeilen meldet — neben den Auftraegen aus dem
+     * Order-Log des Ports. Der Host ruft ihn bei jedem neuen Stand seiner
+     * Auftragsliste mit dem **vollstaendigen** Satz, nicht mit einer Differenz.
+     */
+    onAuftraegeGeaendert: (zeilen: readonly ServerAuftragZeile[]) => void;
+}
+/** Wie eine Zeile der Auftrags-Zeitleiste ausgegangen ist. */
+type AuftragZustand = 'fertig' | 'teilweise' | 'fehlgeschlagen' | 'laeuft' | 'abgebrochen';
+/** Eine Handlung an einer Zeitleistenzeile — etwa einen gesammelten Auftrag freigeben. */
+interface AuftragAktion {
+    label: string;
+    onAusfuehren: () => void;
+    /** Stabile Kennung fuer Tests und Schluessel. */
+    id: string;
+}
+/**
+ * Ein Auftrag, wie die Zeitleiste ihn zeigt — vom Host fertig beschrieben.
+ *
+ * Alles ist Anzeige: Die Zeitleiste deutet keine Felder, sie setzt sie nur.
+ */
+interface ServerAuftragZeile {
+    /** Die Auftrags-ID des Hosts — Schluessel und Teil der Meldung. */
+    id: string;
+    zustand: AuftragZustand;
+    /** Modell, Format, Anzahl — eine Zeile. */
+    titel: string;
+    /** Das Ergebnis in Worten, etwa „fertig · 1 von 1 Bild gespeichert". */
+    ergebnis: string;
+    /** Die vollstaendige Meldung (Fehlertext, Task-Kennung …), zum Aufklappen. */
+    meldung: readonly string[];
+    aktionen?: readonly AuftragAktion[];
+    /** Das Referenzbild, das dieser Auftrag mitgibt — nur wenn er eines hat. */
+    referenzBild?: {
+        src: string | null;
+        beschriftung: string;
+    };
+    /** Der Prompt genau so, wie der Auftrag ihn eingefroren hat. */
+    prompt?: string;
+}
+/** Der Knoten, den der Host am Lauf zeigen will — oder nichts. */
+type SzenenServerJobSlot = (kontext: SzenenServerJobKontext) => React__default.ReactNode;
+
 interface SzenenViewProps {
     port: SzenenViewPort;
     /** Arbeitskontext. Die wirksame Kette löst der Port auf, nicht die View. */
@@ -5468,6 +5768,15 @@ interface SzenenViewProps {
     fokus?: SzenenFokus | null;
     /** Zurück dorthin, woher der Fokus kam. Fehlt, wenn es kein Zurück gibt. */
     onFokusVerlassen?: () => void;
+    /**
+     * Ein hosteigener Serverauftrag am Promptlauf — optional.
+     *
+     * Die Ansicht ruft ihn nur auf und zeigt, was zurückkommt. Ein Host ohne
+     * eigenen Serverjobpfad (Flow-FA) lässt ihn weg und sieht exakt dieselbe
+     * Oberfläche wie bisher; die Flow-/HF-Ausführung wird dadurch weder
+     * berührt noch umgeleitet.
+     */
+    serverJobSlot?: SzenenServerJobSlot | null;
 }
 /** Das angesteuerte Ziel. Genau eines — nie beides und nie geraten. */
 type SzenenFokus = {
@@ -5489,4 +5798,69 @@ type SzenenFokus = {
 declare function areaForFokus(fokus: SzenenFokus): SzenenAreaId;
 declare const SzenenView: React__default.FC<SzenenViewProps>;
 
-export { type AddManualSceneRunInput, type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, type BestandsGalerieEintrag, type BestandsItem, type BuildManualPromptRunInput, CATALOGUE_TYPES, CapabilityAnchorError, type CapabilityFlag, type CapabilityFlagName, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClaimAndRunResult, type ClientDerivationChannel, type ClientDerivationStore, type CompletePromptOperationInput, type CompletePromptOperationResult, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateImageJobPortOptions, type CreateMemoryViewPortOptions, DEFAULT_SEED_VORLAGE, 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, ElementAnnotation, ElementEvent, type ElementEventChannel, type ExecutableImageModel, type ExecutionTargetModel, type ExistingSzenenItem, FLOW_EXECUTION_PATH, type FlowGenerateImage, type FlowGenerateImageParams, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSceneResult, type FreezeSceneSuccess, type FreezeSceneWorkingStateInput, type FreezeSuccess, type FrozenChainNode, type FrozenSceneState, GENERAL_POLICY_SUBTYPE, type GeneratedImage, type GruppierbaresBild, type HfImageStore, type HfImageStoreOptions, type IdFactory, type ImageExecutionProfile, type ImageExecutionRoute, type ImageExecutionTargetModelReader, type ImageGenerationBatchPersistence, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, type ImageHostCapability, type ImageJob, type ImageJobChannel, type ImageJobClaimedPayload, type ImageJobEintrag, type ImageJobHerkunft, type ImageJobQuery, type ImageJobRequestedPayload, type ImageJobSeite, type ImageJobSettledPayload, type ImageJobStatusFilter, type ImageModelChoice, type ImageModelParameters, ImageProvenance, type ImageProviderInput, type ImportBatchImageInput, type ImportBatchInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LetztesErzeugtesBild, type LibraryImage, type LibraryImageItem, LibraryTagRef, MANUAL_MODEL_ID, MANUAL_NODE_STATE, MANUAL_PROVIDER, MANUAL_VISIBILITY_BASIS, MCP_CLIENT_PROVIDER, type ManualPromptEntry, type ManualPromptRunRecord, type NodeContribution, NotDerivable, type Notice, type NoticeTone, PAUSE_SEKUNDEN_OPTIONEN, PAUSE_SEKUNDEN_VORGABE, PROMPT_AUSZUG_ZEICHEN, PROMPT_RULE_EFFECT, PROMPT_RUN_DETAIL_FIELDS, Page, PageRequest, type PolicySnapshot, PreferredHeadResolution, type PreparePromptOperationInput, type PreparePromptOperationResult, type PreparedPromptOperation, type PromptBatchImageRef, type PromptBatchOrigin, type PromptDiagnostic, type PromptEffect, type PromptExecutionOrigin, type PromptImageBatch, type PromptOperationPreparedPayload, type PromptResponseContract, PromptRunAnnotation, type PromptRunFilter, type PromptRunGroup, type PromptRunListRecord, type PromptRunListing, type PromptRunOriginFilter, type PromptRunOutcome, type PromptRunOutput, type PromptRunPage, type PromptRunPageFilter, type PromptRunPageInput, type PromptRunPageRecord, type PromptRunPageSource, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type PromptRunSource, type PromptRunStatusFilter, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, type QueueAusgang, type QueueFortschritt, type QueueLaufOptionen, type QueueZustand, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, ReferenceResolver, type RendererInput, type RequestMoreImagesInput, type RequestMoreImagesResult, type ResolveFailure, type ResolveResult, type ResolveScenePayloadInput, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type ResolvedScenePolicy, type RunBild, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, SZENEN_SNAPSHOT_FILE, SZENEN_SNAPSHOT_PREFIX, SZENEN_SNAPSHOT_SCHEMA_VERSION, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, type ScenePolicyResult, SchemaError, type SeedVorlage, type SeedZuordnung, type SeedZuordnungEintrag, type SelectableTargetModel, type StartImageGenerationInput, type StartRunFromSceneInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, type SzenenBatchSourceKind, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenFokus, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageJobPort, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenLeseErgebnis, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, type SzenenSeedTemplatePort, type SzenenSnapshot, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UNVERIFIED_MODEL_ID, UPLOAD_MAX_BYTES, type UnselectableTargetModel, UnusableProposal, type VersionMedium, type VisibilityNode, type ZipBild, areaForFokus, areasFor, batchesForPromptRun, bildPfad, bilderDesLaufs, buildManualPromptRunRecord, buildSystemInstruction, buildSzenenSnapshot, buildUserPrompt, callOptional, capabilitiesOf, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkImageExecutionProfile, checkImageExecutionProfiles, checkImageModelParameters, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, claimWon, collectImageBatches, collectImageGenerationOrders, collectImageJobs, collectPromptOperations, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, completePromptOperation, contextOfRun, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createImageJobPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, describableContent, detailFehlt, diagnosticOfFinding, diagnosticOfSchemaError, differentialSteps, executableImageModels, findExecutableImageModel, findImageBatch, findImageGenerationOrder, findImageJob, findPromptOperation, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, formatSeedListe, freezeDraftChain, freezeSceneWorkingState, fuehreQueueAus, generationBatchIdOf, gesamtHerkunft, groupKeyOf, groupOf, gruppiereZuItems, hasPlacementCapability, isKnownElementType, isSzenenItemId, istGueltigePause, istOffen, istSzenenSnapshotDatei, istZipDatei, itemIdForRun, itemsAusBestand, jobsForPromptRun, ladeVorschauen, leseBilderAusZip, letztesErzeugtesBild, locatorAus, locatorTeile, manualEntryOf, mergeSnapshotAndPending, mergeSzenenBatchOrigin, mimeTypAus, mitDefaultVorlage, namingElementOf, noticeFor, ordersForPromptRun, ordneSeedsZu, pagePromptRuns, parseRunResponse, parseSeedListe, parseSzenenSnapshot, preparePromptOperation, promptDiagnosticsOf, promptRunPageForTransport, promptRunPageFromTransport, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, resolveArea, resolveGeneralScenePolicies, resolveScenePayload, resolveShot, resolveShotPayload, responseContractOf, roundOfRun, roundsOf, rulesWithoutPromptEffect, runOfOperation, runPromptDerivation, runStoreDifferential, sameResponseAs, sceneOnlyCapabilities, scenePolicyFingerprint, scopeOfPath, seedFehlerText, selectImageJobs, selectPromptRuns, selectableTargetModels, siblingsOf, sortScenePolicies, sourceOf, szenenSnapshotFilename, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };
+type StagePlane = 'top' | 'side' | 'camera';
+type Vec3 = [number, number, number];
+declare const STAGE_CATALOGUE: readonly [{
+    readonly label: "Mensch";
+    readonly type: "subject";
+    readonly dimensions: readonly [0.55, 0.35, 1.75];
+}, {
+    readonly label: "Stuhl";
+    readonly type: "object";
+    readonly dimensions: readonly [0.5, 0.5, 0.9];
+}, {
+    readonly label: "Tisch";
+    readonly type: "surface";
+    readonly dimensions: readonly [1.2, 0.7, 0.75];
+}, {
+    readonly label: "Lampe";
+    readonly type: "light";
+    readonly dimensions: readonly [0.35, 0.35, 1.5];
+}];
+/** Nur die zwei sichtbaren Achsen ändern; die verborgene Tiefe bleibt erhalten. */
+declare function dragPosition(position: readonly number[], point: readonly number[], plane: StagePlane): Vec3;
+declare function stageNode(node: ResolvedNode): {
+    node_id: string;
+    type: string;
+    primitive: string;
+    dimensions: Vec3;
+    position: Vec3;
+    rotation: Vec3;
+    scale: Vec3;
+    anchors: Readonly<Record<string, readonly number[]>> | undefined;
+};
+/** Rendern ist nur bei vollständigen Daten zulässig, niemals mit geratenen Positionen. */
+declare function stageFrame(input: RendererInput): {
+    nodes: {
+        preview_color: {
+            hex: string;
+            name: string;
+        };
+        node_id: string;
+        type: string;
+        primitive: string;
+        dimensions: Vec3;
+        position: Vec3;
+        rotation: Vec3;
+        scale: Vec3;
+        anchors: Readonly<Record<string, readonly number[]>> | undefined;
+    }[];
+    camera: {
+        position: Vec3;
+        orientation: Record<string, unknown>;
+        aspect_ratio: string;
+        aspect: number;
+        focal_length_mm: number;
+        sensor_width_mm: number;
+        vertical_fov_deg: number;
+        camera_id: string;
+        name: string | null;
+        preset: unknown;
+        placement: unknown;
+        framing: unknown;
+        focus: unknown;
+        pattern: unknown | null;
+    };
+};
+
+export { type AddManualSceneRunInput, type AttachLibraryItemInput, type AttachLibraryItemResult, type AuftragAktion, type AuftragZustand, AuthoritativeSzenenStore, type BestandsGalerieEintrag, type BestandsItem, type BuildManualPromptRunInput, CAMERA_ASPECT_RATIOS, CATALOGUE_TYPES, type CameraPreview, type CameraPreviewContext, type CameraPreviewDescriptor, type CameraPreviewRenderer, CapabilityAnchorError, type CapabilityFlag, type CapabilityFlagName, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClaimAndRunResult, type ClientDerivationChannel, type ClientDerivationStore, type CompletePromptOperationInput, type CompletePromptOperationResult, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateImageJobPortOptions, type CreateMemoryViewPortOptions, DEFAULT_SEED_VORLAGE, 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, ElementAnnotation, ElementEvent, type ElementEventChannel, ElementStoreState, type ExecutableImageModel, type ExecutionTargetModel, type ExistingSzenenItem, FLOW_EXECUTION_PATH, type FlowGenerateImage, type FlowGenerateImageParams, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSceneResult, type FreezeSceneSuccess, type FreezeSceneWorkingStateInput, type FreezeSuccess, type FrozenChainNode, type FrozenReferenceSentence, type FrozenSceneState, GENERAL_POLICY_SUBTYPE, type GeneratedImage, type GruppierbaresBild, type HfImageStore, type HfImageStoreOptions, type IdFactory, type ImageExecutionProfile, type ImageExecutionRoute, type ImageExecutionTargetModelReader, type ImageGenerationBatchPersistence, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, type ImageHostCapability, type ImageJob, type ImageJobChannel, type ImageJobClaimedPayload, type ImageJobEintrag, type ImageJobHerkunft, type ImageJobQuery, type ImageJobRequestedPayload, type ImageJobSeite, type ImageJobSettledPayload, type ImageJobStatusFilter, type ImageModelChoice, type ImageModelParameters, ImageProvenance, type ImageProviderInput, type ImportBatchImageInput, type ImportBatchInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LetztesErzeugtesBild, type LibraryImage, type LibraryImageItem, LibraryTagRef, MANUAL_MODEL_ID, MANUAL_NODE_STATE, MANUAL_PROVIDER, MANUAL_VISIBILITY_BASIS, MCP_CLIENT_PROVIDER, type ManualPromptEntry, type ManualPromptRunRecord, type NodeContribution, NotDerivable, type Notice, type NoticeTone, PAUSE_SEKUNDEN_OPTIONEN, PAUSE_SEKUNDEN_VORGABE, PROMPT_AUSZUG_ZEICHEN, PROMPT_RULE_EFFECT, PROMPT_RUN_DETAIL_FIELDS, Page, PageRequest, type PolicySnapshot, PreferredHeadResolution, type PreparePromptOperationInput, type PreparePromptOperationResult, type PreparedPromptOperation, type PromptBatchImageRef, type PromptBatchOrigin, PromptConstructionTag, type PromptDiagnostic, type PromptEffect, type PromptExecutionOrigin, type PromptImageBatch, type PromptOperationPreparedPayload, type PromptResponseContract, PromptRunAnnotation, type PromptRunFilter, type PromptRunGroup, type PromptRunListRecord, type PromptRunListing, type PromptRunOriginFilter, type PromptRunOutcome, type PromptRunOutput, type PromptRunPage, type PromptRunPageFilter, type PromptRunPageInput, type PromptRunPageRecord, type PromptRunPageSource, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type PromptRunSource, type PromptRunStatusFilter, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, type QueueAusgang, type QueueFortschritt, type QueueLaufOptionen, type QueueZustand, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, ReferenceResolver, type ReferenceSentenceTag, type RendererInput, type RequestMoreImagesInput, type RequestMoreImagesResult, type ResolveFailure, type ResolveResult, type ResolveScenePayloadInput, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type ResolvedScenePolicy, type RunBild, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, STAGE_CATALOGUE, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, SZENEN_SNAPSHOT_FILE, SZENEN_SNAPSHOT_PREFIX, SZENEN_SNAPSHOT_SCHEMA_VERSION, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, type ScenePolicyResult, SchemaError, type SeedVorlage, type SeedZuordnung, type SeedZuordnungEintrag, type SelectableTargetModel, type ServerAuftragZeile, type StartImageGenerationInput, type StartRunFromSceneInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, type SzenenBatchSourceKind, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenFokus, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageJobPort, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenLeseErgebnis, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, type SzenenSeedTemplatePort, type SzenenServerJobKontext, type SzenenServerJobSlot, type SzenenSnapshot, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UNVERIFIED_MODEL_ID, UPLOAD_MAX_BYTES, type UnselectableTargetModel, UnusableProposal, type VersionMedium, type VisibilityNode, type ZipBild, areaForFokus, areasFor, batchesForPromptRun, bildPfad, bilderDesLaufs, buildCameraPreviewContext, buildManualPromptRunRecord, buildSystemInstruction, buildSzenenSnapshot, buildUserPrompt, callOptional, cameraAspectRatioValue, cameraPerspective, capabilitiesOf, capabilityGate, capabilityReport, catalogueFor, checkCameraAspectRatioChanges, checkCreateElementInput, checkElementType, checkImageExecutionProfile, checkImageExecutionProfiles, checkImageModelParameters, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, claimWon, collectImageBatches, collectImageGenerationOrders, collectImageJobs, collectPromptOperations, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, completePromptOperation, contextOfRun, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createImageJobPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, describableContent, detailFehlt, diagnosticOfFinding, diagnosticOfSchemaError, differentialSteps, dragPosition, executableImageModels, findExecutableImageModel, findImageBatch, findImageGenerationOrder, findImageJob, findPromptOperation, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, formatSeedListe, freezeDraftChain, freezeSceneWorkingState, frozenCameraAspectRatio, fuehreQueueAus, generationBatchIdOf, gesamtHerkunft, groupKeyOf, groupOf, gruppiereZuItems, hasPlacementCapability, isKnownElementType, isSzenenItemId, istGueltigePause, istOffen, istSzenenSnapshotDatei, istZipDatei, itemIdForRun, itemsAusBestand, jobsForPromptRun, ladeVorschauen, leseBilderAusZip, letztesErzeugtesBild, locatorAus, locatorTeile, manualEntryOf, mergeSnapshotAndPending, mergeSzenenBatchOrigin, mimeTypAus, mitDefaultVorlage, namingElementOf, noticeFor, ordersForPromptRun, ordneSeedsZu, pagePromptRuns, parseRunResponse, parseSeedListe, parseSzenenSnapshot, preparePromptDerivation, preparePromptOperation, promptDiagnosticsOf, promptRunPageForTransport, promptRunPageFromTransport, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, resolveArea, resolveGeneralScenePolicies, resolveScenePayload, resolveShot, resolveShotPayload, responseContractOf, roundOfRun, roundsOf, rulesWithoutPromptEffect, runOfOperation, runPromptDerivation, runStoreDifferential, sameResponseAs, sceneOnlyCapabilities, scenePolicyFingerprint, sceneVersionElementsOf, scopeOfPath, seedFehlerText, selectImageJobs, selectPromptRuns, selectableTargetModels, siblingsOf, sortScenePolicies, sourceOf, stageFrame, stageNode, supportsCompositionReference, szenenSnapshotFilename, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };