@rslsp1/fa-app-tools 2.0.87 → 4.0.0

package/dist/szenen.d.mts

@@ -1,5 +1,5 @@
-import { ac as SchemaError, Z as PublishFinding, Y as PublishCheckResult, aj as SzenenElementType, a2 as ReferenceResolver, ap as TargetModelResolution, I as ElementSnapshot, w as DerivationInputMode, M as ImageProvenance, s as DerivationFailure, n as DerivableType, N as NotDerivable, p as DerivationConflict, u as DerivationFollowUp, B as DraftChainMeta, q as DerivationDiagnostic, o as DerivationAssessment, h as ContextChainPort, a as AuthoritativeSzenenStore, ai as SzenenElementStore, v as DerivationImage, al as SzenenQueries, ah as SzenenCommands, ar as UnusableProposal } from './storeContract-B2BDgvhN.mjs';
-export { A as ALL_PUBLISH_RULES, C as CHAIN_EDGES, b as CHAIN_LINK_FIELDS, c as CatalogueEntry, d as ChainLinkField, e as ChainTarget, f as ChainVerdict, g as CompiledSchemas, i as ContractCheck, j as ContractCheckResult, k as ContractRunResult, l as ContractViolation, m as CreateElementInput, D as DERIVABLE_TYPES, r as DerivationEnvelope, t as DerivationFailureClass, x as DerivationPolicyPayload, y as DerivationProposal, z as DraftChainLink, E as DraftFork, F as DraftRecord, G as ElementMetadata, H as ElementRecord, J as ElementStoreContractHarness, K as ElementVersionValidation, L as FindingSeverity, O as OptionalCommand, P as PROBE_VERSION_ID, Q as ParentRelation, R as PreferredHeadOutcome, S as PreferredHeadResolution, T as PreferredHeadSelection, U as PreferredHeadSource, V as ProjectionState, W as ProjectionStatus, X as PublishCheckInput, _ as PublishRejected, $ as PublishVersionInput, a0 as PublishedVersion, a1 as REFERENCE_FIELD, a3 as ResolvePreferredHeadOptions, a4 as ResolvedVersion, a5 as ReviseMetadataInput, a6 as STYLE_PAYLOAD, a7 as STYLE_PAYLOAD_V2, a8 as SZENEN_ELEMENT_TYPES, a9 as SceneDerivationInput, aa as SceneDerivationOutcome, ab as SceneDerivationOutput, ad as SchemaValidationResult, ae as SetPreferredHeadInput, af as StoreAuthority, ag as SzenenCommandResult, ak as SzenenProjection, am as TargetModelCandidate, an as TargetModelQueries, ao as TargetModelQuery, aq as UnsupportedSchemaError, as as VersionDag, at as VersionDagError, au as VersionNode, av as VersionParentLink, aw as WriteConflict, ax as WriteDraftInput, ay as assessDerivationResponse, az as buildDerivationSystemInstruction, aA as buildDerivationUserPrompt, aB as buildVersionDag, aC as checkChainTargets, aD as checkDerivationResponse, aE as checkDraftChainMeta, aF as collectVersionRefs, aG as compileSchemas, aH as createSimulationSceneDerivationPort, aI as describeTargetModelFailure, aJ as elementStoreContractChecks, aK as formatSchemaErrors, aL as getSzenenSchemas, aM as isOk, aN as isProjectionCurrent, aO as linkFor, aP as parseDerivationResponse, aQ as preferredVersionId, aR as resolvePreferredHead, aS as resolveTargetModelOver, aT as resolverFromQueries, aU as runElementStoreContract, aV as runPublishChecks, aW as runSceneDerivation, aX as showChain, aY as validateAgainst, aZ as validateDerivationInput, a_ as validateElementVersion, a$ as validatePayload, b0 as withReference } from './storeContract-B2BDgvhN.mjs';
+import { Z as PublishFinding, ac as SchemaError, Y as PublishCheckResult, aj as SzenenElementType, a2 as ReferenceResolver, ap as TargetModelResolution, I as ElementSnapshot, w as DerivationInputMode, M as ImageProvenance, s as DerivationFailure, n as DerivableType, N as NotDerivable, p as DerivationConflict, u as DerivationFollowUp, B as DraftChainMeta, q as DerivationDiagnostic, o as DerivationAssessment, h as ContextChainPort, a as AuthoritativeSzenenStore, ai as SzenenElementStore, v as DerivationImage, al as SzenenQueries, ah as SzenenCommands, ar as UnusableProposal } from './storeContract-5vApx6VA.mjs';
+export { A as ALL_PUBLISH_RULES, C as CHAIN_EDGES, b as CHAIN_LINK_FIELDS, c as CatalogueEntry, d as ChainLinkField, e as ChainTarget, f as ChainVerdict, g as CompiledSchemas, i as ContractCheck, j as ContractCheckResult, k as ContractRunResult, l as ContractViolation, m as CreateElementInput, D as DERIVABLE_TYPES, r as DerivationEnvelope, t as DerivationFailureClass, x as DerivationPolicyPayload, y as DerivationProposal, z as DraftChainLink, E as DraftFork, F as DraftRecord, G as ElementMetadata, H as ElementRecord, J as ElementStoreContractHarness, K as ElementVersionValidation, L as FindingSeverity, O as OptionalCommand, P as PROBE_VERSION_ID, Q as ParentRelation, R as PreferredHeadOutcome, S as PreferredHeadResolution, T as PreferredHeadSelection, U as PreferredHeadSource, V as ProjectionState, W as ProjectionStatus, X as PublishCheckInput, _ as PublishRejected, $ as PublishVersionInput, a0 as PublishedVersion, a1 as REFERENCE_FIELD, a3 as ResolvePreferredHeadOptions, a4 as ResolvedVersion, a5 as ReviseMetadataInput, a6 as STYLE_PAYLOAD, a7 as STYLE_PAYLOAD_V2, a8 as SZENEN_ELEMENT_TYPES, a9 as SceneDerivationInput, aa as SceneDerivationOutcome, ab as SceneDerivationOutput, ad as SchemaValidationResult, ae as SetPreferredHeadInput, af as StoreAuthority, ag as SzenenCommandResult, ak as SzenenProjection, am as TargetModelCandidate, an as TargetModelQueries, ao as TargetModelQuery, aq as UnsupportedSchemaError, as as VersionDag, at as VersionDagError, au as VersionNode, av as VersionParentLink, aw as WriteConflict, ax as WriteDraftInput, ay as assessDerivationResponse, az as buildDerivationSystemInstruction, aA as buildDerivationUserPrompt, aB as buildVersionDag, aC as checkChainTargets, aD as checkDerivationResponse, aE as checkDraftChainMeta, aF as collectVersionRefs, aG as compileSchemas, aH as createSimulationSceneDerivationPort, aI as describeTargetModelFailure, aJ as elementStoreContractChecks, aK as formatSchemaErrors, aL as getSzenenSchemas, aM as isOk, aN as isProjectionCurrent, aO as linkFor, aP as parseDerivationResponse, aQ as preferredVersionId, aR as resolvePreferredHead, aS as resolveTargetModelOver, aT as resolverFromQueries, aU as runElementStoreContract, aV as runPublishChecks, aW as runSceneDerivation, aX as showChain, aY as validateAgainst, aZ as validateDerivationInput, a_ as validateElementVersion, a$ as validatePayload, b0 as withReference } from './storeContract-5vApx6VA.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-Dkfrcd_t.mjs';
@@ -34,6 +34,86 @@ declare const ELEMENT_VERSION_SCHEMA_FILE = "element-version.schema.json";
  */
 declare function hasPlacementCapability(setupPayload: unknown): boolean;
 
