@rslsp1/fa-app-tools 10.1.3 → 10.3.3

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, Q as ElementStoreState, 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, 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, O as ElementSnapshot, 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, 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,6 +104,444 @@ declare const SZENEN_SCHEMAS: Readonly<Record<string, RawSchema>>;
 /** Dateiname des Umschlagschemas — Einstieg jeder Validierung. */
 declare const ELEMENT_VERSION_SCHEMA_FILE = "element-version.schema.json";
 
+declare const STAGE_MIGRATION_ID = "stage_floor_center_v1";
+declare const STAGE_MIGRATION_EVENT = "szenen.stage_convention_migrated";
+type Payload$1 = Record<string, any>;
+interface StageMigrationEntry {
+    element_id: string;
+    version_id?: string;
+    draft_id?: string;
+    revision?: number;
+    before: Payload$1;
+    after: Payload$1;
+}
+interface StageMigration {
+    migration_id: typeof STAGE_MIGRATION_ID;
+    entries: StageMigrationEntry[];
+    report: {
+        remaining_boxes: string[];
+        changed_camera_views: string[];
+        placements: number;
+    };
+}
+/** One atomic log event, retaining identities and references under the issue's MVP migration exception. */
+declare function prepareStageMigration(state: ElementStoreState): StageMigration;
+
+/** 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 eingefrorener Kettenknoten — die Provenienz des Laufs (D-98). */
+interface FrozenChainNode {
+    type: DerivableType;
+    element_id: string;
+    draft_id: string;
+    revision: number;
+}
+interface FreezeSuccess {
+    kind: 'ok';
+    chainId: string;
+    nodes: readonly FrozenChainNode[];
+    input: RendererInput;
+    /**
+     * Der Rekonstruktionslauf, aus dem die Kette entstand (D-123, A2).
+     *
+     * Alle Knoten einer Kette teilen dieselben Kettenmetadaten (D-96) — die
+     * Übernahme entsteht aus **einer** Operation aus **einem** Ursprung —, daher
+     * genügt der Wert eines beliebigen erfassten Knotens, hier der des Shots.
+     */
+    sourceRunId?: string;
+    /** Gesetzt, wenn der Inhalt der Kette aus einer Recovery-Arbeitsfassung kam. */
+    sourceRecoveryId?: string;
+}
+/**
+ * Warum eine Kette nicht eingefroren werden konnte.
+ *
+ * `conflict` ist bewusst von `rejected` getrennt: Das eine ist ein Wettlauf und
+ * beim nächsten Versuch weg, das andere ein Mangel der Kette, den jemand
+ * beheben muss. Sie gleich zu behandeln hieße, dem Nutzer „nochmal versuchen"
+ * für einen unvollständigen Shot anzubieten.
+ *
+ * `error` kam mit Stufe 6.7.1 (D-125) dazu: **technisch**, nicht fachlich —
+ * Netz, Drosselung, Speicher nicht erreichbar. Vor 6.7.1 landete ein solcher
+ * Lesefehler beim Einfrieren als `rejected`, und ein HF-429 sah dadurch wie
+ * ein Mangel der Kette aus (der reale 429-Durchstich vom 2026-08-13). HF671-10
+ * verlangt, dass er stattdessen hier ankommt.
+ */
+type FreezeFailure = {
+    kind: 'conflict';
+    message: string;
+    /** Der Knoten, der sich zwischen den beiden Lesedurchgängen änderte. */
+    node: {
+        type: DerivableType;
+        element_id: string;
+        draft_id: string;
+    };
+    expectedRevision: number;
+    actualRevision: number;
+} | {
+    kind: 'rejected';
+    message: string;
+    failure?: ResolveFailure;
+} | {
+    kind: 'error';
+    message: string;
+    retryable: boolean;
+};
+type FreezeResult = FreezeSuccess | FreezeFailure;
+/** Ein einzelnes Element aus einer Momentaufnahme — kein Netzzugriff mehr. */
+interface ChainSnapshot {
+    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?
  *
@@ -391,125 +829,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 +842,26 @@ 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[];
+        variant?: string;
+        pose_ref?: string | null;
+        origin?: 'floor_center';
+        morph?: {
+            build?: number;
+            gender?: number;
+        };
+        preview_color?: string | null;
+    } | null;
+    anchors?: Readonly<Record<string, readonly number[]>>;
     type: string;
     /** Additiv nach `rank`, nie vorgemischt (D-50). */
     contributions: readonly NodeContribution[];
@@ -532,6 +871,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 +891,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 +917,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 +955,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 +989,7 @@ interface RendererInput {
         text: string;
         locale: string | null;
     }[];
