@rslsp1/fa-app-tools 3.0.0 → 5.0.0

package/dist/szenen.d.ts

@@ -1,4 +1,4 @@
-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-DNggXiZl.js';
+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-DNggXiZl.js';
 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-DNggXiZl.js';
 import { T as TextGenerationPort, Q as QueryResult, C as CommandResult } from './contracts-DdYOMBl9.js';
 export { S as SIMULATION_PROVIDER, c as TextGenerationRequest, d as TextGenerationResult, g as createFakeTextGenerationPort, h as createSimulationTextGenerationPort, s as simulatedAnswerFor } from './contracts-DdYOMBl9.js';
@@ -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.
@@ -1727,7 +2000,22 @@ interface ImageExecutionProfile {
  */
 interface ImageHostCapability {
     environment_id: string;
-    execution_paths: readonly 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;
 }
 /** Ein Zielmodell, so wie die Auswahl es braucht. */
 interface ExecutionTargetModel {
@@ -1792,6 +2080,21 @@ interface ImageModelChoice {
  * zeigen soll — eine Regel, eine Stelle.
  */
 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.
  *
@@ -2011,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.
@@ -2278,7 +2608,7 @@ interface DerivationPolicyOption {
     inputModes: readonly DerivationInputMode[];
     produces: readonly DerivableType[];
 }
-/** Ein wählbares Bild aus dem Bestand. */
+/** Ein wählbares Bild aus dem Bestand — ein konkreter Galerieeintrag. */
 interface LibraryImage {
     /**
      * Die **HF-Bildkennung** (D-93) — der Wert, unter dem das Bild als
@@ -2291,9 +2621,45 @@ interface LibraryImage {
     mediaRef: string;
     title: string;
     mimeType: string;
-    /** Anzeigbare Quelle für die Kachel, sofern der Host eine liefert. */
+    /**
+     * Anzeigbare Quelle für die Kachel, sofern der Host sie **kostenlos** kennt.
+     *
+     * React kennt sie: Der Server liefert seinen Thumbnail-Pfad ohnehin mit der
+     * Liste. Flow kennt sie nicht — dort liegt jedes Bild als Datei auf HF, und
+     * eine Quelle entsteht erst durch einen Download. Deshalb bleibt das Feld
+     * optional und wird **nicht** durch einen eifrigen Ladelauf gefüllt; wer
+     * keine mitbringt, bietet stattdessen `loadPreview` an.
+     */
     thumbUrl?: string | null;
 }
+/**
+ * Ein **Werk** des Bestands: die fachliche Gruppe über seinen Bildern.
+ *
+ * Warum das die Auskunftsform ist und nicht die flache Bildliste: Beide Hosts
+ * kennen die Gruppe längst — React als `user_library`-Zeile mit
+ * `metadata.gallery`, Flow über dieselbe Locator-Konvention (D-118), die der
+ * Abgleich beim Hochladen vergibt. Die Auskunft hat sie bis zum 2026-08-22 nur
+ * verworfen, bevor die Ansicht sie sehen konnte: Ein Item mit vierzehn Bildern
+ * erschien als vierzehn gleichrangige Kacheln, und `limit: 8` lieferte
+ * einundzwanzig davon (nachgemessen auf dev). Die Auswahl war damit nicht die
+ * Auswahl eines Werkes, sondern eine ungeordnete Frameliste.
+ */
+interface LibraryImageItem {
+    /**
+     * Die **autoritative** Identität des Werkes bei diesem Host — die
+     * `item_id` in React, dieselbe Kennung als Locator-Stamm in Flow.
+     *
+     * Ausdrücklich keine zweite Bildidentität und keine aus dem Prompt geratene
+     * Gruppe: Zwei Werke mit demselben Prompt bleiben zwei Werke.
+     */
+    itemRef: string;
+    title: string;
+    /**
+     * Die Bilder des Werkes in stabiler Reihenfolge. Jedes trägt seinen
+     * vorhandenen auflösbaren `mediaRef` — die Gruppierung ändert daran nichts.
+     */
+    images: readonly LibraryImage[];
+}
 /**
  * Bilder wählen, auflösen und ablegen — **optional als Ganzes** (D-94).
  *
@@ -2305,11 +2671,29 @@ interface LibraryImage {
  * ein Library-Item mit dem Tag `hf-sync` an, das der bestehende Sync trägt.
  */
 interface SzenenImageLibraryPort {
-    /** Wählbare Bilder, neueste zuerst. */
-    listImages(query?: {
+    /**
+     * Wählbare **Werke**, neueste zuerst; `search` und `limit` gelten auf
+     * Item-Ebene.
+     *
+     * `limit: 60` heisst also sechzig Werke, nicht sechzig Bilder — sonst
+     * verdrängte ein einziges mehrbildiges Werk den ganzen übrigen Bestand.
+     */
+    listItems(query?: {
         search?: string;
         limit?: number;
-    }): Promise<QueryResult<readonly LibraryImage[]>>;
+    }): Promise<QueryResult<readonly LibraryImageItem[]>>;
+    /**
+     * Eine anzeigbare Quelle für **ein** Bild nachladen — `<img src>`-fähig,
+     * also eine URL oder ein `data:`-URI.
+     *
+     * Optional wie alles andere hier (R11): Ein Host, dessen Liste `thumbUrl`
+     * schon mitbringt, braucht das nicht und lässt es weg. Ein Host, der seine
+     * Bilder erst holen muss, bietet es an — und die Ansicht ruft es dann nur
+     * für die Kacheln, die sie wirklich zeigt. Genau daran hängt, dass sich der
+     * Wähler nicht beim Öffnen sechzig Vollauflösungen von HF zieht; die Dateien
+     * dort sind real 3–22 MB gross.
+     */
+    loadPreview?(mediaRef: string): Promise<QueryResult<string>>;
     /**
      * Base64 **ohne** `data:`-Präfix und der MIME-Typ — die Modelleingabe.
      *
@@ -2627,6 +3011,23 @@ interface HfImageStore {
     putWithId(id: string, base64: string, mimeType: string, titel?: string): Promise<void>;
     /** Löst eine Kennung auf. `mimeType` ist ein Hinweis, kein Zwang. */
     resolve(id: string, mimeType?: string | null): Promise<AufgeloestesBild>;
+    /**
+     * Eine **anzeigbare** Fassung als `data:`-URI — für die Kachel, nicht für das
+     * Modell.
+     *
+     * Warum getrennt von `resolve()`: Der Bestand kennt zu vielen Bildern ein
+     * fertiges Vorschaubild unter `thumbs/<filename>` (rund 25 KB gegenüber
+     * 3–22 MB beim Original, nachgemessen im echten Bestand am 2026-08-22).
+     * `resolve()` darf es nicht nehmen — es füttert das Modell, und ein
+     * heruntergerechnetes Bild wäre dort eine andere Eingabe. Die Kachel darf es
+     * nicht nur, sie muss: Ein Wähler, der sechzig Originale zieht, ist die
+     * Download-Lawine, die §7.1 des Auftrags verbietet.
+     *
+     * Kennt der Bestand keins, fällt diese Auskunft auf `resolve()` zurück —
+     * denselben Weg mit demselben Sitzungsspeicher und demselben Retry, nicht
+     * einen zweiten daneben.
+     */
+    preview(id: string): Promise<string>;
     /** Der aktuelle Bestand — Schnappschuss plus die Ereignisse danach. */
     bestand(): Promise<HFStateSnapshot>;
 }
@@ -2663,6 +3064,59 @@ interface CreateHfImageLibraryOptions {
 }
 declare function createHfImageLibrary(options: CreateHfImageLibraryOptions): SzenenImageLibraryPort;
 
+interface LocatorTeile {
+    /** Der Stamm — die `item_id` des Werkes, oder der ganze Locator. */
+    stamm: string;
+    /** Die Position innerhalb der Galerie; `null` bei einem Einbild-Locator. */
+    position: number | null;
+}
+/** Zerlegt einen Locator in Werk und Position, ohne etwas zu raten. */
+declare function locatorTeile(mediaRef: string): LocatorTeile;
+/** Ein Bild, wie es aus dem Bestand kommt, plus das, was die Ordnung braucht. */
+interface GruppierbaresBild extends LibraryImage {
+    /**
+     * Der Zeitpunkt, an dem das Bild in den Bestand kam. Er ordnet die **Werke**
+     * untereinander; innerhalb eines Werkes ordnet die Locator-Position, damit
+     * „Bild 3" morgen dasselbe Bild ist wie heute.
+     */
+    timestamp?: number;
+    /**
+     * Ein menschenlesbarer Werktitel, falls der Bestand einen kennt. Fehlt er,
+     * gilt der Titel des ersten Bildes — und fehlt auch der, die Kennung. Ein
+     * erfundener Name wäre schlechter als eine ehrliche UUID.
+     */
+    itemTitle?: string | null;
+}
+/**
+ * Gruppiert Bilder zu Werken.
+ *
+ * Reihenfolge: Werke nach ihrem jüngsten Bild absteigend — wer ein Referenzbild
+ * sucht, sucht meist ein frisches. Bilder innerhalb eines Werkes nach ihrer
+ * Locator-Position aufsteigend; die ist stabil, der Zeitstempel wäre es nicht.
+ */
+declare function gruppiereZuItems(bilder: readonly GruppierbaresBild[]): readonly LibraryImageItem[];
+
+interface VorschauLauf {
+    /** Wird `true`, sobald der Aufrufer das Ergebnis nicht mehr braucht. */
+    abgebrochen: boolean;
+}
+interface LadeVorschauenOptionen {
+    /** Wie viele Anfragen gleichzeitig laufen dürfen. */
+    parallel?: number;
+    /** Ob eine Quelle schon vorliegt — dann wird sie nicht erneut geholt. */
+    hat?: (mediaRef: string) => boolean;
+    lauf?: VorschauLauf;
+}
+/**
+ * Lädt Vorschauen für die übergebenen Kennungen und meldet jede einzeln, sobald
+ * sie da ist.
+ *
+ * Ein Fehlschlag beendet den Lauf **nicht**: Eine Kachel ohne Bild ist besser
+ * 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>;
+
 interface CreateMemoryViewPortOptions {
     /**
      * Ob der Port Items anbietet. `false` bildet Flow-Pure nach: das Feld fehlt
@@ -2680,8 +3134,24 @@ interface CreateMemoryViewPortOptions {
      * Upload, und ein Folgelauf ohne Bild wird mit Grund abgelehnt.
      */
     imageLibrary?: boolean;
-    /** Vorbelegte Bilder des Bestands. */
+    /**
+     * Vorbelegte Bilder des Bestands — jedes für sich ein **Einbild-Werk**.
+     *
+     * Das ist der Normalfall eines Bestands und bleibt die knappe Schreibweise
+     * für Tests, die die Gruppierung gar nicht brauchen. Mehrbildige Werke gehen
+     * über `imageItems`.
+     */
     images?: readonly LibraryImage[];
+    /** Vorbelegte **Werke** mit ihren Galerien. */
+    imageItems?: readonly LibraryImageItem[];
+    /**
+     * Ob dieser Bestand seine Vorschauen erst auf Anforderung liefert.
+     *
+     * `true` bildet den Flow-Host ab: `thumbUrl` bleibt leer, und die Ansicht
+     * muss `loadPreview()` benutzen. Vorgabe ist der React-Fall — die Liste
+     * bringt ihre Quellen mit, und `loadPreview` fehlt am Port (R11).
+     */
+    imagePreviewLazy?: boolean;
     /**
      * Ob der Port die Rekonstruktion anbietet (Stufe 6.5).
      *
@@ -2878,6 +3348,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 {
@@ -3266,4 +3744,4 @@ interface SzenenViewProps {
 }
 declare const SzenenView: React__default.FC<SzenenViewProps>;
 
-export { type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, CATALOGUE_TYPES, 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 ExecutableImageModel, type ExecutionTargetModel, type ExistingSzenenItem, FLOW_EXECUTION_PATH, 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 ImageExecutionProfile, 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, 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 SelectableTargetModel, 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, type UnselectableTargetModel, UnusableProposal, type VersionMedium, type VisibilityNode, areasFor, batchesForPromptRun, bildPfad, buildSystemInstruction, buildUserPrompt, callOptional, capabilitiesOf, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkImageExecutionProfile, 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, differentialSteps, draftRevisionOf, executableImageModels, findExecutableImageModel, findImageBatch, findImageGenerationOrder, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, freezeDraftChain, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, logRevisionOf, mergeSzenenBatchOrigin, noticeFor, ordersForPromptRun, parseRunResponse, preferredHeadRevisionOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveShot, resolveShotPayload, roundOfRun, runPromptDerivation, runStoreDifferential, scopeOfPath, selectableTargetModels, 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 GruppierbaresBild, 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 LibraryImageItem, 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, gruppiereZuItems, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, ladeVorschauen, locatorTeile, 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 };