+/**
+ * Ein fachlicher Befund des Promptpfads, der den Lauf **nicht** verhindert hat.
+ *
+ * Er wird im Lauf mit eingefroren (D-22): Wer spaeter fragt, warum ein Prompt
+ * ohne Kameravorgabe entstand, findet die Antwort im Lauf und nicht in einem
+ * Logfile, das es nicht mehr gibt.
+ */
+interface PromptDiagnostic {
+    /** Regel-ID (`P-07`) oder Kennung einer Aufloesungsentscheidung. */
+    code: string;
+    /** Woher der Befund stammt. */
+    origin: 'rule' | 'schema' | 'resolution';
+    /** JSON-Pointer auf die betroffene Stelle, soweit bestimmbar. */
+    path: string;
+    message: string;
+}
+/**
+ * Was ein Regelbefund im **Promptpfad** bewirkt.
+ *
+ * `blocker` steht bewusst in keiner Zeile der Tabelle unten: Kein Befund aus
+ * P-01…P-17 verhindert fuer sich genommen einen Textauftrag. Die echten
+ * Prompt-Blocker sind keine Regelbefunde, sondern Zustaende — kein
+ * verwertbarer Inhalt, ein Revisionskonflikt, eine technisch unlesbare
+ * Eingabe, eine nicht endlich aufloesbare Pflichtstruktur. Sie stehen dort,
+ * wo sie entstehen (`resolve.ts`, `freezeDraftChain.ts`), nicht hier.
+ */
+type PromptEffect = 'diagnostic' | 'blocker' | 'not_applicable';
+/**
+ * Die Zielrichtung aus Schritt 07 §6, als ausfuehrbare Tabelle.
+ *
+ * Vollstaendig ueber `ALL_PUBLISH_RULES` — ein Test wacht darueber. Eine neue
+ * Regel muss hier eingeordnet werden, sonst faellt sie im Promptpfad
+ * stillschweigend unter den Tisch, und genau das war der Fehler, den die
+ * positive Liste in `capabilities.ts` schon einmal verhindert hat.
+ */
+declare const PROMPT_RULE_EFFECT: Readonly<Record<string, PromptEffect>>;
+/** Regeln, die weder eingeordnet noch als unzuständig benannt sind. */
+declare function rulesWithoutPromptEffect(alleRegeln: readonly string[]): readonly string[];
+/**
+ * Macht aus einem Publish-Befund einen Prompt-Diagnostic.
+ *
+ * Der Text des Befundes bleibt woertlich stehen. Ihn umzuformulieren hiesse,
+ * dieselbe Sache an zwei Stellen zu erklaeren — und die zweite Fassung waere
+ * irgendwann die falsche.
+ */
+declare function diagnosticOfFinding(finding: PublishFinding): PromptDiagnostic;
+/** Macht aus einem Schemabefund einen Prompt-Diagnostic (Schritt 07 §7). */
+declare function diagnosticOfSchemaError(error: SchemaError, where: string): PromptDiagnostic;
+/**
+ * Alle Prompt-Diagnostics eines Prueflaufs.
+ *
+ * `advisory` und `blocking` werden hier **gleich** behandelt: Fuer den
+ * Promptlauf ist der Unterschied bedeutungslos, weil keiner von beiden ihn
+ * verhindert. Der Unterschied bleibt dort erhalten, wo er zaehlt — im
+ * Publish-Pfad, der `PublishCheckResult.ok` liest.
+ */
+declare function promptDiagnosticsOf(checks: PublishCheckResult): PromptDiagnostic[];
+/**
+ * Der **einzige** inhaltliche Prompt-Blocker: Gibt dieser Arbeitsstand
+ * ueberhaupt etwas her, das sich beschreiben laesst?
+ *
+ * „Tolerant" heisst nicht „aus nichts wird ein Lauf" (Goal §5.3). Verwertbar
+ * ist eine Szene, wenn mindestens **eine** dieser Quellen Text traegt:
+ *
+ *   * ein Knoten mit `semantic.description`,
+ *   * ein Knoten mit mindestens einer Komponentenreferenz — der Text steht
+ *     dann in der referenzierten Komponente,
+ *   * ein Umgebungstext oder eine Umgebungsreferenz.
+ *
+ * Bewusst **nicht** die blosse Knotenzahl: Ein Knoten ohne jede Beschreibung
+ * ist ein Platzhalter, kein Inhalt, und ein Prompt daraus waere die leere
+ * Behauptung, die §5.3 ausschliesst.
+ */
+declare function describableContent(scenePayload: unknown): {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+
 /**
  * Zustand einer Fähigkeit.
  *
@@ -126,11 +206,20 @@ interface CapabilityReport {
      * Stand die Modellregeln ein", sondern „ist das überhaupt ein Scene Setup".
      */
     schemaErrors: readonly SchemaError[];
+    /**
+     * Was dem Promptpfad auffiel, ohne ihn zu verhindern (D-135).
+     *
+     * Dieselben Befunde, die `checks` fuehrt — nur in der Wirkung, die sie fuer
+     * **diese** Operation haben. Ein zweiter Prueflauf entsteht dabei nicht.
+     */
+    promptDiagnostics: readonly PromptDiagnostic[];
 }
 /** Ein falscher Anker ist ein Aufruffehler, kein Befund. */
 declare class CapabilityAnchorError extends Error {
 }
 type CapabilityScope = 'scene' | 'camera_rig' | 'placement' | 'global';
+/** Die drei Flags des Berichts — als Name, nicht als Restmenge des Berichts. */
+type CapabilityFlagName = 'can_describe_scene' | 'can_render_prompt' | 'can_place';
 /**
  * Welche Bereiche eine Regel beim Anker `scene_setup` abdeckt.
  *
@@ -187,6 +276,29 @@ declare function capabilityReport(input: CapabilityReportInput): Promise<Capabil
  * damit er gegen `ALL_PUBLISH_RULES` läuft und nicht gegen eine Kopie davon.
  */
 declare function unclassifiedPublishRules(): readonly string[];