+    prompt_tags?: readonly PromptConstructionTag[];
     fragments: readonly {
         channel: string;
         rank: number;
@@ -706,6 +1065,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 +1258,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 +1385,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 +1453,7 @@ type PromptRunSource = {
     };
 };
 interface PromptRunRecord {
+    camera_preview?: CameraPreviewDescriptor;
     run_id: string;
     /**
      * Herkunft: die veröffentlichte Shot-Version, aus der der Lauf entstand.
@@ -1200,6 +1601,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 +1688,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 +1703,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 +1716,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. */
@@ -1366,6 +1780,8 @@ interface PromptRunPage extends Omit<PromptRunListing, 'runs'>, Page<PromptRunPa
     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;
     /**
@@ -1594,249 +2010,6 @@ declare function findProviderCheck(events: readonly ElementEvent[], checkId: str
  */
 declare function totalModelCalls(checks: readonly ProviderCheckRecord[]): number;
 
-/** Ein eingefrorener Kettenknoten — die Provenienz des Laufs (D-98). */
-interface FrozenChainNode {
-    type: DerivableType;
-    element_id: string;
-    draft_id: string;
-    revision: number;
-}
-interface FreezeSuccess {
-    kind: 'ok';
-    chainId: string;
-    nodes: readonly FrozenChainNode[];
-    input: RendererInput;
-    /**
-     * Der Rekonstruktionslauf, aus dem die Kette entstand (D-123, A2).
-     *
-     * Alle Knoten einer Kette teilen dieselben Kettenmetadaten (D-96) — die
-     * Übernahme entsteht aus **einer** Operation aus **einem** Ursprung —, daher
-     * genügt der Wert eines beliebigen erfassten Knotens, hier der des Shots.
-     */
-    sourceRunId: string;
-    /** Gesetzt, wenn der Inhalt der Kette aus einer Recovery-Arbeitsfassung kam. */
-    sourceRecoveryId?: string;
-}
-/**
- * Warum eine Kette nicht eingefroren werden konnte.
- *
- * `conflict` ist bewusst von `rejected` getrennt: Das eine ist ein Wettlauf und
- * beim nächsten Versuch weg, das andere ein Mangel der Kette, den jemand
- * beheben muss. Sie gleich zu behandeln hieße, dem Nutzer „nochmal versuchen"
- * für einen unvollständigen Shot anzubieten.
- *
- * `error` kam mit Stufe 6.7.1 (D-125) dazu: **technisch**, nicht fachlich —
- * Netz, Drosselung, Speicher nicht erreichbar. Vor 6.7.1 landete ein solcher
- * Lesefehler beim Einfrieren als `rejected`, und ein HF-429 sah dadurch wie
- * ein Mangel der Kette aus (der reale 429-Durchstich vom 2026-08-13). HF671-10
- * verlangt, dass er stattdessen hier ankommt.
- */
-type FreezeFailure = {
-    kind: 'conflict';
-    message: string;
-    /** Der Knoten, der sich zwischen den beiden Lesedurchgängen änderte. */
-    node: {
-        type: DerivableType;
-        element_id: string;
-        draft_id: string;
-    };
-    expectedRevision: number;
-    actualRevision: number;
-} | {
-    kind: 'rejected';
-    message: string;
-    failure?: ResolveFailure;
-} | {
-    kind: 'error';
-    message: string;
-    retryable: boolean;
-};
-type FreezeResult = FreezeSuccess | FreezeFailure;
-/** Ein einzelnes Element aus einer Momentaufnahme — kein Netzzugriff mehr. */
-interface ChainSnapshot {
-    getElement(elementId: string): {
-        kind: string;
-        message?: string;
-        value?: {
-            element: {
-                element_id: string;
-                type: string;
-                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;
-    }): Promise<ChainSnapshot>;
-}
-interface FreezeDraftChainInput {
-    /** Das Shot-**Element** der Kette. Eine Version gibt es hier gerade nicht. */
-    shotElementId: string;
-    store: ChainQueries;
-    resolver: ReferenceResolver;
-    contextChain: readonly (string | null)[];
-    userInstruction?: string | null;
-}
-/**
- * Friert die vom Shot erreichbare Draft-Kette ein und baut die Renderer-Eingabe.
- *
- * Bei **jedem** Fehlausgang gilt: null Provideraufrufe. Diese Funktion ruft
- * ohnehin kein Modell — sie liefert nur die Eingabe, und der Aufrufer entscheidet
- * danach, ob er sie benutzt.
- */
-declare function freezeDraftChain(input: FreezeDraftChainInput): Promise<FreezeResult>;
-/**
- * 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>;
-
 /**
  * Wie brauchbar das Material einer Arbeitsfassung ist.
  *
@@ -2119,6 +2292,7 @@ interface ImageGenerationStartedPayload {
     request: {
         image_count: number;
         aspect_ratio?: string;
+        reference_asset_ids?: readonly string[];
         seeds?: readonly number[];
         callable_model_id: string;
         /**
@@ -2235,6 +2409,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 +2609,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 +2702,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 +2713,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 +2818,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 +2935,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;
@@ -3287,6 +3475,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.
      *
@@ -3496,8 +3691,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;
@@ -3860,6 +4057,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.
@@ -3871,6 +4079,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;
@@ -4233,7 +4443,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>;
     /**
@@ -4384,7 +4594,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.
@@ -4426,40 +4636,572 @@ interface ManualPromptEntry {
     /** Wer eingetragen hat. */
     entered_by: string;
 }
-/** Ein Lauf, der von Hand eingetragen wurde. */
-type ManualPromptRunRecord = PromptRunRecord & {
-    manual_entry: ManualPromptEntry;
+/** Ein Lauf, der von Hand eingetragen wurde. */
+type ManualPromptRunRecord = PromptRunRecord & {
+    manual_entry: ManualPromptEntry;
+};
+interface BuildManualPromptRunInput {
+    runId: string;
+    /** Der eingefrorene Szenenstand — woertlich der von `freezeSceneWorkingState()`. */
+    scene: FrozenSceneState;
+    /** Die eingefrorene Renderer-Eingabe desselben Einfrierens (D-22). */
+    input: RendererInput;
+    /** Der Prompttext, **unveraendert** wie eingegeben. */
+    promptText: string;
+    note?: string | null;
+    derivedFromRunId?: string | null;
+    enteredBy: string;
+    now?: () => Date;
+}
+type BuildManualPromptRunResult = {
+    kind: 'ok';
+    record: ManualPromptRunRecord;
+} | {
+    kind: 'rejected';
+    message: string;
+};
+/**
+ * Baut den Lauf. Prueft nur, was ohne Bestandszugriff pruefbar ist.
+ *
+ * Ein leerer Prompttext ist eine Ablehnung und kein Lauf: Er waere ein
+ * erfolgreicher Lauf ohne Ergebnis und wuerde in jeder Leseansicht als
+ * vollwertige Runde erscheinen.
+ */
+declare function buildManualPromptRunRecord(eingabe: BuildManualPromptRunInput): BuildManualPromptRunResult;
+/** Der Handeingabe-Block eines Laufs, oder `null` bei jedem anderen Lauf. */
+declare function manualEntryOf(run: PromptRunPageRecord): ManualPromptEntry | null;
+
+type StagePlane = 'top' | 'side' | 'camera' | 'free';
+type Vec3$1 = [number, number, number];
+declare const STAGE_CATALOGUE: readonly [{
+    readonly label: "Mensch";
+    readonly type: "subject";
+    readonly dimensions: readonly [0.55, 0.35, 1.75];
+    readonly primitive: "humanoid_proxy";
+    readonly pose_ref: "standing";
+}, {
+    readonly label: "Stuhl";
+    readonly type: "object";
+    readonly dimensions: readonly [0.5, 0.5, 0.9];
+    readonly primitive: "furniture_proxy";
+    readonly variant: "chair";
+}, {
+    readonly label: "Tisch";
+    readonly type: "surface";
+    readonly dimensions: readonly [1.2, 0.7, 0.75];
+    readonly primitive: "furniture_proxy";
+    readonly variant: "table";
+}, {
+    readonly label: "Lampe";
+    readonly type: "light";
+    readonly dimensions: readonly [0.35, 0.35, 1.5];
+    readonly primitive: "furniture_proxy";
+    readonly variant: "floor_lamp";
+}, {
+    readonly label: "Raum";
+    readonly type: "object";
+    readonly dimensions: readonly [5, 4, 2.8];
+    readonly primitive: "room_shell";
+}];
+/**
+ * Unterhalb dieses Abstands gelten zwei Markerfarben als schwer unterscheidbar
+ * („redmean“-Abstand im RGB-Raum, 0…~765). Runde 6 zeigte #df995f gegen
+ * #e89254 (Abstand ≈ 26) — das konnte das Bildmodell nicht trennen.
+ */
+declare const PREVIEW_COLOR_MIN_DISTANCE = 75;
+/** `#RRGGBB` in beliebiger Schreibweise → `#rrggbb`, sonst `null`. */
+declare function normalizePreviewColor(value: unknown): string | null;
+/** Wahrnehmungsnaher Abstand zweier Farben („redmean“). */
+declare function previewColorDistance(a: string, b: string): number;
+type ColorNode = Pick<ResolvedNode, 'node_id' | 'type'> & {
+    proxy_3d?: {
+        preview_color?: string | null;
+    } | null;
+};
+/**
+ * Die wirksame Markerfarbe je Node.
+ *
+ * Eine gespeicherte `proxy_3d.preview_color` gilt immer — auch wenn sie einer
+ * anderen ähnelt; das meldet `previewColorConflicts`. Nodes ohne gespeicherte
+ * Farbe bekommen, in `node_id`-Reihenfolge, die Typfarbe oder die nächste
+ * Ersatzfarbe, die von allen bereits vergebenen deutlich abweicht. Damit
+ * Ersatzfarben stabil bleiben, schreiben Editor und MCP sie bei jeder
+ * Bühnenänderung fest (`pinPreviewColors`).
+ */
+declare function stageColors(nodes: readonly ColorNode[]): Record<string, {
+    hex: string;
+    name: string;
+    explicit: boolean;
+}>;
+/**
+ * Hinweis für Markerfarben, die im Kamera-Preview schlecht als Marker taugen:
+ * sehr dunkel (liest sich als Schatten oder dunkle Kleidung) oder sehr hell
+ * (verschwindet im hellen Preview-Hintergrund). Keine Sperre — nur ein Hinweis.
+ */
+declare function previewColorLegibility(hex: string): 'too_dark' | 'too_light' | null;
+type PreviewColorConflict = {
+    node_ids: [string, string];
+    hexes: [string, string];
+    distance: number;
+    identical: boolean;
+};
+/** Paare wirksamer Markerfarben, die gleich oder schwer unterscheidbar sind. */
+declare function previewColorConflicts(nodes: readonly ColorNode[]): PreviewColorConflict[];
+/** Nur die zwei sichtbaren Achsen ändern; die verborgene Tiefe bleibt erhalten. */
+declare function dragPosition(position: readonly number[], point: readonly number[], plane: StagePlane): Vec3$1;
+declare function stageNode(node: ResolvedNode): {
+    node_id: string;
+    type: string;
+    primitive: string;
+    dimensions: Vec3$1;
+    variant: string | undefined;
+    pose_ref: string | null | undefined;
+    morph: {
+        build?: number;
+        gender?: number;
+    } | undefined;
+    position: Vec3$1;
+    rotation: Vec3$1;
+    scale: Vec3$1;
+    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$1;
+        variant: string | undefined;
+        pose_ref: string | null | undefined;
+        morph: {
+            build?: number;
+            gender?: number;
+        } | undefined;
+        position: Vec3$1;
+        rotation: Vec3$1;
+        scale: Vec3$1;
+        anchors: Readonly<Record<string, readonly number[]>> | undefined;
+    }[];
+    camera: {
+        position: Vec3$1;
+        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;
+    };
+};
+
+type Payload = Record<string, any>;
+type Vec3 = [number, number, number];
+declare const NODE_TYPES: readonly ["subject", "object", "surface", "light", "camera_target", "group", "other"];
+declare const PROXY_PRIMITIVES: readonly ["humanoid_proxy", "box", "cylinder", "sphere", "plane", "room_shell", "furniture_proxy"];
+type StageOperation = {
+    op: 'add_node';
+    node_id?: string;
+    label?: string;
+    type: string;
+    description: string;
+    properties?: Record<string, unknown>;
+    primitive?: string;
+    dimensions?: Vec3;
+    variant?: string;
+    pose_ref?: string;
+    morph?: {
+        build?: number;
+        gender?: number;
+    };
+    preview_color?: string;
+    position?: Vec3;
+    rotation_euler_deg?: Vec3;
+    scale?: Vec3;
+} | {
+    op: 'update_node';
+    node_id: string;
+    label?: string | null;
+    type?: string;
+    description?: string;
+    properties?: Record<string, unknown>;
+    primitive?: string;
+    dimensions?: Vec3;
+    variant?: string;
+    pose_ref?: string;
+    morph?: {
+        build?: number;
+        gender?: number;
+    };
+    /** `null` setzt auf die automatisch vergebene Standardfarbe zurück. */
+    preview_color?: string | null;
+} | {
+    op: 'place_node';
+    node_id: string;
+    position?: Vec3;
+    rotation_euler_deg?: Vec3;
+    scale?: Vec3;
+} | {
+    op: 'remove_node';
+    node_id: string;
+} | {
+    op: 'add_camera';
+    camera: Payload;
+} | {
+    op: 'update_camera';
+    camera_id: string;
+    changes: Payload;
+} | {
+    op: 'set_shot_camera';
+    camera_id: string;
+};
+interface StagePayloads {
+    scene: Payload;
+    setup: Payload;
+    shot: Payload | null;
+}
+type StageOperationsResult = {
+    kind: 'ok';
+    payloads: StagePayloads;
+    changed: {
+        scene: boolean;
+        setup: boolean;
+        shot: boolean;
+    };
+    created_node_ids: string[];
+    /** Gesetzte Reihenfolge der Writes, so dass kein Zwischenstand verwaist. */
+    write_order: ('scene' | 'setup' | 'shot')[];
+    color_conflicts: PreviewColorConflict[];
+} | {
+    kind: 'rejected';
+    message: string;
+    operation_index: number | null;
+};
+/**
+ * Die Nodes, wie der Editor sie färbt: alle nicht ausgeblendeten, mit der
+ * wirksamen Proxy-Geometrie (eine `proxy_3d`-Überschreibung im Aufbau gilt vor
+ * der Szene — dieselbe Regel wie in `resolve`).
+ */
+declare function previewColorNodes(scene: Payload, setup: Payload | null, shot: Payload | null): {
+    node_id: string;
+    type: string;
+    proxy_3d: any;
+}[];
+/**
+ * Schreibt die wirksamen Markerfarben aller Proxy-Nodes der Szene fest.
+ *
+ * Ersatzfarben hängen von den anderen Nodes ab; ohne Festschreiben könnte das
+ * Hinzufügen oder Entfernen eines Nodes die Farbe eines anderen verschieben.
+ * Sichtbare Nodes behalten genau ihre angezeigte Farbe, ausgeblendete bekommen
+ * eine davon deutlich verschiedene. Nodes, deren Geometrie im Aufbau
+ * überschrieben ist, bleiben unberührt — ihre Farbe wirkt dort.
+ */
+declare function pinPreviewColors(scene: Payload, setup: Payload | null, shot: Payload | null): Payload;
+/**
+ * Rechnet die Operationen auf die drei Payloads um. Schreibt nichts.
+ *
+ * Abgelehnt wird jede Operation, die einen inkonsistenten Endstand ergäbe:
+ * unbekannte oder doppelte Node-IDs, Placements ohne Node, Kameras ohne
+ * Eintrag im Rig, ein entfernter Node, auf den noch eine Kamera oder der Shot
+ * zeigt. Hinzufügen und Entfernen in einem Aufruf wird abgelehnt: Für diese
+ * Kombination gibt es keine Schreibreihenfolge ohne verwaisten Zwischenstand.
+ */
+declare function applyStageOperations(input: StagePayloads, operations: readonly StageOperation[]): StageOperationsResult;
+
+type StageElementsPort = Pick<SzenenQueries, 'getElement' | 'listElements'> & Pick<SzenenCommands, 'createElement' | 'writeDraft'>;
+interface StageChainState {
+    chain_id: string;
+    scene: ElementSnapshot;
+    setup: ElementSnapshot;
+    shot: ElementSnapshot;
+}
+/**
+ * Die bestehende Bühnenkette einer Szene, oder `null`, wenn die Szene keinen
+ * Kettenentwurf hat. Eine unvollständige oder mehrdeutige Kette ist ein Fehler
+ * und wird nicht geraten.
+ */
+declare function findStageDraftChain(elements: StageElementsPort, sceneElementId: string): Promise<StageChainState | null>;
+interface OpenStageDraftChainInput {
+    sceneElementId: string;
+    setupElementId: string;
+    /** Die veröffentlichte Aufbauversion, von der aus begonnen wird; `null` = sein Entwurf. */
+    setupVersionId: string | null;
+    contextId: string | null;
+    /** Zielmodell für einen neu angelegten Shot, sonst weggelassen. */
+    targetModelId?: string | null;
+    newChainId?: () => string;
+}
+/**
+ * Legt die Bühnenkette an oder setzt eine bestehende fort — genau der Ablauf,
+ * mit dem der Editor eine Ansicht in einen 3D-Entwurf überführt.
+ *
+ * Kein erfundener Shot und keine erfundene Version: Ein Shot dieser Kette wird
+ * wiederverwendet, sonst wird genau einer angelegt.
+ */
+declare function openStageDraftChain(elements: StageElementsPort, input: OpenStageDraftChainInput): Promise<StageChainState>;
+
+/**
+ * Der Anbieter, der in einem so entstandenen Lauf steht.
+ *
+ * `mcp_client` und nicht `openai`/`chatgpt`: Was der Server sicher weiss, ist
+ * dass **sein MCP-Aufrufer** formuliert hat. Welcher Anbieter dahinter steht,
+ * sagt ihm niemand — und ein geratener Anbietername waere im Lauf spaeter
+ * nicht mehr von einem belegten zu unterscheiden (D-107).
+ */
+declare const MCP_CLIENT_PROVIDER = "mcp_client";
+/**
+ * Die Modellkennung, wenn der Host keine belegte liefert — und das tut er nie.
+ *
+ * Bewusst ein sprechender Platzhalter statt einer Modellversion: `model_id`
+ * ist das Feld, an dem ein Leser ablesen soll, **womit** formuliert wurde.
+ * Eine dort eingetragene Selbstauskunft saehe aus wie eine belegte Kennung.
+ * Die Selbstauskunft steht deshalb in `execution_origin.declared_model_id` und
+ * traegt dort sichtbar, dass sie unbelegt ist.
+ */
+declare const UNVERIFIED_MODEL_ID = "mcp-client-unspecified";
+/**
+ * Die Herkunft der Ausfuehrung, so ehrlich wie sie belegbar ist.
+ *
+ * Additiv am Lauf und nicht in `model_id`/`provider` versteckt: Der
+ * Unterschied zwischen „das war Modell X" und „der Aufrufer sagt, es war
+ * Modell X" ist genau der, um den es geht.
+ */
+interface PromptExecutionOrigin {
+    /** Wer den Lauf eingereicht hat — hier immer der MCP-Werkzeugweg. */
+    host: 'mcp';
+    /** Was der Aufrufer ueber sich selbst gesagt hat, unveraendert und unbelegt. */
+    declared_model_id?: string;
+    /**
+     * Ob die unten mitgegebene Renderer-Anweisung die tatsaechliche
+     * Systemnachricht des formulierenden Chats war.
+     *
+     * Sie war es nie: Der MCP reicht sie als Werkzeugergebnis heraus; was im
+     * Chat als Systemprompt stand, kennt der Server nicht. Das Feld steht
+     * trotzdem im Lauf, weil `system_prompt` sonst genau so gelesen wuerde.
+     */
+    renderer_instruction_was_system_prompt: false;
+}
+/** Der Antwortvertrag, den der Aufrufer erfuellen muss — maschinenlesbar. */
+interface PromptResponseContract {
+    format: 'json';
+    /** Pflichtfelder der Antwort, wie `checkRunResponse()` sie prueft. */
+    required_fields: readonly string[];
+    /** Ob ein Negativ-Prompt zugesagt ist (sonst muss `negative` null bleiben). */
+    negative_prompt_allowed: boolean;
+    /** Jeder dieser Knoten muss in `visibility.nodes` erscheinen (D-21). */
+    node_ids: readonly string[];
+    /** Die Sprache, in der `positive` formuliert wird. */
+    prompt_language: string;
+}
+/** Ein vorbereiteter Promptvorgang — dauerhaft unter `operation_id`. */
+interface PreparedPromptOperation {
+    operation_id: string;
+    /** Die eingefrorene Szene: genau ein Entwurfs- oder Versionsstand (D-135). */
+    scene: FrozenSceneState;
+    context_id: string | null;
+    /** Die Arbeitsanweisung des Nutzers, soweit eine gegeben wurde. */
+    user_instruction: string | null;
+    /** Der eingefrorene `RendererInput` — woertlich der des bestehenden Pfads. */
+    renderer_input: RendererInput;
+    /**
+     * Die Renderer-Anweisung (`buildSystemInstruction`).
+     *
+     * Sie ist **Material fuer den Aufrufer**, nicht sein Systemprompt. Beim
+     * Abschluss landet sie unveraendert in `system_prompt` des Laufs, weil das
+     * Feld seit Stufe 3 genau diese Anweisung fuehrt.
+     */
+    renderer_instruction: string;
+    /** Die Nutzernachricht: die Renderer-Eingabe als JSON (D-47). */
+    renderer_payload: string;
+    response_contract: PromptResponseContract;
+    prepared_by: string;
+    created_at: string;
+}
+/** Nutzlast von `promptOperationPrepared`. */
+type PromptOperationPreparedPayload = PreparedPromptOperation;
+/** Liest alle vorbereiteten Vorgaenge aus dem Ereignislog. */
+declare function collectPromptOperations(events: readonly ElementEvent[]): readonly PreparedPromptOperation[];
+/** Ein einzelner vorbereiteter Vorgang, oder `null`. */
+declare function findPromptOperation(events: readonly ElementEvent[], operationId: string): PreparedPromptOperation | null;
+interface PreparePromptOperationInput {
+    sceneElementId: string;
+    operationId: string;
+    store: ChainQueries;
+    resolver: ReferenceResolver;
+    contextChain: readonly (string | null)[];
+    contextId: string | null;
+    userInstruction?: string | null;
+    /**
+     * Das gewaehlte Zielmodell (Kette `szenen-direktlauf-target-model-policy`).
+     *
+     * Optional. Ohne Angabe bleibt der Vorgang exakt der generische von D-135;
+     * mit Angabe traegt der eingefrorene `RendererInput` die Modellprovenienz,
+     * und `completePromptOperation()` schreibt ihre `version_id` ohne Zutun in
+     * `target_model_version_id` des Laufs.
+     */
+    targetModelElementId?: string | null;
+    preparedBy: string;
+    now?: () => Date;
+}
+type PreparePromptOperationResult = {
+    kind: 'ok';
+    operation: PreparedPromptOperation;
+} | FreezeFailure;
+/**
+ * Friert den Arbeitsstand einer Szene ein und baut daraus den Vorgang.
+ *
+ * Ruft **kein** Modell — hier entstehen keine Kosten. Das Einfrieren ist
+ * woertlich `freezeSceneWorkingState()`, also derselbe Zwei-Durchgang-Vergleich
+ * mit denselben drei Ausgaengen wie im bestehenden Pfad (D-97/D-135). Ein
+ * Konflikt bleibt ein Konflikt, kein „nochmal versuchen".
+ */
+declare function preparePromptOperation(input: PreparePromptOperationInput): Promise<PreparePromptOperationResult>;
+/**
+ * Der Antwortvertrag, abgelesen an derselben Eingabe wie die Anweisung.
+ *
+ * Bewusst abgelesen und nicht danebengeschrieben: Was `checkRunResponse()
+ * prueft, entscheidet allein `promptRun.ts`. Ein hier gepflegter zweiter
+ * Katalog liefe irgendwann auseinander, und der Aufrufer bekaeme einen
+ * Vertrag, den die Pruefung nicht kennt.
+ */
+declare function responseContractOf(input: RendererInput): PromptResponseContract;
+interface CompletePromptOperationInput {
+    operation: PreparedPromptOperation;
+    /** Die Antwort des aufrufenden Modells, woertlich. */
+    response: string;
+    runId: string;
+    /** Was der Aufrufer ueber sein eigenes Modell sagt — unbelegt (D-107). */
+    declaredModelId?: string | null;
+    now?: () => Date;
+}
+type CompletePromptOperationResult = {
+    kind: 'ok';
+    record: PromptRunRecord;
+} | {
+    kind: 'rejected';
+    message: string;
+};
+/**
+ * Macht aus der Antwort des Aufrufers einen normalen Promptlauf.
+ *
+ * **Eine ungueltige Antwort wird nicht als gescheiterter Lauf abgelegt.** Das
+ * ist der eine bewusste Unterschied zum Providerpfad, und er hat einen Grund:
+ * Dort belegt ein `failed` einen **bezahlten** Aufruf, der sich nicht
+ * wiederholen laesst, ohne noch einmal zu kosten (D-23 §6). Hier hat niemand
+ * bezahlt — der Aufrufer hat nur falsch formuliert und kann es unter derselben
+ * `operation_id` sofort richtig tun. Ein Fehlerlauf waere hier kein Nachweis,
+ * sondern Muell im autoritativen Bestand, und er wuerde die Wiederholung
+ * ausserdem als Konflikt blockieren.
+ */
+declare function completePromptOperation(input: CompletePromptOperationInput): CompletePromptOperationResult;
+/**
+ * Der Lauf, der aus diesem Vorgang schon entstanden ist — oder `null`.
+ *
+ * Grundlage der Idempotenz: Derselbe Vorgang mit derselben Antwort liefert
+ * denselben Lauf; eine **andere** Antwort unter derselben Kennung ist ein
+ * Konflikt und kein zweiter Lauf. Verglichen wird die woertliche Antwort aus
+ * `raw_output` — es braucht keinen Fingerabdruck neben etwas, das der Lauf
+ * ohnehin vollstaendig traegt.
+ */
+declare function runOfOperation(runs: readonly PromptRunRecord[], operationId: string): PromptRunRecord | null;
+/** Ob eine eingereichte Antwort woertlich die des bereits gespeicherten Laufs ist. */
+declare function sameResponseAs(run: PromptRunRecord, response: string): boolean;
+
+/** Die Rolle des Kamera-Previews unter den Eingangsbildern. */
+declare const CAMERA_PREVIEW_ASSET_ROLE = "camera_preview";
+/** Ein Eingangsbild, so wie der Quelllauf es tatsaechlich benutzt hat. */
+interface PromptRunInputAsset {
+    /** Kanonische Asset-Kennung — nie ein Dateiname oder Blob. */
+    asset_id: string;
+    role: typeof CAMERA_PREVIEW_ASSET_ROLE;
+    /** Platz in der geordneten Eingangsliste, ab 0, luckenlos. */
+    position: number;
+    /** Die Schreibweise im Prompt, wie sie das eingefrorene Zielmodell festlegt. */
+    prompt_token: string | null;
+    /** Pruefsumme der Bytes — muss zum eingefrorenen Preview passen. */
+    sha256: string;
+    /** Wo das Asset liegt: Lauf und Run-Item, an dem es gespeichert ist. */
+    origin: {
+        run_id: string;
+        item_id: string;
+    };
+}
+/** Die Herkunft eines Variantenlaufs. */
+interface PromptRunVariantOf {
+    source_run_id: string;
+    operation_id: string;
+    input_assets: readonly PromptRunInputAsset[];
+}
+type PromptRunVariantRecord = PromptRunRecord & {
+    operation_id: string;
+    execution_origin: PromptExecutionOrigin;
+    variant_of: PromptRunVariantOf;
 };
-interface BuildManualPromptRunInput {
+interface BuildPromptRunVariantInput {
     runId: string;
-    /** Der eingefrorene Szenenstand — woertlich der von `freezeSceneWorkingState()`. */
-    scene: FrozenSceneState;
-    /** Die eingefrorene Renderer-Eingabe desselben Einfrierens (D-22). */
-    input: RendererInput;
-    /** Der Prompttext, **unveraendert** wie eingegeben. */
-    promptText: string;
+    operationId: string;
+    /** Der gespeicherte Quelllauf, unveraendert aus dem autoritativen Log. */
+    source: PromptRunRecord;
+    positive: string;
+    negative?: string | null;
     note?: string | null;
-    derivedFromRunId?: string | null;
-    enteredBy: string;
+    declaredModelId?: string | null;
+    inputAssets: readonly PromptRunInputAsset[];
     now?: () => Date;
 }
-type BuildManualPromptRunResult = {
+type BuildPromptRunVariantResult = {
     kind: 'ok';
-    record: ManualPromptRunRecord;
+    record: PromptRunVariantRecord;
 } | {
     kind: 'rejected';
     message: string;
 };
+type Verdict = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
 /**
- * Baut den Lauf. Prueft nur, was ohne Bestandszugriff pruefbar ist.
+ * Prueft die geordneten Eingangsbilder gegen den eingefrorenen Lauf.
  *
- * Ein leerer Prompttext ist eine Ablehnung und kein Lauf: Er waere ein
- * erfolgreicher Lauf ohne Ergebnis und wuerde in jeder Leseansicht als
- * vollwertige Runde erscheinen.
+ * Ein Lauf mit Kamera-Preview braucht genau dieses Preview als Eingang — ein
+ * fehlendes waere ein stilles Weglassen, ein abweichendes ein Ersatzbild.
  */
-declare function buildManualPromptRunRecord(eingabe: BuildManualPromptRunInput): BuildManualPromptRunResult;
-/** Der Handeingabe-Block eines Laufs, oder `null` bei jedem anderen Lauf. */
-declare function manualEntryOf(run: PromptRunPageRecord): ManualPromptEntry | null;
+declare function checkVariantInputAssets(assets: unknown, cameraPreview: PromptRunRecord['camera_preview'] | undefined): Verdict;
+/**
+ * Prueft den Variantenblock eines Laufs. Additiv und optional: Ein Lauf ohne
+ * `variant_of` bleibt unveraendert gueltig.
+ */
+declare function checkVariantBlock(record: Record<string, unknown>): Verdict;
+/**
+ * Baut den Variantenlauf. Prueft, was ohne Bestandszugriff pruefbar ist; die
+ * Rechte und die Erreichbarkeit der Assets prueft der Host vorher.
+ */
+declare function buildPromptRunVariantRecord(eingabe: BuildPromptRunVariantInput): BuildPromptRunVariantResult;
+/** Der Variantenblock eines Laufs, oder `null` bei jedem anderen Lauf. */
+declare function variantOf(run: PromptRunPageRecord | PromptRunRecord): PromptRunVariantOf | null;
+/**
+ * Ist dieser gespeicherte Lauf genau die angefragte Variante? Grundlage der
+ * Idempotenz: dieselbe operation_id mit derselben Anfrage liefert denselben
+ * Lauf, eine abweichende ist ein Konflikt.
+ */
+declare function sameVariantRequest(run: PromptRunRecord, anfrage: {
+    sourceRunId: string;
+    positive: string;
+    negative?: string | null;
+    note?: string | null;
+}): boolean;
 
 interface CreateMemoryViewPortOptions {
     /**
@@ -4497,6 +5239,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).
      *
@@ -4611,7 +5361,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.
@@ -4635,6 +5385,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;
@@ -4731,6 +5483,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. */
@@ -5020,6 +5777,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;
 }
@@ -5069,173 +5827,6 @@ interface TargetModelChoices {
  */
 declare function selectableTargetModels(queries: VisibilityQueries, contextChain: readonly (string | null)[]): Promise<QueryResult<TargetModelChoices>>;
 
-/**
- * Der Anbieter, der in einem so entstandenen Lauf steht.
- *
- * `mcp_client` und nicht `openai`/`chatgpt`: Was der Server sicher weiss, ist
- * dass **sein MCP-Aufrufer** formuliert hat. Welcher Anbieter dahinter steht,
- * sagt ihm niemand — und ein geratener Anbietername waere im Lauf spaeter
- * nicht mehr von einem belegten zu unterscheiden (D-107).
- */
-declare const MCP_CLIENT_PROVIDER = "mcp_client";
-/**
- * Die Modellkennung, wenn der Host keine belegte liefert — und das tut er nie.
- *
- * Bewusst ein sprechender Platzhalter statt einer Modellversion: `model_id`
- * ist das Feld, an dem ein Leser ablesen soll, **womit** formuliert wurde.
- * Eine dort eingetragene Selbstauskunft saehe aus wie eine belegte Kennung.
- * Die Selbstauskunft steht deshalb in `execution_origin.declared_model_id` und
- * traegt dort sichtbar, dass sie unbelegt ist.
- */
-declare const UNVERIFIED_MODEL_ID = "mcp-client-unspecified";
-/**
- * Die Herkunft der Ausfuehrung, so ehrlich wie sie belegbar ist.
- *
- * Additiv am Lauf und nicht in `model_id`/`provider` versteckt: Der
- * Unterschied zwischen „das war Modell X" und „der Aufrufer sagt, es war
- * Modell X" ist genau der, um den es geht.
- */
-interface PromptExecutionOrigin {
-    /** Wer den Lauf eingereicht hat — hier immer der MCP-Werkzeugweg. */
-    host: 'mcp';
-    /** Was der Aufrufer ueber sich selbst gesagt hat, unveraendert und unbelegt. */
-    declared_model_id?: string;
-    /**
-     * Ob die unten mitgegebene Renderer-Anweisung die tatsaechliche
-     * Systemnachricht des formulierenden Chats war.
-     *
-     * Sie war es nie: Der MCP reicht sie als Werkzeugergebnis heraus; was im
-     * Chat als Systemprompt stand, kennt der Server nicht. Das Feld steht
-     * trotzdem im Lauf, weil `system_prompt` sonst genau so gelesen wuerde.
-     */
-    renderer_instruction_was_system_prompt: false;
-}
-/** Der Antwortvertrag, den der Aufrufer erfuellen muss — maschinenlesbar. */
-interface PromptResponseContract {
-    format: 'json';
-    /** Pflichtfelder der Antwort, wie `checkRunResponse()` sie prueft. */
-    required_fields: readonly string[];
-    /** Ob ein Negativ-Prompt zugesagt ist (sonst muss `negative` null bleiben). */
-    negative_prompt_allowed: boolean;
-    /** Jeder dieser Knoten muss in `visibility.nodes` erscheinen (D-21). */
-    node_ids: readonly string[];
-    /** Die Sprache, in der `positive` formuliert wird. */
-    prompt_language: string;
-}
-/** Ein vorbereiteter Promptvorgang — dauerhaft unter `operation_id`. */
-interface PreparedPromptOperation {
-    operation_id: string;
-    /** Die eingefrorene Szene: genau ein Entwurfs- oder Versionsstand (D-135). */
-    scene: FrozenSceneState;
-    context_id: string | null;
-    /** Die Arbeitsanweisung des Nutzers, soweit eine gegeben wurde. */
-    user_instruction: string | null;
-    /** Der eingefrorene `RendererInput` — woertlich der des bestehenden Pfads. */
-    renderer_input: RendererInput;
-    /**
-     * Die Renderer-Anweisung (`buildSystemInstruction`).
-     *
-     * Sie ist **Material fuer den Aufrufer**, nicht sein Systemprompt. Beim
-     * Abschluss landet sie unveraendert in `system_prompt` des Laufs, weil das
-     * Feld seit Stufe 3 genau diese Anweisung fuehrt.
-     */
-    renderer_instruction: string;
-    /** Die Nutzernachricht: die Renderer-Eingabe als JSON (D-47). */
-    renderer_payload: string;
-    response_contract: PromptResponseContract;
-    prepared_by: string;
-    created_at: string;
-}
-/** Nutzlast von `promptOperationPrepared`. */
-type PromptOperationPreparedPayload = PreparedPromptOperation;
-/** Liest alle vorbereiteten Vorgaenge aus dem Ereignislog. */
-declare function collectPromptOperations(events: readonly ElementEvent[]): readonly PreparedPromptOperation[];
-/** Ein einzelner vorbereiteter Vorgang, oder `null`. */
-declare function findPromptOperation(events: readonly ElementEvent[], operationId: string): PreparedPromptOperation | null;
-interface PreparePromptOperationInput {
-    sceneElementId: string;
-    operationId: string;
-    store: ChainQueries;
-    resolver: ReferenceResolver;
-    contextChain: readonly (string | null)[];
-    contextId: string | null;
-    userInstruction?: string | null;
-    /**
-     * Das gewaehlte Zielmodell (Kette `szenen-direktlauf-target-model-policy`).
-     *
-     * Optional. Ohne Angabe bleibt der Vorgang exakt der generische von D-135;
-     * mit Angabe traegt der eingefrorene `RendererInput` die Modellprovenienz,
-     * und `completePromptOperation()` schreibt ihre `version_id` ohne Zutun in
-     * `target_model_version_id` des Laufs.
-     */
-    targetModelElementId?: string | null;
-    preparedBy: string;
-    now?: () => Date;
-}
-type PreparePromptOperationResult = {
-    kind: 'ok';
-    operation: PreparedPromptOperation;
-} | FreezeFailure;
-/**
- * Friert den Arbeitsstand einer Szene ein und baut daraus den Vorgang.
- *
- * Ruft **kein** Modell — hier entstehen keine Kosten. Das Einfrieren ist
- * woertlich `freezeSceneWorkingState()`, also derselbe Zwei-Durchgang-Vergleich
- * mit denselben drei Ausgaengen wie im bestehenden Pfad (D-97/D-135). Ein
- * Konflikt bleibt ein Konflikt, kein „nochmal versuchen".
- */
-declare function preparePromptOperation(input: PreparePromptOperationInput): Promise<PreparePromptOperationResult>;
-/**
- * Der Antwortvertrag, abgelesen an derselben Eingabe wie die Anweisung.
- *
- * Bewusst abgelesen und nicht danebengeschrieben: Was `checkRunResponse()
- * prueft, entscheidet allein `promptRun.ts`. Ein hier gepflegter zweiter
- * Katalog liefe irgendwann auseinander, und der Aufrufer bekaeme einen
- * Vertrag, den die Pruefung nicht kennt.
- */
-declare function responseContractOf(input: RendererInput): PromptResponseContract;
-interface CompletePromptOperationInput {
-    operation: PreparedPromptOperation;
-    /** Die Antwort des aufrufenden Modells, woertlich. */
-    response: string;
-    runId: string;
-    /** Was der Aufrufer ueber sein eigenes Modell sagt — unbelegt (D-107). */
-    declaredModelId?: string | null;
-    now?: () => Date;
-}
-type CompletePromptOperationResult = {
-    kind: 'ok';
-    record: PromptRunRecord;
-} | {
-    kind: 'rejected';
-    message: string;
-};
-/**
- * Macht aus der Antwort des Aufrufers einen normalen Promptlauf.
- *
- * **Eine ungueltige Antwort wird nicht als gescheiterter Lauf abgelegt.** Das
- * ist der eine bewusste Unterschied zum Providerpfad, und er hat einen Grund:
- * Dort belegt ein `failed` einen **bezahlten** Aufruf, der sich nicht
- * wiederholen laesst, ohne noch einmal zu kosten (D-23 §6). Hier hat niemand
- * bezahlt — der Aufrufer hat nur falsch formuliert und kann es unter derselben
- * `operation_id` sofort richtig tun. Ein Fehlerlauf waere hier kein Nachweis,
- * sondern Muell im autoritativen Bestand, und er wuerde die Wiederholung
- * ausserdem als Konflikt blockieren.
- */
-declare function completePromptOperation(input: CompletePromptOperationInput): CompletePromptOperationResult;
-/**
- * Der Lauf, der aus diesem Vorgang schon entstanden ist — oder `null`.
- *
- * Grundlage der Idempotenz: Derselbe Vorgang mit derselben Antwort liefert
- * denselben Lauf; eine **andere** Antwort unter derselben Kennung ist ein
- * Konflikt und kein zweiter Lauf. Verglichen wird die woertliche Antwort aus
- * `raw_output` — es braucht keinen Fingerabdruck neben etwas, das der Lauf
- * ohnehin vollstaendig traegt.
- */
-declare function runOfOperation(runs: readonly PromptRunRecord[], operationId: string): PromptRunRecord | null;
-/** Ob eine eingereichte Antwort woertlich die des bereits gespeicherten Laufs ist. */
-declare function sameResponseAs(run: PromptRunRecord, response: string): boolean;
-
 /** Die waehlbaren Pausen zwischen zwei Auftraegen, in Sekunden (§4). */
 declare const PAUSE_SEKUNDEN_OPTIONEN: readonly number[];
 /** Die Vorgabe, wenn der Nutzer nichts waehlt (§4). */
@@ -5469,6 +6060,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. */
@@ -5488,6 +6164,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 = {
@@ -5509,4 +6194,4 @@ 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 };
+export { type AddManualSceneRunInput, type AttachLibraryItemInput, type AttachLibraryItemResult, type AuftragAktion, type AuftragZustand, AuthoritativeSzenenStore, type BestandsGalerieEintrag, type BestandsItem, type BuildManualPromptRunInput, type BuildPromptRunVariantInput, type BuildPromptRunVariantResult, CAMERA_ASPECT_RATIOS, CAMERA_PREVIEW_ASSET_ROLE, 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, ElementSnapshot, 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, NODE_TYPES, type NodeContribution, NotDerivable, type Notice, type NoticeTone, type OpenStageDraftChainInput, PAUSE_SEKUNDEN_OPTIONEN, PAUSE_SEKUNDEN_VORGABE, PREVIEW_COLOR_MIN_DISTANCE, PROMPT_AUSZUG_ZEICHEN, PROMPT_RULE_EFFECT, PROMPT_RUN_DETAIL_FIELDS, PROXY_PRIMITIVES, 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 PromptRunInputAsset, 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 PromptRunVariantOf, type PromptRunVariantRecord, 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, STAGE_MIGRATION_EVENT, STAGE_MIGRATION_ID, 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 StageChainState, type StageOperation, type StageOperationsResult, type StagePayloads, 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, applyStageOperations, areaForFokus, areasFor, batchesForPromptRun, bildPfad, bilderDesLaufs, buildCameraPreviewContext, buildManualPromptRunRecord, buildPromptRunVariantRecord, 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, checkVariantBlock, checkVariantInputAssets, 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, findStageDraftChain, 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, normalizePreviewColor, noticeFor, openStageDraftChain, ordersForPromptRun, ordneSeedsZu, pagePromptRuns, parseRunResponse, parseSeedListe, parseSzenenSnapshot, pinPreviewColors, preparePromptDerivation, preparePromptOperation, prepareStageMigration, previewColorConflicts, previewColorDistance, previewColorLegibility, previewColorNodes, promptDiagnosticsOf, promptRunPageForTransport, promptRunPageFromTransport, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, resolveArea, resolveGeneralScenePolicies, resolveScenePayload, resolveShot, resolveShotPayload, responseContractOf, roundOfRun, roundsOf, rulesWithoutPromptEffect, runOfOperation, runPromptDerivation, runStoreDifferential, sameResponseAs, sameVariantRequest, sceneOnlyCapabilities, scenePolicyFingerprint, sceneVersionElementsOf, scopeOfPath, seedFehlerText, selectImageJobs, selectPromptRuns, selectableTargetModels, siblingsOf, sortScenePolicies, sourceOf, stageColors, stageFrame, stageNode, supportsCompositionReference, szenenSnapshotFilename, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason, variantOf };