+/**
+ * Der Fähigkeitsstand einer Szene, für die es **kein** Scene Setup gibt.
+ *
+ * Seit D-135 kann ein Promptlauf direkt aus einer Szene entstehen. Dann gibt
+ * es keinen Anker für `capabilityReport()` — der hängt am `scene_setup` (D-20)
+ * und wirft bei jedem anderen Typ. Trotzdem muss der Lauf drei Zustände
+ * einfrieren, und sie dürfen nicht geraten sein.
+ *
+ * Diese Funktion leitet sie aus **denselben Primitiven** ab, die der Bericht
+ * benutzt — Knotenzahl, `describableContent()`, `hasPlacementCapability()`.
+ * Sie ist deshalb keine zweite Fähigkeitsableitung (R-2), sondern dieselbe
+ * ohne den Setup-Teil.
+ *
+ * `can_place` ist hier immer `no`, und das ist keine Verlegenheit: Die
+ * Weltplatzierung liegt ausschließlich im Scene Setup (D-39), das
+ * `coordinate_system` ebenfalls (D-65). Ohne Setup gibt es keine belastbaren
+ * Koordinaten — nicht „unbekannt", sondern nachweislich keine.
+ */
+declare function sceneOnlyCapabilities(scenePayload: unknown): {
+    can_describe_scene: CapabilityFlag;
+    can_render_prompt: CapabilityFlag;
+    can_place: CapabilityFlag;
+};
 
 /** Ein Beitrag zur Beschreibung eines Knotens, mit Herkunft (D-50). */
 interface NodeContribution {
@@ -218,6 +330,7 @@ interface ResolvedPlacement {
 interface ResolvedCamera {
     camera_id: string;
     name: string | null;
+    /** `null`, wenn das Preset nicht auflösbar war — kein erfundenes Objektiv. */
     preset: unknown;
     placement: unknown;
     orientation: unknown;
@@ -226,24 +339,51 @@ interface ResolvedCamera {
     /** Aufgelöste Pattern-Version, falls die Platzierung eines benutzt. */
     pattern: unknown | null;
 }
-/** Die Renderer-Eingabe nach `prompt-derivation.md` §3a. */
+/**
+ * Die Renderer-Eingabe nach `prompt-derivation.md` §3a — seit D-135 in
+ * Normalform.
+ *
+ * `shot`, `setup`, `camera`, `target_model` und `target_model_resolution` sind
+ * **echt optional**: `null` heißt „gab es nicht", nicht „wurde durch einen
+ * Platzhalter ersetzt". Ein Dummy-Objekt an einer dieser Stellen wäre von
+ * einer echten Angabe nicht zu unterscheiden — genau der Einwand, den D-75
+ * gegen erfundene Kennungen führt.
+ *
+ * `scene` bleibt Pflicht. Sie ist der beschreibbare Inhalt, und ohne ihn gibt
+ * es nichts zu formulieren (Goal §5.3).
+ */
 interface RendererInput {
+    /** `null` bei einem Lauf ohne Shot (Szene-Direktpfad). */
     shot: {
         version_id: string;
         element_id: string;
-        camera_id: string;
+        /** `null`, wenn der Shot keine auflösbare Kamera nennt. */
+        camera_id: string | null;
         shot_concept: unknown | null;
         user_instruction: string | null;
         text_override: string | null;
-    };
+    } | null;
+    /**
+     * Das verwendete Scene Setup — Herkunft, nicht Inhalt (D-135).
+     *
+     * Der Inhalt des Setups steckt bereits in `nodes` (Overrides, Placements)
+     * und in `styles`. Was fehlte, war die Auskunft, **welches** Setup das war;
+     * bei einem Lauf ohne Setup steht hier ehrlich `null`.
+     */
+    setup: {
+        version_id: string;
+        element_id: string;
+    } | null;
     scene: {
+        element_id: string;
         version_id: string;
         nodes: readonly ResolvedNode[];
         relations: readonly unknown[];
         environment: unknown | null;
         unit_system: unknown | null;
     };
-    camera: ResolvedCamera;
+    /** `null`, wenn der Lauf ohne konkrete Kamera entstand. */
+    camera: ResolvedCamera | null;
     styles: readonly {
         role: string;
         rank: number;
@@ -263,7 +403,8 @@ interface RendererInput {
         text: string;
         locale: string | null;
     }[];
-    target_model: unknown;
+    /** `null` bei generischer Ableitung ohne Zielmodell. */
+    target_model: unknown | null;
     /**
      * Fälle, in denen die Zielsprache nicht verfügbar war (D-48).
      *
@@ -275,6 +416,15 @@ interface RendererInput {
     localization_notes: readonly unknown[];
     /** Annahmen, unter denen diese Eingabe entstanden ist. */
     assumptions: readonly string[];
+    /**
+     * Fachliche Befunde, die den Lauf **nicht** verhindert haben (D-135).
+     *
+     * Publish-Befunde, Schemabefunde und ausgelassene optionale Teile — jeder
+     * mit Regel-ID bzw. Kennung. Sie werden mit dem Lauf eingefroren: Wer später
+     * fragt, warum ein Prompt ohne Kameravorgabe entstand, findet die Antwort im
+     * Lauf.
+     */
+    diagnostics: readonly PromptDiagnostic[];
     /** Die Fähigkeiten, die die Auflösung gesehen hat — eingefroren (D-22). */
     capabilities: {
         can_describe_scene: string;
@@ -283,7 +433,7 @@ interface RendererInput {
     };
     /** Die tatsächlich verwendete Kontextkette (§4.9.1). */
     context_chain: readonly (string | null)[];
-    /** Wie das Zielmodell gefunden wurde (§4.9.1). */
+    /** Wie das Zielmodell gefunden wurde (§4.9.1). `null` ohne Zielmodell. */
     target_model_resolution: {
         element_id: string;
         version_id: string;
@@ -293,7 +443,7 @@ interface RendererInput {
             element_id: string;
             context_id: string | null;
         }[];
-    };
+    } | null;
 }
 /**
  * Warum eine Auflösung nicht zustande kam.
@@ -301,6 +451,12 @@ interface RendererInput {
  * Alles hier ist **fachlich**. Technische Lesefehler werfen und werden nie zu
  * einer dieser Klassen — sonst entstünde aus einer kränkelnden Datenbank eine
  * Aussage über den Bestand (Grundsatzregel 5).
+ *
+ * Die Liste ist mit D-135 **kürzer geworden**, nicht länger: `schema` gilt nur
+ * noch für eine Payload, die technisch nicht lesbar ist, und
+ * `capability_blocked`/`capability_undetermined` entstehen im Promptpfad nicht
+ * mehr. Sie bleiben als Typen erhalten, weil `capabilityGate()` sie weiterhin
+ * für Aufrufer bildet, die eine Fähigkeit ausdrücklich als Tor benutzen wollen.
  */
 type ResolveFailure = {
     class: 'not_a_shot';
@@ -313,8 +469,13 @@ type ResolveFailure = {
 } | {
     class: 'schema';
     message: string;
-    where: 'shot' | 'scene_setup';
+    where: 'shot' | 'scene_setup' | 'scene';
     errors: readonly SchemaError[];
+}
+/** Kein verwertbarer beschreibbarer Inhalt (Schritt 05 §5.1, Goal §5.3). */
+ | {
+    class: 'no_content';
+    message: string;
 } | {
     class: 'capability_blocked';
     message: string;
@@ -339,7 +500,7 @@ type ResolveFailure = {
 type ResolveResult = {
     kind: 'resolved';
     input: RendererInput;
-    report: CapabilityReport;
+    report: CapabilityReport | null;
 } | {
     kind: 'rejected';
     failure: ResolveFailure;
@@ -398,9 +559,7 @@ interface ResolveShotPayloadInput {
      * Zielmodell-Logik (Gate C0).
      *
      * Die `version_id` ist bei einem Draft leer — sie wird **nicht** erfunden
-     * (D-98/D-75). Alle übrigen Referenzen (Preset, Pattern, Styles, Policies,
-     * Zielmodell) bleiben veröffentlichungspflichtig: D-96 erlaubt genau zwei
-     * Draft-Kanten, nicht beliebige.
+     * (D-98/D-75).
      */
     chain?: {
         setup: {
@@ -423,13 +582,44 @@ interface ResolveShotPayloadInput {
  * gebaut wurde („prüfen, bevor geschrieben wird"). Es wird nichts gespeichert
  * und kein Modell gerufen.
  *
- * Die **Referenzen** müssen trotzdem veröffentlicht und sichtbar sein (D-03):
- * Ein Entwurf darf auf nichts zeigen, was es noch nicht gibt.
+ * **Seit D-135 tolerant.** Ein Schemabefund am Shot oder am Setup beendet den
+ * Lauf nicht mehr; er wird als Diagnostic mitgeführt. Was noch beendet, ist
+ * eine Payload, die technisch nicht lesbar ist, und ein Inhaltsträger — Setup
+ * oder Szene —, dessen Referenz sich nicht auflösen lässt.
  */
 declare function resolveShotPayload(input: ResolveShotPayloadInput): Promise<ResolveResult>;
+interface ResolveScenePayloadInput {
+    /** Payload einer `scene` — Entwurf oder veröffentlichte Version. */
+    scenePayload: unknown;
+    sceneElementId: string;
+    /** Kennung der Version, falls es eine gibt. Bei einem Entwurf leer. */
+    sceneVersionId?: string;
+    resolver: ReferenceResolver;
+    contextChain: readonly (string | null)[];
+    userInstruction?: string | null;
+}
+/**
+ * Löst eine **Szene allein** zur Renderer-Eingabe auf (D-135).
+ *
+ * Kein Shot, kein Scene Setup, keine Kamera, kein Zielmodell — und
+ * ausdrücklich keine erfundenen Ersatzobjekte dafür. Was hier entsteht, ist
+ * dieselbe Renderer-Eingabe wie beim vollständigen Shot-Pfad, nur mit `null`
+ * an den Stellen, die es in diesem Arbeitsstand nicht gibt.
+ *
+ * Die Zusammensetzung ist **dieselbe Funktion**: Beitragsreihenfolge (D-50),
+ * Sichtbarkeit (D-21), Annahmen und Diagnostics entstehen für beide Wege im
+ * selben Code. Ein zweiter Prompt-Stack wäre die zweite Wahrheit aus R-2.
+ */
+declare function resolveScenePayload(input: ResolveScenePayloadInput): Promise<ResolveResult>;
 /**
  * Prüft ein Fähigkeits-Flag als Torwächter.
  *
+ * **Nicht mehr Teil des Promptpfads** (D-135): Ein Publish-Befund verhindert
+ * dort keinen Textversuch mehr. Die Funktion bleibt für Aufrufer, die eine
+ * Fähigkeit ausdrücklich als Bedingung ihrer **eigenen** Operation lesen —
+ * etwa ein späterer Blender-/Freeze-Pfad, der genau das darf (Schritt 07 §3
+ * D/E).
+ *
  * `no` und `unknown` bekommen **verschiedene** Klassen. Die Ablehnung bei
  * `unknown` sagt „das liess sich hier nicht feststellen", nicht „die Szene kann
  * das nicht" — der Unterschied ist der ganze Grund, warum `unknown` in D-64 ein
@@ -787,6 +977,23 @@ type PromptRunSource = {
     derivation_run_id?: string;
     /** Gesetzt, wenn die Kette aus einer Recovery-Arbeitsfassung kam (D-99). */
     derivation_recovery_id?: string;
+}
+/**
+ * Der Lauf entstand **direkt aus einer Szene** — Stufe 6.11 (D-135).
+ *
+ * Kein Shot, kein Scene Setup, keine Kette. Was eingefroren wurde, ist genau
+ * ein Arbeitsstand: entweder ein Entwurf (`draft_id` + `revision`) oder eine
+ * veröffentlichte Version (`version_id`). Nie beides, und nie ein erfundener
+ * Ersatz für das jeweils andere (D-75/D-98).
+ */
+ | {
+    kind: 'scene_direct';
+    scene: {
+        element_id: string;
+        draft_id: string | null;
+        revision: number | null;
+        version_id: string | null;
+    };
 };
 interface PromptRunRecord {
     run_id: string;
@@ -798,9 +1005,14 @@ interface PromptRunRecord {
      * unterscheiden. Wer die Herkunft wissen will, liest `source`.
      */
     shot_version_id: string;
+    /**
+     * Das Shot-Element. **Leer** bei einem Lauf, der ohne Shot entstand (D-135).
+     */
     shot_element_id: string;
     scene_setup_version_id: string;
+    /** Leer, wenn der Lauf ohne konkrete Kamera entstand (D-135). */
     camera_id: string;
+    /** Leer bei generischer Ableitung ohne Zielmodell (D-135). */
     target_model_version_id: string;
     provider: string;
     model_id: string;
@@ -1064,6 +1276,7 @@ interface ChainSnapshot {
             element: {
                 element_id: string;
                 type: string;
+                context_id?: string | null;
             };
             draft: {
                 draft_id: string;
@@ -1072,6 +1285,23 @@ interface ChainSnapshot {
                 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;
+            }[];
+            preferredHeads?: readonly {
+                context_id: string | null;
+                version_id?: string;
+            }[];
         } | null;
     };
 }
@@ -1106,6 +1336,49 @@ interface FreezeDraftChainInput {
  * 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;
+}
+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;
+}
+/**
+ * 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.
@@ -1391,6 +1664,49 @@ interface ImageGenerationStartedPayload {
         aspect_ratio?: string;
         seeds?: readonly number[];
         callable_model_id: string;
+        /**
+         * Der Anbieter des ausgefuehrten Modells (D-132) — `google`, nicht `flow`.
+         * Flow ist eine Umgebung, kein Anbieter.
+         *
+         * Optional, und das ist keine Nachlaessigkeit: Auftraege aus der Zeit vor
+         * D-128 tragen das Feld nicht, und die Projektion darf es fuer sie nicht
+         * erfinden (D-107).
+         */
+        provider?: string;
+        /** Das Zielmodell, mit dem die Pixel erzeugt wurden (D-131). */
+        execution_target_model_key?: string;
+        /** Dessen wirksame Version, sofern bekannt — nichts wird erfunden. */
+        execution_target_model_version_id?: string;
+        /** Das Ausfuehrungsprofil dieses Zielmodells, das gegolten hat. */
+        execution_profile_id?: string;
+        /** Die App-Umgebung, in der ausgefuehrt wurde (D-132). */
+        environment_id?: string;
+        /** Der technische Aufrufweg des Hosts. */
+        execution_path?: string;
+        /**
+         * Exakt der Modellwert, mit dem der Aufrufweg gestartet wurde. Fuehrt
+         * denselben Wert wie `callable_model_id`; letzteres bleibt, weil
+         * Altauftraege und der Server es tragen.
+         */
+        execution_model_id?: string;
+        /**
+         * Das Zielmodell, fuer das der Prompt formuliert wurde, oder `null`.
+         * Zusammen mit `target_model_matched` bleibt die Abweichung
+         * „optimiert fuer X, ausgefuehrt mit Y" dauerhaft nachvollziehbar (D-131).
+         */
+        prompt_target_model_key?: string | null;
+        /**
+         * Ob das ausgefuehrte Zielmodell das Prompt-Zielmodell war. Getrennt vom
+         * Schluessel, damit ein Leser die Abweichung nicht aus zwei verschiedenen
+         * Kennungen erraten muss. Fehlt das Feld, ist **keine** Aussage getroffen.
+         */
+        target_model_matched?: boolean;
+        /**
+         * Ob der negative Promptkanal wirklich mitgelaufen ist (D-130 §9) — nicht,
+         * ob der Lauf einen traegt. Fehlt das Feld, kennt der Auftrag die Frage
+         * nicht.
+         */
+        negative_prompt_transmitted?: boolean;
     };
     created_at: string;
 }
@@ -1649,45 +1965,162 @@ declare function differentialSteps(): readonly DifferentialStep[];
  */
 declare function runStoreDifferential(left: () => Promise<SzenenElementStore> | SzenenElementStore, right: () => Promise<SzenenElementStore> | SzenenElementStore): Promise<DifferentialResult>;
 
-/** Ein aufrufbares Bildmodell und seine Parametergrenzen. */
-interface CallableImageModel {
-    callable_model_id: string;
-    provider: string;
+/**
+ * Ein Ausführungsprofil eines Zielmodells (D-130) — wie ein konkreter Host
+ * dieses Modell wirklich aufruft.
+ */
+interface ImageExecutionProfile {
+    /** Stabile Kennung **innerhalb** dieses Zielmodells. */
+    profile_id: string;
+    /** Auswählbar, oder bewusst abgeschaltet. */
+    enabled: boolean;
+    /** Umgebungen, in denen dieses Profil gilt. */
+    environments: readonly string[];
+    /** Der technische Aufrufweg, den der Host besitzen muss. */
+    execution_path: string;
+    /**
+     * Exakt der Modellwert, den der vorhandene Aufrufweg als Eingabe erwartet
+     * (D-132) — nicht zwingend die offizielle Endpunkt-ID des Anbieters. Was
+     * hier steht, geht unverändert an den Adapter und in die Provenienz.
+     */
+    execution_model_id: string;
     max_images: number;
+    /** Vom konkreten Pfad übertragene Seitenverhältnisse. Darf leer sein. */
     aspect_ratios: readonly string[];
-    supports_seed: boolean;
+    /** Ob ein Seed über diesen Pfad wirklich übertragen wird. */
+    accepts_seed: boolean;
+    /** Ob ein separater negativer Prompt wirklich übertragen wird. */
+    accepts_negative_prompt: boolean;
+}
+/**
+ * Was **dieser Host** kann (D-132).
+ *
+ * Bewusst nur zwei Angaben: in welcher Umgebung er läuft und welche Aufrufwege
+ * er besitzt. Keine Modellliste — die kommt aus den Zielmodellen.
+ */
+interface ImageHostCapability {
+    environment_id: string;
+    /**
+     * Die Aufrufwege dieses Hosts — je Weg **mit dem Anbieter, zu dem er
+     * führt** (R-06.1).
+     *
+     * Der Anbieter steht hier und nicht als Tabelle in der Domain: Wer den Weg
+     * besitzt, weiß auch, wo er endet. Ohne diese Angabe könnte ein falsch
+     * gepflegtes Profil (`provider: artspace`, `execution_path: google_flow`)
+     * den Google-Weg rufen und die Provenienz trotzdem `artspace` protokollieren
+     * — der Auftrag würde etwas anderes behaupten als das, was passiert ist.
+     */
+    execution_paths: readonly ImageExecutionRoute[];
+}
+/** Ein Aufrufweg des Hosts und der Anbieter, bei dem er landet. */
+interface ImageExecutionRoute {
+    execution_path: string;
+    provider: string;
 }
-/** Die katalogisierte Zuordnung für einen `target_model.key`, oder `null`. */
-declare function callableImageModelFor(targetModelKey: string): CallableImageModel | null;
-/** Der Ausgang der Fähigkeitsauskunft (D-115). */
-type ImageGenerationCapability = {
-    kind: 'supported';
+/** Ein Zielmodell, so wie die Auswahl es braucht. */
+interface ExecutionTargetModel {
+    key: string;
+    title: string;
+    provider: string | null;
+    /** Die wirksame Version, aus der die Profile stammen — für die Provenienz. */
+    versionId?: string;
+    /** Roh aus der Payload; wird hier gegen den Vertrag geprüft. */
+    executionProfiles: readonly unknown[];
+}
+/** Eine wirklich ausführbare Kombination aus Zielmodell und Profil. */
+interface ExecutableImageModel {
+    /** Kennung der Auswahl: Zielmodell **und** Profil, weil beides zählt. */
+    selection_id: string;
     target_model_key: string;
+    target_model_version_id?: string;
+    display_name: string;
     provider: string;
-    callable_model_id: string;
+    profile_id: string;
+    environment_id: string;
+    execution_path: string;
+    execution_model_id: string;
     max_images: number;
     aspect_ratios: readonly string[];
-    supports_seed: boolean;
-} | {
-    kind: 'unsupported';
-    target_model_key: string;
-    reason: string;
-};
+    accepts_seed: boolean;
+    accepts_negative_prompt: boolean;
+    /** Ob dieses Zielmodell das ist, für das der Prompt optimiert wurde (D-131). */
+    is_prompt_target: boolean;
+}
 /**
- * Ob **dieser Host** tatsächlich Zugang zu einem katalogisierten Bildmodell
- * hat — die einzige Stelle, an der Host-Wissen einfließen darf, und zwar als
- * Funktionsparameter, nicht als Verzweigung im gemeinsamen Code (R-1).
+ * Die Modellwahl für einen Lauf in einer konkreten Umgebung.
+ *
+ * `models` ist leer, wenn kein Zielmodell dieser Umgebung ein aktives,
+ * vom Host ausführbares Profil trägt. Das ist kein Fehler und sperrt den Lauf
+ * nicht — der externe Importpfad bleibt daneben stehen (D-104.5/D-133).
  */
-type ImageProviderAccessCheck = (model: CallableImageModel) => boolean;
+interface ImageModelChoice {
+    /** Das Zielmodell, für das der Prompt erzeugt wurde, oder `null` (D-103). */
+    prompt_target_model_key: string | null;
+    models: readonly ExecutableImageModel[];
+    /**
+     * Die Vorauswahl: das Profil des Prompt-Zielmodells, sonst das erste
+     * ausführbare. `null` bei leerer Liste. Komfort, keine Festlegung (D-131).
+     */
+    default_selection_id: string | null;
+    /** Nur gesetzt, wenn `models` leer ist: warum es hier nichts zu wählen gibt. */
+    reason?: string;
+    /**
+     * Profile, die den Vertrag verletzen — als Klartext, je Zielmodell.
+     *
+     * Sie werden **nicht** angeboten und **nicht** stillschweigend weggelassen:
+     * Ein falsch gepflegtes Profil soll sichtbar sein, sonst sucht der Autor die
+     * Ursache im Host (Regel 4/11).
+     */
+    invalid_profiles: readonly string[];
+}
 /**
- * Die Fähigkeitsauskunft: aus dem eingefrorenen `target_model` (D-103) und
- * der Zugangsauskunft des Hosts entsteht `supported` oder `unsupported`.
+ * Prüft ein rohes Profil gegen den Vertrag und liefert die Befunde als Klartext.
  *
- * `unsupported` ist kein Fehler und blockiert nichts (D-104.5) — der
- * Prompt-Lauf bleibt vollständig nutzbar und bekommt Ergebnisse über den
- * externen Importpfad (Teil D).
+ * Exportiert, weil der Zielmodell-Editor dieselbe Prüfung vor dem Speichern
+ * zeigen soll — eine Regel, eine Stelle.
  */
-declare function capabilityForTargetModel(targetModel: unknown, hasAccess: ImageProviderAccessCheck): ImageGenerationCapability;
+declare function checkImageExecutionProfile(profile: unknown): readonly string[];
+/**
+ * Prüft die Profilliste **eines** Zielmodells und liefert die Befunde je Profil
+ * (R-06.2).
+ *
+ * Zusätzlich zur Einzelprüfung: `profile_id` muss innerhalb eines Zielmodells
+ * eindeutig sein — auch über deaktivierte Profile hinweg. Die Auswahl wird über
+ * `zielmodell#profil` identifiziert; zweimal dieselbe Kennung wäre nicht mehr
+ * eindeutig auflösbar, und die Laufzeit nähme stillschweigend das erste. Über
+ * **verschiedene** Zielmodelle hinweg darf dieselbe Kennung vorkommen
+ * (`nano_banana_pro#flow` und `imagen_4#flow` sind verschiedene Auswahlen).
+ *
+ * Exportiert, weil der Zielmodell-Editor dieselbe Prüfung zeigt — eine Regel,
+ * eine Stelle.
+ */
+declare function checkImageExecutionProfiles(profiles: readonly unknown[]): readonly (readonly string[])[];
+/**
+ * Alle Bildmodelle, die dieser Host für diesen Lauf wirklich ausführen kann.
+ *
+ * Fünf Bedingungen, alle notwendig (D-130/D-132): Das Profil ist gültig, es ist
+ * aktiviert, es gilt für die Umgebung dieses Hosts, der Host besitzt den
+ * genannten Aufrufweg — und das Zielmodell trägt überhaupt ein Profil.
+ */
+declare function executableImageModels(promptTargetModelKey: string | null, targets: readonly ExecutionTargetModel[], capability: ImageHostCapability): ImageModelChoice;
+/** Eine Kombination aus einer Wahl, exakt über Zielmodell und Profil. */
+declare function findExecutableImageModel(choice: ImageModelChoice, targetModelKey: string, profileId: string): ExecutableImageModel | null;
+/** Die Parameter eines Bildauftrags, wie sie gegen ein Profil geprüft werden. */
+interface ImageModelParameters {
+    imageCount: number;
+    aspectRatio?: string;
+    seeds?: readonly number[];
+}
+/**
+ * Prüft Auftragsparameter gegen das **tatsächlich gewählte** Ausführungsprofil
+ * (D-131) und liefert die Befunde als Klartext.
+ *
+ * Kein stilles Kürzen, kein Umrechnen: Ein Seitenverhältnis, das dieser
+ * Aufrufweg nicht überträgt, wird abgelehnt und nicht auf das nächstliegende
+ * gerundet (Regel 4). Die Meldungen nennen den konkreten Wert und die zulässige
+ * Menge (Regel 11).
+ */
+declare function checkImageModelParameters(model: ExecutableImageModel, parameters: ImageModelParameters): readonly string[];
 
 /** Ein tatsächlich vom Provider geliefertes Bild. */
 interface GeneratedImage {
@@ -1700,7 +2133,18 @@ interface GeneratedImage {
 }
 /** Die Eingabe an den tatsächlichen Provideraufruf — abgeleitet aus dem eingefrorenen Lauf. */
 interface ImageProviderInput {
-    callableModelId: 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. */
+    executionPath: string;
+    /**
+     * Exakt der Modellwert, den dieser Aufrufweg erwartet — aus **demselben**
+     * Profil (D-132). Der Adapter gibt ihn unverändert weiter und hält keine
+     * eigene Mapping-Tabelle.
+     */
+    executionModelId: string;
+    /** Die Umgebung, in der ausgeführt wird (D-132). */
+    environmentId: string;
     provider: string;
     positivePrompt: string;
     negativePrompt?: string | null;
@@ -1734,6 +2178,16 @@ interface ImageGenerationBatchPersistence {
         images: readonly GeneratedImage[];
     }): Promise<CommandResult<PromptImageBatch>>;
 }
+/**
+ * Die Zielmodelle dieses Kontexts, wie der Port sie braucht (D-130).
+ *
+ * Der Host liefert sie — beim React- und Flow-Host über dieselbe
+ * `selectableTargetModels()`-Auskunft, die auch der Editor benutzt. Damit gibt
+ * es keine zweite Wahrheit darüber, welche Zielmodelle sichtbar sind.
+ */
+interface ImageExecutionTargetModelReader {
+    listExecutionTargetModels(): Promise<QueryResult<readonly ExecutionTargetModel[]>>;
+}
 /** Was der Auftragskanal (D-119) braucht — lesen und anhängen, wie `RunEventChannel`. */
 interface ImageGenerationEventChannel {
     appendEvent(type: string, payload: unknown): Promise<void>;
@@ -1742,6 +2196,18 @@ interface StartImageGenerationInput {
     runId: string;
     /** Vom Aufrufer VOR dem Aufruf gebildet (D-113) — deterministisch mit dem Lauf verknüpft. */
     generationBatchId: string;
+    /**
+     * Das Zielmodell, mit dem tatsächlich ausgeführt wird, und sein Profil —
+     * **beides verpflichtend** und explizit (D-131).
+     *
+     * Bewusst kein optionaler Parameter mit Rückfall auf das Prompt-Zielmodell:
+     * Ein bezahlter Bildaufruf, dessen Modell nicht in der Eingabe steht, wäre
+     * nach dem Auftrag nicht mehr von einer Vorauswahl zu unterscheiden. Die
+     * Vorauswahl trifft die Ansicht sichtbar aus
+     * `ImageModelChoice.default_selection_id`, nicht der Port stillschweigend.
+     */
+    executionTargetModelKey: string;
+    executionProfileId: string;
     imageCount: number;
     aspectRatio?: string;
     /** Je Bild, wenn das Modell Seeds kennt. */
@@ -1768,7 +2234,14 @@ type ImageGenerationResult = {
     message: string;
 };
 interface SzenenImageGenerationPort {
-    capabilityForRun(runId: string): Promise<QueryResult<ImageGenerationCapability>>;
+    /**
+     * Alle Modelle, die **diese Umgebung** für diesen Lauf ausführen kann, mit
+     * Vorauswahl und der sichtbaren Optimierungsabsicht (D-128/D-129).
+     *
+     * Die frühere `capabilityForRun()` ist entfallen: Sie beantwortete die
+     * 1:1-Frage aus dem Domänenkatalog, den es nicht mehr gibt.
+     */
+    imageModelChoiceForRun(runId: string): Promise<QueryResult<ImageModelChoice>>;
     startFromPromptRun(input: StartImageGenerationInput): Promise<ImageGenerationResult>;
 }
 interface CreateImageGenerationPortOptions {
@@ -1776,8 +2249,14 @@ interface CreateImageGenerationPortOptions {
     provider: ImageGenerationProviderPort;
     batches: ImageGenerationBatchPersistence;
     events: ImageGenerationEventChannel;
-    /** Ob dieser Host Zugang zu einem katalogisierten Bildmodell hat (D-115). */
-    hasAccess: ImageProviderAccessCheck;
+    /**
+     * Die Zielmodelle, die in diesem Kontext sichtbar sind (D-130). Ihre
+     * `execution_profiles` sind die einzige Quelle ausführbarer Bildmodelle —
+     * der Port konstruiert keines und errät keine Verfügbarkeit.
+     */
+    targetModels: ImageExecutionTargetModelReader;
+    /** Was dieser Host wirklich kann: Umgebung und Aufrufwege (D-132). */
+    capability: ImageHostCapability;
     now?: () => Date;
 }
 /** Der gemeinsame Bildgenerierungs-Port. */
@@ -1835,6 +2314,33 @@ interface SzenenRunPort {
      * Draft-Lauf hat keine, wäre dort also unauffindbar.
      */
     listRunsForChain(chainId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+    /**
+     * Startet einen Lauf **direkt aus einer Szene** — D-135.
+     *
+     * Kein Shot, kein Scene Setup, keine Kamera, kein Zielmodell nötig. Intern
+     * derselbe Weg wie die beiden anderen Einstiege: einfrieren (D-97), dann
+     * dieselbe Ableitung, dieselbe Antwortprüfung, dieselbe Persistenz. Es
+     * entsteht keine zweite Lauf-Architektur — nur ein dritter Einstieg in die
+     * vorhandene.
+     *
+     * Dieselben drei Fehlausgänge wie beim Kettenlauf, und aus demselben Grund:
+     * Konflikt, fachlicher Mangel und technischer Fehler sind verschiedene
+     * Auskünfte. In **allen** Fehlerfällen gilt: Es wurde kein Modell gerufen.
+     */
+    startRunFromScene(input: StartRunFromSceneInput): Promise<StartRunFromDraftResult>;
+    /**
+     * Die Läufe, die direkt aus dieser Szene entstanden sind (D-135).
+     *
+     * Sie tragen weder Shot-Version noch `chain_id` und wären über die beiden
+     * bestehenden Abfragen unauffindbar.
+     */
+    listRunsForScene(sceneElementId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+}
+interface StartRunFromSceneInput {
+    /** Das Szenen-**Element**. Ob Entwurf oder Version gilt, entscheidet der Bestand. */
+    sceneElementId: string;
+    userInstruction?: string;
+    contextId?: string | null;
 }
 /**
  * Warum ein Draft-Lauf nicht zustande kam — **drei** verschiedene Auskünfte.
@@ -2554,7 +3060,14 @@ interface CreateMemoryViewPortOptions {
     /** Simulierter Provideraufruf — Voreinstellung liefert `imageCount` Bilder. */
     imageProvider?: ImageGenerationProviderPort;
     /** Ob der simulierte Host Zugang zum katalogisierten Zielmodell hat. Default: immer. */
-    imageProviderHasAccess?: ImageProviderAccessCheck;
+    imageCapability?: ImageHostCapability;
+    /**
+     * Zielmodelle fuer die Bildauswahl. Vorgabe: die `target_model`-Elemente des
+     * Bestands ueber `selectableTargetModels()` — derselbe Weg wie im echten
+     * Host. Direkt setzbar, damit ein Test eine Auswahl stellen kann, ohne
+     * Elemente anzulegen.
+     */
+    imageTargetModels?: readonly ExecutionTargetModel[];
 }
 declare function createMemoryViewPort(options?: CreateMemoryViewPortOptions): SzenenViewPort;
 
@@ -2569,33 +3082,8 @@ type FlowGenerateImage = (params: FlowGenerateImageParams) => Promise<{
     base64: string;
     mediaId?: string;
 }>;
-/**
- * Katalogisierte Bildmodelle (`imageGenerationCapability.ts`) auf
- * Flow-Display-Namen (`howto-flow-sdk.md` — bekannt sind "🍌 Nano Banana Pro",
- * "🍌 Nano Banana 2", "Imagen 4").
- *
- * Der genaue String für "Nano Banana Pro" ist real belegt, nicht nur
- * dokumentiert: `AvatarArchitectApp.tsx`s produktive Labs-Generierung
- * verwendet `'🍌 Nano Banana Pro'` als Vorgabewert und reicht ihn
- * unverändert als `modelDisplayName` an `Flow.generate.image()` durch
- * (`aiHelpers.ts#buildImageGenerationOptions`).
- *
- * "Imagen 4" bleibt katalogisiert, obwohl es im Modellwähler des
- * Flow-„Generieren"-Tabs am 2026-08-17 ausgegraut erschien (Screenshot,
- * nur "Nano Banana Pro"/"Nano Banana 2" wählbar) — das kann kontoabhängig
- * sein. Ein Aufruf schlägt dann mit der echten Flow-Fehlermeldung fehl,
- * statt einen stillen Fallback zu erzeugen (D-6.9.2-3).
- * `imagen-3.0-generate-001` bleibt bewusst draußen: Dafür ist kein
- * Flow-Display-Name dokumentiert oder belegt.
- */
-declare const FLOW_MODEL_DISPLAY_NAMES: Readonly<Record<string, string>>;
-/**
- * Ob dieser Host tatsächlich Zugang zu einem katalogisierten Bildmodell hat
- * (D-115) — die Vorgabe für `hasAccess` in `createFlowSzenenViewPort()`.
- */
-declare function flowImageProviderHasAccess(model: {
-    callable_model_id: string;
-}): boolean;
+/** Der Aufrufweg, den dieser Adapter bedient (D-132). */
+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
@@ -2643,10 +3131,28 @@ interface CreateFlowSzenenViewPortOptions {
     /** Ein fertiger Bildprovider statt des Flow-SDK — für Tests. */
     imageProvider?: ImageGenerationProviderPort;
     /**
-     * Ob dieser Host Zugang zu einem katalogisierten Bildmodell hat (D-115).
-     * Vorgabe: die bekannten Flow-Display-Namen (`flowImageProviderHasAccess`).
+     * Was dieser Host beim Bilderzeugen wirklich kann (D-132): seine Umgebung
+     * und seine Aufrufwege. **Keine** Modellliste — welche Modelle ausführbar
+     * sind, steht in den `execution_profiles` der Zielmodelle (D-130).
+     *
+     * Vorgabe: `flow` mit dem einen Weg, den `createFlowImageProvider()` bedient.
      */
-    imageProviderHasAccess?: ImageProviderAccessCheck;
+    imageCapability?: ImageHostCapability;
+    /**
+     * Der Arbeitskontext, über dessen Vererbungskette die Zielmodelle sichtbar
+     * werden — als **Getter**, nicht als Wert.
+     *
+     * Der Grund ist der Lebenszyklus: Der React-Host baut seinen Port je Kontext
+     * neu (`SzenenTab.tsx`), der Flow-Host hält einen Port über die ganze
+     * Sitzung. Ein Wert hier würde den Kontext einfrieren, und ein in einem
+     * Kontext veröffentlichtes Zielmodell wäre im Bildmodell-Wähler unsichtbar,
+     * obwohl der Editor es zeigt. Ein Getter liest ihn bei jeder Auskunft frisch,
+     * ohne den HF-Elementspeicher samt seiner Materialisierung (D-125) bei jedem
+     * Kontextwechsel wegzuwerfen.
+     *
+     * Vorgabe: der globale Kontext.
+     */
+    imageContextId?: () => string | null;
     /** Kennung je abgelegtem Batch-Bild. Ersetzbar, damit ein Test nicht würfelt. */
     newBatchImageId?: (generationBatchId: string, position: number) => string;
 }
@@ -2702,6 +3208,14 @@ interface PromptRunPersistencePort {
      * unverändert.
      */
     listForChain(chainId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
+    /**
+     * Die Läufe einer Szene, die direkt aus ihr entstanden sind — D-135.
+     *
+     * Ein solcher Lauf hat weder Shot-Version noch `chain_id`; ohne eigene
+     * Abfrage waere er nach einem Reload verschwunden, obwohl er bezahlt wurde
+     * (derselbe Befund wie D-102/A1 bei der Kette).
+     */
+    listForScene(sceneElementId: string): Promise<QueryResult<readonly PromptRunRecord[]>>;
 }
 /** Was der Eventlog-Adapter vom Kanal braucht — lesen und anhängen. */
 interface RunEventChannel {
@@ -2915,6 +3429,73 @@ interface CreateClientDerivationPortOptions {
 }
 declare function createClientDerivationPort(options: CreateClientDerivationPortOptions): SzenenDerivationPort;
 
+/** Der Lesezugriff, den diese Datei braucht — mehr nicht. */
+type VisibilityQueries = Pick<SzenenQueries, 'listElements' | 'getElement'>;
+/** Ein wählbares Zielmodell — der fachliche Key und woher er kommt. */
+interface SelectableTargetModel {
+    /** Der Wert, der gespeichert wird: `payload.key` (6.10 §6.4). */
+    key: string;
+    title: string;
+    elementId: string;
+    /** Die wirksame Version, aus der der Key stammt. Anzeige, nicht Speicherwert. */
+    versionId: string;
+    provider: string | null;
+    /**
+     * Die Ausfuehrungsprofile dieser wirksamen Version (D-130), roh aus der
+     * Payload. Leer, wenn das Zielmodell keines traegt — der Normalfall fuer ein
+     * reines Prompt-Ziel (D-133). Die Auswahl der wirklich ausfuehrbaren
+     * Kombinationen trifft `executableImageModels()`, nicht diese Datei.
+     */
+    executionProfiles: readonly unknown[];
+    /** Glied der Kette, auf dem der Treffer lag. `0` = Arbeitskontext. */
+    chainIndex: number;
+}
+/** Ein Kandidat, der bewusst **nicht** angeboten wird, samt Grund. */
+interface UnselectableTargetModel {
+    /** Der fachliche Key, der dadurch blockiert ist. */
+    key: string;
+    elementId: string;
+    title: string;
+    reason: 'fork' | 'ambiguous';
+    message: string;
+}
+interface TargetModelChoices {
+    selectable: readonly SelectableTargetModel[];
+    unselectable: readonly UnselectableTargetModel[];
+}
+/**
+ * Die Zielmodelle, die ein Autor wählen darf — **derselbe** Kandidatensatz, den
+ * `resolveTargetModelOver()` später akzeptiert.
+ *
+ * Diese Funktion bildet den Resolver Schritt für Schritt nach, und zwar
+ * absichtlich engmaschig: Der erste Anlauf bot „alle Keys aller Versionen" an,
+ * der zweite nur die wirksame Version je Element — beide Male wich das Ergebnis
+ * in einem Fall vom Resolver ab, und beide Male hat es ein Review gefunden.
+ *
+ * Die Regeln, alle drei aus `resolveTargetModelOver()`:
+ *
+ * 1. **Nur die wirksame Version** liefert den Key (`matchOf` arbeitet auf der
+ *    ausgewählten Version, nicht auf „irgendeiner veröffentlichten").
+ * 2. **Das erste Kettenglied mit einem Treffer entscheidet — und beendet die
+ *    Suche.** Auch dann, wenn der Treffer blockierend ist. Genau hier lag der
+ *    zweite Review-Befund: Ein lokaler Fork, dessen einer Head `imagen_4`
+ *    trägt, ist für `imagen_4` ein **Fork-Treffer** auf dem näheren Glied; der
+ *    Resolver endet dort mit `fork` und greift nicht auf ein globales
+ *    `imagen_4` durch. Ein Picker, der den Key nach dem Fork weiterlaufen
+ *    lässt, bietet einen Wert an, den die Auflösung ablehnt.
+ * 3. **Mehrere Treffer auf demselben Glied sind mehrdeutig** — auch wenn einer
+ *    davon ein Fork ist (`active.length > 1`). Es wird keiner gewählt.
+ *
+ * Blockierte Keys verschwinden nicht stillschweigend: Sie stehen mit Grund in
+ * `unselectable`, sonst sieht ein Zielmodell mit offener Auswahl aus wie ein
+ * nicht vorhandenes.
+ *
+ * Stillgelegte Elemente beenden die Kette **nicht** — der Resolver führt sie als
+ * `shadowedRetired` und sucht weiter (E-7). Sie erscheinen hier gar nicht, weil
+ * `listElements` sie ohne `includeRetired` nicht liefert.
+ */
+declare function selectableTargetModels(queries: VisibilityQueries, contextChain: readonly (string | null)[]): Promise<QueryResult<TargetModelChoices>>;
+
 interface CreateHfImageBatchPersistenceOptions {
     namespace: string;
     token: string;
@@ -3023,4 +3604,4 @@ interface SzenenViewProps {
 }
 declare const SzenenView: React__default.FC<SzenenViewProps>;
 
-export { type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, CATALOGUE_TYPES, type CallableImageModel, CapabilityAnchorError, type CapabilityFlag, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClientDerivationChannel, type ClientDerivationStore, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateMemoryViewPortOptions, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, type ElementEvent, type ElementEventChannel, ElementSnapshot, type ElementStoreState, type ExistingSzenenItem, FLOW_MODEL_DISPLAY_NAMES, type FlowGenerateImage, type FlowGenerateImageParams, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSuccess, type FrozenChainNode, type GeneratedImage, type HfImageStore, type HfImageStoreOptions, type IdFactory, type ImageBatchPersistedImage, type ImageBatchPersistedPayload, type ImageGenerationBatchPersistence, type ImageGenerationCapability, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, ImageProvenance, type ImageProviderAccessCheck, type ImageProviderInput, type ImportBatchImageInput, type ImportBatchInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LibraryImage, type NodeContribution, NotDerivable, type Notice, type NoticeTone, type PromptBatchImageRef, type PromptImageBatch, type PromptRunOutcome, type PromptRunOutput, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, type ReducerFinding, ReferenceResolver, type RendererInput, type ResolveFailure, type ResolveResult, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_EVENT_PREFIX, SZENEN_EVENT_TYPES, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, SchemaError, type StartImageGenerationInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UnusableProposal, type VersionMedium, type VisibilityNode, areasFor, batchesForPromptRun, bildPfad, buildSystemInstruction, buildUserPrompt, callOptional, callableImageModelFor, capabilitiesOf, capabilityForTargetModel, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, collectImageBatches, collectImageGenerationOrders, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, differentialSteps, draftRevisionOf, findImageBatch, findImageGenerationOrder, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, flowImageProviderHasAccess, freezeDraftChain, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, logRevisionOf, mergeSzenenBatchOrigin, noticeFor, ordersForPromptRun, parseRunResponse, preferredHeadRevisionOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveShot, resolveShotPayload, roundOfRun, runPromptDerivation, runStoreDifferential, scopeOfPath, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };
+export { type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, CATALOGUE_TYPES, CapabilityAnchorError, type CapabilityFlag, type CapabilityFlagName, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClientDerivationChannel, type ClientDerivationStore, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateMemoryViewPortOptions, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, type ElementEvent, type ElementEventChannel, ElementSnapshot, type ElementStoreState, type 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, type GeneratedImage, type HfImageStore, type HfImageStoreOptions, type IdFactory, type ImageBatchPersistedImage, type ImageBatchPersistedPayload, 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 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 LibraryImage, type NodeContribution, NotDerivable, type Notice, type NoticeTone, PROMPT_RULE_EFFECT, type PromptBatchImageRef, type PromptDiagnostic, type PromptEffect, type PromptImageBatch, type PromptRunOutcome, type PromptRunOutput, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, type ReducerFinding, ReferenceResolver, type RendererInput, type ResolveFailure, type ResolveResult, type ResolveScenePayloadInput, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_EVENT_PREFIX, SZENEN_EVENT_TYPES, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, SchemaError, type SelectableTargetModel, type StartImageGenerationInput, type StartRunFromSceneInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, type UnselectableTargetModel, UnusableProposal, type VersionMedium, type VisibilityNode, areasFor, batchesForPromptRun, bildPfad, buildSystemInstruction, 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, collectImageBatches, collectImageGenerationOrders, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, describableContent, diagnosticOfFinding, diagnosticOfSchemaError, differentialSteps, draftRevisionOf, executableImageModels, findExecutableImageModel, findImageBatch, findImageGenerationOrder, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, freezeDraftChain, freezeSceneWorkingState, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, logRevisionOf, mergeSzenenBatchOrigin, noticeFor, ordersForPromptRun, parseRunResponse, preferredHeadRevisionOf, promptDiagnosticsOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveScenePayload, resolveShot, resolveShotPayload, roundOfRun, rulesWithoutPromptEffect, runPromptDerivation, runStoreDifferential, sceneOnlyCapabilities, scopeOfPath, selectableTargetModels, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };