@rslsp1/fa-app-tools 9.0.0 → 9.4.4

package/dist/szenen.d.ts

@@ -1,276 +1,11 @@
-import { I as ElementSnapshot, Z as PublishFinding, ac as SchemaError, Y as PublishCheckResult, aj as SzenenElementType, a2 as ReferenceResolver, ap as TargetModelResolution, 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 { J as ElementEvent, ad as PublishFinding, av as SchemaError, ac as PublishCheckResult, aC as SzenenElementType, aj as ReferenceResolver, aJ as TargetModelResolution, a3 as PreferredHeadResolution, a0 as PageRequest, X as LibraryTagRef, a8 as PromptRunAnnotation, $ as Page, y as DerivationInputMode, U as ImageProvenance, u as DerivationFailure, p as DerivableType, Y as NotDerivable, r as DerivationConflict, w as DerivationFollowUp, F as DraftChainMeta, s as DerivationDiagnostic, q as DerivationAssessment, j as ContextChainPort, c as AuthoritativeSzenenStore, aB as SzenenElementStore, x as DerivationImage, aE as SzenenQueries, aA as SzenenCommands, aL as UnusableProposal, I as ElementAnnotation } from './storeContract-gc2dxews.js';
+export { A as ALL_PUBLISH_RULES, a as AngezeigterTag, b as AnnotateRunsOptions, C as CHAIN_EDGES, d as CHAIN_LINK_FIELDS, e as CatalogueEntry, f as ChainLinkField, g as ChainTarget, h as ChainVerdict, i as CompiledSchemas, k as ContractCheck, l as ContractCheckResult, m as ContractRunResult, n as ContractViolation, o as CreateElementInput, D as DERIVABLE_TYPES, t as DerivationEnvelope, v as DerivationFailureClass, z as DerivationPolicyPayload, B as DerivationProposal, E as DraftChainLink, G as DraftFork, H as DraftRecord, K as ElementListFilter, L as ElementMetadata, M as ElementRecord, N as ElementSnapshot, O as ElementStoreContractHarness, P as ElementStoreState, Q as ElementVersionValidation, R as FindingSeverity, S as ImageBatchPersistedImage, T as ImageBatchPersistedPayload, V as KEINE_BILDER, W as LOAD_MORE_PAGE_SIZE, Z as OptionalCommand, _ as PROBE_VERSION_ID, a1 as ParentRelation, a2 as PreferredHeadOutcome, a4 as PreferredHeadSelection, a5 as PreferredHeadSource, a6 as ProjectionState, a7 as ProjectionStatus, a9 as PromptRunPreviewImage, aa as PromptRunTagsSetPayload, ab as PublishCheckInput, ae as PublishRejected, af as PublishVersionInput, ag as PublishedVersion, ah as REFERENCE_FIELD, ai as ReducerFinding, ak as ResolvePreferredHeadOptions, al as ResolvedVersion, am as ReviseMetadataInput, an as STYLE_PAYLOAD, ao as STYLE_PAYLOAD_V2, ap as SZENEN_ELEMENT_TYPES, aq as SZENEN_EVENT_PREFIX, ar as SZENEN_EVENT_TYPES, as as SceneDerivationInput, at as SceneDerivationOutcome, au as SceneDerivationOutput, aw as SchemaValidationResult, ax as SetPreferredHeadInput, ay as StoreAuthority, az as SzenenCommandResult, aD as SzenenProjection, aF as TagHerkunft, aG as TargetModelCandidate, aH as TargetModelQueries, aI as TargetModelQuery, aK as UnsupportedSchemaError, aM as VersionDag, aN as VersionDagError, aO as VersionNode, aP as VersionParentLink, aQ as WriteConflict, aR as WriteDraftInput, aS as annotateElementsFromEvents, aT as annotateRunsFromEvents, aU as assessDerivationResponse, aV as buildDerivationSystemInstruction, aW as buildDerivationUserPrompt, aX as buildVersionDag, aY as checkChainTargets, aZ as checkDerivationResponse, a_ as checkDraftChainMeta, a$ as collectPromptRunTags, b0 as collectVersionRefs, b1 as compileSchemas, b2 as createSimulationSceneDerivationPort, b3 as describeTargetModelFailure, b4 as draftRevisionOf, b5 as elementStoreContractChecks, b6 as formatSchemaErrors, b7 as getSzenenSchemas, b8 as isOk, b9 as isProjectionCurrent, ba as labelsOf, bb as linkFor, bc as listElementsPageOver, bd as logRevisionOf, be as mergeRunTags, bf as pageOf, bg as pageRequestFrom, bh as parseDerivationResponse, bi as preferredHeadRevisionOf, bj as preferredVersionId, bk as promptRunTagsOf, bl as reduceElementEvents, bm as resolvePreferredHead, bn as resolveTargetModelOver, bo as resolverFromQueries, bp as runElementStoreContract, bq as runPublishChecks, br as runSceneDerivation, bs as showChain, bt as tagRefsAus, bu as validateAgainst, bv as validateDerivationInput, bw as validateElementVersion, bx as validatePayload, by as withReference } from './storeContract-gc2dxews.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';
 import { g as HFStateSnapshot, F as FlowGenerateText } from './hfEventTypes-fAdA-0A9.js';
 export { C as CreateFlowTextGenerationPortOptions, r as createFlowTextGenerationPort } from './hfEventTypes-fAdA-0A9.js';
 import React__default from 'react';
 
-/** Präfix aller Events dieser Domain im gemeinsamen HF-Event-Kanal. */
-declare const SZENEN_EVENT_PREFIX = "szenen.";
-declare const SZENEN_EVENT_TYPES: {
-    readonly elementCreated: "szenen.element_created";
-    readonly elementRetired: "szenen.element_retired";
-    readonly metadataRevised: "szenen.element_metadata_revised";
-    readonly draftWritten: "szenen.element_draft_written";
-    readonly versionPublished: "szenen.element_version_published";
-    readonly preferredHeadSelected: "szenen.element_preferred_head_selected";
-    /**
-     * Ein Prompt-Ableitungslauf — Stufe 3, S6 (E-3b).
-     *
-     * Ein Lauf ist **kein Element**: keine Version, kein DAG, nicht
-     * referenzierbar. Er liegt trotzdem im selben autoritativen Log, weil er
-     * append-only und unveränderlich ist — genau die Form, die ein Ereignislog
-     * nativ trägt — und weil MySQL sonst zu einem zweiten fachlichen Speicher
-     * würde, den D-62 abgeschafft hat.
-     *
-     * Der Elementreducer ignoriert diesen Typ (`default:`-Zweig); die Läufe
-     * werden mit `collectPromptRuns` gelesen.
-     */
-    readonly promptRunRecorded: "szenen.prompt_run_recorded";
-    /**
-     * Ein Szenen-Rekonstruktionslauf — Stufe 6.5 (D-71).
-     *
-     * Derselbe Bauplan und dieselbe Begründung wie beim Prompt-Lauf: append-only,
-     * unveränderlich, **kein Element** — keine Version, kein DAG, nicht
-     * referenzierbar. Er liegt im autoritativen Log, weil er genau die Form hat,
-     * die ein Ereignislog nativ trägt.
-     *
-     * Bewusst ein zweiter Lauftyp und **kein** gemeinsamer: Ein Prompt-Lauf geht
-     * von einer veröffentlichten Shot-Version aus, ein Rekonstruktionslauf von
-     * einer Referenz, die noch zu gar keinem Element gehört. Sie in einen Typ zu
-     * zwingen hieße, beiden ihre Herkunftsfelder zu nehmen.
-     *
-     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig).
-     */
-    readonly sceneDerivationRecorded: "szenen.scene_derivation_recorded";
-    /**
-     * Ein ausdrücklich ausgelöster Lauf gegen den **echten** Provider.
-     *
-     * Er kostet Geld und wird deshalb nie beiläufig gefahren. Das Ereignis hält
-     * fest, was tatsächlich bezahlt wurde: wie viele Modellaufrufe, mit welchem
-     * Ausgang, in welcher Umgebung und von wem ausgelöst.
-     *
-     * Es ersetzt **nicht** die einzelnen Läufe — die werden regulär als
-     * `prompt_run_recorded` bzw. `scene_derivation_recorded` protokolliert. Es
-     * ist die Klammer darüber und der Grund, warum jemand später nachlesen kann,
-     * ob der Durchstich stattgefunden hat, ohne ihn erneut zu bezahlen.
-     */
-    readonly providerCheckRecorded: "szenen.provider_check_recorded";
-    /**
-     * Eine geprüfte Arbeitsfassung eines fehlgeschlagenen Rekonstruktionslaufs —
-     * Stufe 6.6 (D-99).
-     *
-     * Sie ist **kein Lauf**: kein Provideraufruf, keine Kosten, kein Zielmodell.
-     * Sie ist die lokal geprüfte Korrektur eines bereits bezahlten Ergebnisses
-     * und zeigt über `run_id` auf ihren Ursprung. Der `raw_output` jenes Laufs
-     * bleibt unangetastet — deshalb ein eigenes Ereignis statt einer Änderung am
-     * bestehenden, das es ohnehin nicht geben dürfte (D-71).
-     *
-     * Mehrere Rettungen zum selben Lauf sind zulässig und erwartet: Jede
-     * Korrekturrunde ist nachvollziehbare Arbeit, kein Update der vorigen.
-     *
-     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig).
-     */
-    readonly sceneDerivationRecoveryRecorded: "szenen.scene_derivation_recovery_recorded";
-    /**
-     * Ein bezahlter Bildgenerierungsauftrag beginnt — Stufe 6.7 (D-119).
-     *
-     * Append-only wie jedes andere Ereignis dieser Domain, geschrieben **vor**
-     * dem Provideraufruf. Es traegt **keine Bilddaten** — nur die Kennung, mit
-     * der die spaetere kanonische Batch-Persistenz (`saveGeneratedAssetBatch`,
-     * Teil C) wiedergefunden wird. Ein Crash zwischen diesem Ereignis und
-     * `imageGenerationFinished` loescht den Auftrag nicht: Er bleibt lesbar,
-     * ohne dass irgendein automatischer Retry darauf reagiert.
-     *
-     * Gilt nur fuer `generated_in_app` — ein externer Import (D-108/D-117)
-     * ruft keinen Provider und braucht deshalb kein `started`; sein Nachweis
-     * ist das gespeicherte Library-Item selbst.
-     *
-     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig); gelesen
-     * wird mit `collectImageGenerationOrders`.
-     */
-    readonly imageGenerationStarted: "szenen.image_generation_started";
-    /**
-     * Derselbe Bildgenerierungsauftrag endet — Stufe 6.7 (D-119).
-     *
-     * Erscheint erst **nach** der kanonischen Batch-Persistenz: Ein technischer
-     * Fehler zwischen Provideraufruf und Speichern darf nie als `succeeded`
-     * protokolliert werden, nur weil der Provider geantwortet hat. Traegt
-     * ebenfalls keine Bilddaten — nur Status, Zaehlung und die Item-Kennung,
-     * falls eine entstand.
-     */
-    readonly imageGenerationFinished: "szenen.image_generation_finished";
-    /**
-     * Ein Bild-Batch ist kanonisch gespeichert — Stufe 6.9.2, Gate D
-     * (D-6.9.2-6).
-     *
-     * Erscheint erst, **nachdem** jedes Bild des Batches im Bildbestand liegt
-     * (`hfUploadImage` + `image_added`, dieselbe Reihenfolge wie
-     * `hfImageLibrary.putImage`) — kein Bild gilt als vorhanden, bevor sein
-     * Upload bestätigt ist (R3). Trägt bewusst **keine Bilddaten**, nur den
-     * vollständigen Metadatennachweis, den `listBatchesForPromptRun()` /
-     * `getBatch()` ohne MySQL rekonstruieren können müssen: `item_id`,
-     * `prompt_run_id`, `generation_batch_id`, `source_kind`, je Bild
-     * `position`, `media_ref`, `asset_id`, `model`, `seed`, `width`/`height`.
-     *
-     * Additiv wie jedes Ereignis dieser Domain: ein zweiter Batch desselben
-     * Laufs ist ein **weiteres** Ereignis mit derselben `item_id`, nicht eine
-     * Änderung am ersten (D-113/D-121 — ein Lauf bleibt ein Item). Gilt für
-     * `generated_in_app` **und** `external_import` — nur `source_kind`
-     * unterscheidet die beiden Schreiber (D-116/D-117/D-120).
-     *
-     * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig); gelesen
-     * wird mit `collectImageBatches` (`imageBatchStore.ts`).
-     */
-    readonly imageBatchPersisted: "szenen.image_batch_persisted";
-    /**
-     * Ein vorbereiteter Promptvorgang — der Durchstich „Szene → ChatGPT → Lauf".
-     *
-     * Der bestehende Promptpfad ruft das Modell selbst
-     * (`runPromptDerivation()`); ein aufrufendes Chatmodell formuliert dagegen
-     * **zwischen** zwei Werkzeugaufrufen. Damit zerfaellt der eine Vorgang in
-     * zwei, und der zweite braucht genau den Stand, den der erste eingefroren
-     * hat — sonst loeste der Abschluss die inzwischen geaenderte Szene neu auf
-     * und der Lauf behauptete eine Herkunft, die er nicht hat (D-22).
-     *
-     * Deshalb ein eigenes Ereignis und **kein** fluechtiger Prozesszustand: Der
-     * Snapshot ueberlebt Neustart, Hostwechsel und Sitzungsende, weil er im
-     * selben autoritativen Log liegt wie der Lauf, der daraus entsteht.
-     *
-     * Der Elementreducer ignoriert diesen Typ (`default:`-Zweig); gelesen wird
-     * mit `collectPromptOperations` (`scenePromptOperation.ts`).
-     */
-    readonly promptOperationPrepared: "szenen.prompt_operation_prepared";
-    /**
-     * Ein Bildauftrag wartet auf einen ausfuehrenden Flow-Host.
-     *
-     * Die vorhandene Auftragshistorie (`imageGenerationStarted`) beginnt
-     * **unmittelbar vor** dem Provideraufruf und kennt deshalb keinen wartenden
-     * Auftrag. Genau der entsteht hier: Ein Chatmodell beauftragt ueber MCP ein
-     * Bild, der Auftrag wird dauerhaft abgelegt, und der Werkzeugaufruf endet
-     * sofort mit seiner Kennung — er haelt keine Antwort minutenlang offen.
-     *
-     * Traegt **keinen** Prompt: Der steht im referenzierten Lauf, und ihn hier
-     * zu kopieren waere eine zweite Wahrheit ueber denselben eingefrorenen Text
-     * (D-103).
-     */
-    readonly imageJobRequested: "szenen.image_job_requested";
-    /**
-     * Ein Flow-Host beansprucht einen wartenden Bildauftrag.
-     *
-     * Ein append-only Log kennt kein Lock: Zwei Tabs koennen beide anhaengen.
-     * Deshalb ist die Uebernahme **nicht** der Append, sondern das Ergebnis
-     * einer deterministischen Schiedsregel darueber (`winningClaimOf`) — der
-     * erste Anspruch in Logreihenfolge gewinnt, und jeder Host liest nach
-     * seinem Append erneut, bevor er einen bezahlten Provideraufruf startet.
-     * Ein unterlegener Anspruch bleibt sichtbar stehen; er wird nicht geloescht,
-     * weil das Log das nicht kann und weil der Versuch ein Beleg ist.
-     */
-    readonly imageJobClaimed: "szenen.image_job_claimed";
-    /**
-     * Der Bildauftrag ist erledigt — mit dem Ausgang, den der Host gesehen hat.
-     *
-     * Getrennt von `imageGenerationFinished`: Jenes gehoert zum bezahlten
-     * Provideraufruf, dieses zur Zustellung. Ein Auftrag kann fehlschlagen,
-     * **bevor** ein Provider gerufen wurde (abgelehntes Profil), und dann gibt
-     * es kein `imageGenerationFinished`, das den Wartenden erloesen wuerde.
-     */
-    readonly imageJobSettled: "szenen.image_job_settled";
-};
-/** Ein einzelnes Bild innerhalb von `ImageBatchPersistedPayload` (D-6.9.2-6). */
-interface ImageBatchPersistedImage {
-    position: number;
-    /** Im aktuellen Host auflösbarer Locator — hier die HF-Bildkennung (D-93). */
-    media_ref: string;
-    /** Fachlich stabile Identität, soweit bekannt — hier identisch mit `media_ref` (D-118). */
-    asset_id?: string;
-    /**
-     * Der **bestätigte** MIME-Typ der abgelegten Datei — Review 2026-08-18 §5 P2.
-     *
-     * Additiv nachgetragen, weil der Batch ihn beim Schreiben kennt, ihn aber
-     * nicht führte: Der Lesepfad musste die Dateiendung deshalb über zwei
-     * Varianten erraten. Geraten wird nichts mehr — der Typ stammt aus den
-     * tatsächlichen Bildbytes (`typAusBytes`), nicht aus einer Annahme, und
-     * bestimmt den Pfad `images/<id>.<ext>`, unter dem die Datei liegt.
-     *
-     * Optional, weil ältere Ereignisse ihn nicht tragen; für die fällt der
-     * Lesepfad auf den Bestandseintrag zurück.
-     */
-    mime_type?: string | null;
-    model?: string | null;
-    /** Nur gesetzt, wenn der Provider ihn tatsächlich zurückliefert (D-107). */
-    seed?: number | null;
-    width?: number | null;
-    height?: number | null;
-}
-/** Nutzlast von `imageBatchPersisted` — geschrieben nach bestätigtem Bild-Upload. */
-interface ImageBatchPersistedPayload {
-    item_id: string;
-    prompt_run_id: string;
-    generation_batch_id: string;
-    source_kind: 'generated_in_app' | 'external_import';
-    title: string;
-    images: readonly ImageBatchPersistedImage[];
-    created_at: string;
-}
-/**
- * Ein Event, wie der Reducer es sieht.
- *
- * Nur `type`, `payload` und `clientId` sind fachlich. `ts` dient allein der
- * **Lesereihenfolge** des Logs und darf nie eine fachliche Vorrangfrage
- * entscheiden — sonst wäre es `MAX(ts)` durch die Hintertür (§2.5, R-3).
- */
-interface ElementEvent<P = unknown> {
-    type: string;
-    payload: P;
-    clientId: string;
-    ts: number;
-}
-/** Ein Befund beim Falten: etwas ist widersprüchlich, aber der Zustand bleibt lesbar. */
-interface ReducerFinding {
-    code: 'unbekanntes_element' | 'version_doppelt' | 'version_veraendert' | 'draft_fork' | 'metadata_fork' | 'preferred_head_fork' | 'element_doppelt';
-    element_id: string;
-    message: string;
-}
-/** Abgeleiteter Zustand über alle Elemente. */
-interface ElementStoreState {
-    elements: ReadonlyMap<string, ElementSnapshot>;
-    findings: readonly ReducerFinding[];
-}
-/**
- * Faltet den Event-Log zum Elementzustand.
- *
- * Der Reducer ist rein: gleiche Events, gleicher Zustand — unabhängig von der
- * Eingabereihenfolge.
- *
- * @param events Alle bekannten Szenen-Events; fremde Typen werden übergangen.
- */
-declare function reduceElementEvents(events: readonly ElementEvent[]): ElementStoreState;
-/** Aktuelle Revision des Entwurfs. `0`, wenn keiner existiert. */
-declare function draftRevisionOf(snapshot: ElementSnapshot | null | undefined): number;
-/**
- * Quellrevision eines gelesenen Event-Logs (D-62 §2.4, D-63 §1.1.2).
- *
- * Die Projektion darf sich nur dann `current` nennen, wenn sie belegen kann,
- * **bis wohin** sie reicht. Dieser Beleg ist die Quellrevision, und sie muss
- * zwei Eigenschaften haben: aus dem Log allein berechenbar (sonst wäre sie eine
- * zweite Buchführung) und für zwei verschiedene Logstände verschieden.
- *
- * Beides leistet `Anzahl@größter-Zeitstempel`. Der Log ist append-only — es
- * verschwindet nie ein Event —, also wächst die Anzahl bei jedem Schreibvorgang.
- * Der Zeitstempel kommt dazu, weil er den Stand für einen Menschen lesbar macht;
- * entscheidend ist die Anzahl.
- *
- * Bewusst **kein** Hash über die Payloads: der wäre teurer und würde
- * Gleichheit über die Zeit versprechen, die der Log ohnehin schon garantiert.
- * Und bewusst hier, nicht im Server: der Projektor rechnet damit, und wer den
- * Stand prüfen will, soll dieselbe Rechnung fahren (R-2).
- */
-declare function logRevisionOf(events: readonly ElementEvent[]): string;
-/** Aktuelle Revision der Preferred-Head-Auswahl eines Kontexts. `0`, wenn keine existiert. */
-declare function preferredHeadRevisionOf(events: readonly ElementEvent[], elementId: string, contextId: string): number;
-
 /** Aktuelle Fassung des Dateiformats. */
 declare const SZENEN_SNAPSHOT_SCHEMA_VERSION = 1;
 /** Namenspräfix des Snapshots im Namensraum bzw. im Dateilog. */
@@ -656,7 +391,7 @@ declare function sceneOnlyCapabilities(scenePayload: unknown): {
     can_place: CapabilityFlag;
 };
 
-/** Der einzige Subtyp, der in diesem Schritt automatisch gilt (Auftrag §1). */
+/** Der Subtyp, der ohne jede weitere Bedingung gilt (Auftrag §1). */
 declare const GENERAL_POLICY_SUBTYPE = "general";
 /**
  * Eine automatisch aufgeloeste Policy — mit vollstaendiger Provenienz (D-22).
@@ -766,7 +501,14 @@ declare function scenePolicyFingerprint(policies: readonly ResolvedScenePolicy[]
  * die Voraussetzung dafuer, dass die Auswahl in dieselbe Konsistenzgrenze
  * faellt wie das Einfrieren der Szene (Gegenpruefung P2).
  */
-declare function resolveGeneralScenePolicies(snapshot: PolicySnapshot, contextChain: readonly (string | null)[]): ScenePolicyResult;
+declare function resolveGeneralScenePolicies(snapshot: PolicySnapshot, contextChain: readonly (string | null)[], 
+/**
+ * Das gewaehlte Zielmodell dieses Laufs, oder `null` fuer einen generischen.
+ *
+ * Nur seinetwegen kommen `target_model`-Policies ueberhaupt in Betracht;
+ * ohne Zielmodell bleibt die Auswahl exakt die von Schritt 03.
+ */
+targetModelElementId?: string | null): ScenePolicyResult;
 
 /** Ein Beitrag zur Beschreibung eines Knotens, mit Herkunft (D-50). */
 interface NodeContribution {
@@ -1079,6 +821,21 @@ interface ResolveShotPayloadInput {
         };
     };
 }
+/**
+ * Ein vom Aufrufer gewaehltes und bereits aufgeloestes Zielmodell (Kette
+ * `szenen-direktlauf-target-model-policy`).
+ *
+ * Bewusst dieselben Felder, die `targetModelResolution` ohnehin fuehrt: Damit
+ * entsteht **kein** zweiter Provenienznachweis neben dem des Shot-Pfads,
+ * sondern derselbe, nur aus einer anderen Quelle bestimmt.
+ */
+interface SceneTargetModel {
+    element_id: string;
+    version_id: string;
+    chain_index: number;
+    payload: unknown;
+    head: PreferredHeadResolution;
+}
 /**
  * Löst eine Shot-**Payload** auf, ohne eine veröffentlichte Version zu verlangen.
  *
@@ -1107,6 +864,8 @@ interface ResolveScenePayloadInput {
      * gegen die zweite Momentaufnahme bestaetigt (Schritt 03 §3).
      */
     autoPolicies?: readonly ResolvedScenePolicy[];
+    /** Das gewaehlte Zielmodell, bereits aufgeloest — oder `null`/fehlend. */
+    sceneTargetModel?: SceneTargetModel | null;
 }
 /**
  * Löst eine **Szene allein** zur Renderer-Eingabe auf (D-135).
@@ -1338,6 +1097,41 @@ interface PromptRunRecord {
     source?: PromptRunSource;
     created_at: string;
 }
+/**
+ * Die Felder, die **nur** das Detail eines Laufs braucht.
+ *
+ * Alle drei sind gross und keines davon steht in einer Liste: `system_prompt`
+ * wird nirgends angezeigt, `raw_output` nur im Diagnosebereich der
+ * aufgeklappten Runde, `input_payload` nur dort, wo aus dem eingefrorenen Lauf
+ * Bilder entstehen. Auf dev machten sie bei zehn Laeufen 74 von 100 kB der
+ * uebertragenen Laufdaten aus.
+ */
+declare const PROMPT_RUN_DETAIL_FIELDS: readonly ["system_prompt", "input_payload", "raw_output"];
+/**
+ * Ein Lauf, wie ihn eine Liste **ueber eine Leitung** bekommt.
+ *
+ * Kein gekuerzter `PromptRunRecord`, sondern ein eigener Typ mit einer
+ * ausdruecklichen Marke: Wer `detail_omitted` sieht, weiss, dass die drei
+ * Felder fehlen, **weil sie nicht mitgeschickt wurden** — und nicht, weil der
+ * Lauf sie nicht hat. Genau diese Unterscheidung ginge verloren, wenn die
+ * Felder am `PromptRunRecord` optional wuerden: Ein leeres `raw_output` saehe
+ * dann aus wie ein Lauf ohne Modellantwort (Regel 4).
+ *
+ * Ein Host, der seinen Bestand **ohne** Transport faltet (der Ereignislog in
+ * Flow), setzt die Marke nicht und liefert weiterhin volle Saetze. Die Ansicht
+ * braucht dafuer keinen zweiten Weg: Sie laedt das Detail nach, wenn die Marke
+ * steht, und sonst nicht.
+ */
+interface PromptRunListRecord extends Omit<PromptRunRecord, 'system_prompt' | 'input_payload' | 'raw_output'> {
+    detail_omitted: true;
+    system_prompt?: undefined;
+    input_payload?: undefined;
+    raw_output?: undefined;
+}
+/** Ein Lauf in einer Seite — voll, oder als Listenprojektion. */
+type PromptRunPageRecord = PromptRunRecord | PromptRunListRecord;
+/** Ob einem Lauf die Detailfelder fehlen, weil die Liste sie nicht uebertraegt. */
+declare function detailFehlt(run: PromptRunPageRecord): run is PromptRunListRecord;
 /**
  * Die Herkunft eines Laufs, auch bei einem Satz von vor 6.6.
  *
@@ -1346,7 +1140,7 @@ interface PromptRunRecord {
  * Damit muss kein Konsument zwei Datenformen kennen — und trotzdem wurde kein
  * einziges Ereignis angefasst.
  */
-declare function sourceOf(run: PromptRunRecord): PromptRunSource;
+declare function sourceOf(run: PromptRunPageRecord): PromptRunSource;
 /** Nutzlast des Ereignisses. Identisch mit dem Datensatz — ein Lauf ändert sich nie. */
 type PromptRunRecordedPayload = PromptRunRecord;
 /**
@@ -1394,9 +1188,9 @@ type PromptRunGroup = {
  * zusammenführt. Es entsteht **kein** neues Herkunftsfeld am Lauf; die Gruppe
  * wird bei jedem Lesen aus dem berechnet, was ohnehin dasteht.
  */
-declare function groupOf(run: PromptRunRecord): PromptRunGroup;
+declare function groupOf(run: PromptRunPageRecord): PromptRunGroup;
 /** Nur der Schlüssel der Bezugsgruppe — für Vergleiche und Filter. */
-declare function groupKeyOf(run: PromptRunRecord): string;
+declare function groupKeyOf(run: PromptRunPageRecord): string;
 /**
  * Die Geschwister eines Laufs: alle Läufe **seiner** Bezugsgruppe.
  *
@@ -1423,7 +1217,7 @@ declare function siblingsOf(run: PromptRunRecord, alle: readonly PromptRunRecord
  * `null` heisst: Es gibt kein benennbares Element. Dann bleibt es bei „Runde
  * n" — ein erfundener Titel wäre schlimmer als keiner (D-75).
  */
-declare function namingElementOf(run: PromptRunRecord): string | null;
+declare function namingElementOf(run: PromptRunPageRecord): string | null;
 /**
  * Der Arbeitskontext, in dem ein Lauf entstanden ist.
  *
@@ -1483,6 +1277,167 @@ interface PromptRunListing {
  * Eingabe bleibt erhalten.
  */
 declare function selectPromptRuns(alle: readonly PromptRunRecord[], filter?: PromptRunFilter): PromptRunListing;
+/**
+ * Woher die Laeufe einer Seite kommen.
+ *
+ * Genau die vier Einstiege, die es ohnehin gibt — `listAllRuns` und die drei
+ * verankerten Abfragen. Hier entsteht **keine** fuenfte Herkunft und keine
+ * neue Zuordnungsregel: `'all'` heisst „ohne Anker", die drei anderen
+ * vergleichen denselben `groupKeyOf`, den auch die Geschwister benutzen.
+ */
+type PromptRunPageSource = {
+    kind: 'all';
+} | {
+    kind: 'published';
+    shotVersionId: string;
+} | {
+    kind: 'draft_chain';
+    chainId: string;
+} | {
+    kind: 'scene';
+    sceneElementId: string;
+};
+/** Der Herkunftsfilter der gemeinsamen Sicht — dieselben Namen wie `PromptRunGroup`. */
+type PromptRunOriginFilter = PromptRunGroup['kind'];
+interface PromptRunPageFilter extends PromptRunFilter {
+    /** Nur Laeufe dieser Herkunft. Weglassen heisst „alle Herkuenfte". */
+    origin?: PromptRunOriginFilter;
+}
+interface PromptRunPageInput {
+    source?: PromptRunPageSource;
+    filter?: PromptRunPageFilter;
+    /** Ohne Angabe wird nicht geschnitten — dann ist die Seite der ganze Bestand. */
+    page?: PageRequest | null;
+    /**
+     * Die direkten Prompt-Tags des **ganzen** Bestands, wie
+     * `collectPromptRunTags()` sie aus demselben Log faltet.
+     *
+     * Sie gehen hier hinein und nicht in einen zweiten Aufruf, weil die Seite
+     * genau die Tags ihrer zehn Laeufe mitbringen soll — ein Nachschlagen je
+     * Karte waere die N+1-Abfrage, die diese Kette ausdruecklich vermeidet.
+     * Fehlt die Angabe, traegt die Seite einen leeren Tagsatz; das heisst „nicht
+     * mitgeliefert", und die Ansicht zeigt dann nur, was sie hat.
+     */
+    tags?: ReadonlyMap<string, readonly LibraryTagRef[]>;
+    /**
+     * Bildanzahl, Vorschau und Library-Tags je Lauf — wie
+     * `annotateRunsFromEvents()` sie liefert.
+     *
+     * Auch das geht **hier** hinein und nicht in einen Aufruf je Karte: Die
+     * Bild-Batches liegen in demselben Log wie die Laeufe, und die Seite bringt
+     * die Zahlen ihrer zehn Laeufe mit.
+     */
+    annotations?: ReadonlyMap<string, PromptRunAnnotation>;
+    /**
+     * Der Titel je **Element**, wie ihn der gefaltete Bestand kennt.
+     *
+     * Aus demselben Grund hier wie Tags und Bildzahlen: Der Name eines Laufs ist
+     * der Titel des Elements, aus dem er entstand (`namingElementOf`), und der
+     * steht in demselben Log. Ihn je Karte einzeln zu lesen hiess bisher, nach
+     * der Seite noch einmal **je Element** eine Abfrage zu stellen — nacheinander,
+     * weil eine Liste sonst zehn gleichzeitig ausloeste.
+     *
+     * Fehlt die Angabe, traegt die Seite keine Titel; die Ansicht loest sie dann
+     * weiterhin selbst auf. Es entsteht keine zweite Namensregel: **welches**
+     * Element benennt, entscheidet nach wie vor `namingElementOf()`.
+     */
+    titles?: ReadonlyMap<string, string>;
+}
+/**
+ * Eine Seite Laeufe, **neueste zuerst**, mit allem, was die Anzeige sonst aus
+ * dem Gesamtbestand hatte.
+ *
+ * Warum die Rundennummern mitkommen: Die Runde ist der Platz eines Laufs unter
+ * seinen Geschwistern (U23) — sie laesst sich aus zehn von achthundert Laeufen
+ * nicht ausrechnen. Statt dafuer wieder alles zu uebertragen, rechnet die Seite
+ * sie dort aus, wo der volle Bestand ohnehin liegt, und schickt genau die
+ * Nummern der gezeigten Laeufe mit. Es entsteht keine zweite Zaehlung: dieselbe
+ * Gruppierung, dieselbe Reihenfolge, derselbe 1-basierte Platz wie
+ * `roundOfRun(lauf, siblingsOf(lauf, alle))`.
+ */
+interface PromptRunPage extends Omit<PromptRunListing, 'runs'>, Page<PromptRunPageRecord> {
+    /**
+     * Dieselben Saetze wie `items` — `runs` bleibt der Name der Laufliste.
+     *
+     * Ueber eine Leitung sind es Listenprojektionen (`detail_omitted`), im
+     * lokal faltenden Host volle Saetze. Die Ansicht unterscheidet das mit
+     * `detailFehlt()` und laedt nur im ersten Fall nach.
+     */
+    runs: readonly PromptRunPageRecord[];
+    /** Rundennummer je `run_id`, nur fuer die Laeufe dieser Seite. */
+    rounds: Readonly<Record<string, number>>;
+    /** Laeufe, die der Herkunftsfilter ausgeblendet hat. */
+    hiddenByOrigin: number;
+    /**
+     * Die **direkten** Tags je `run_id`, nur fuer die Laeufe dieser Seite.
+     *
+     * Ein Lauf ohne Eintrag hat keine Prompt-Tags. Getrennt von `annotations`
+     * gefuehrt, weil diese Tags aus demselben Log stammen wie die Laeufe und
+     * jeder Host sie hat — auch einer ohne Library-Bestand.
+     */
+    promptTags: Readonly<Record<string, readonly LibraryTagRef[]>>;
+    /**
+     * Der Anzeigename je `run_id`, nur fuer die Laeufe dieser Seite und nur, wo
+     * das benennende Element einen Titel hat.
+     *
+     * Ein Lauf ohne Eintrag bleibt titellos und heisst „Runde n" — ein aus der
+     * `run_id` gebastelter Name saehe aus wie ein echter (D-75).
+     */
+    titles?: Readonly<Record<string, string>>;
+    /**
+     * Bildanzahl, Vorschau und Library-Tags je `run_id` — nur wenn der Host sie
+     * liefern kann. Fehlt das Feld, weiss die Ansicht es nicht und sagt das.
+     */
+    annotations?: Readonly<Record<string, PromptRunAnnotation>>;
+}
+/**
+ * Die Rundennummer **jedes** Laufs des uebergebenen Bestands.
+ *
+ * Gerechnet auf der chronologischen Reihenfolge, die `collectPromptRuns`
+ * liefert — nicht auf der Anzeigereihenfolge. Die Anzeige dreht sich um; die
+ * Rundenzaehlung tut es nicht, sonst hiesse derselbe Lauf morgen anders.
+ */
+declare function roundsOf(alle: readonly PromptRunRecord[]): ReadonlyMap<string, number>;
+/**
+ * Der eine Seitenschnitt fuer Prompt-Laeufe — Server wie Client.
+ *
+ * Reine Funktion ueber einem bereits gelesenen Bestand, genau wie
+ * `selectPromptRuns`, das sie benutzt. Damit gilt der Bezugsrahmen (Status,
+ * Kontext) an beiden Enden unveraendert; dazu kommen Herkunft, Umkehrung und
+ * Schnitt.
+ *
+ * @param alle Der Bestand in der Reihenfolge von `collectPromptRuns`.
+ * @throws Wenn der Cursor in der gefilterten Liste nicht vorkommt (`pageOf`).
+ */
+declare function pagePromptRuns(alle: readonly PromptRunRecord[], input?: PromptRunPageInput): PromptRunPage;
+/**
+ * Eine Seite, wie sie **ueber eine Leitung** geht — Kette `szenen-promptliste-transport`.
+ *
+ * Zwei Dinge fallen weg, beide gemessen an `GET /api2/szenen/prompt-runs/page`
+ * auf dev mit zehn Laeufen (203 kB):
+ *
+ * 1. **`items`.** Die Seite trug die Laufliste zweimal: einmal als `runs`,
+ *    einmal als `items` aus dem `Page<T>`-Vertrag. Im JSON sind das zwei
+ *    vollstaendige Kopien — 100 der 203 kB. Der Vertrag bleibt: Der Adapter
+ *    auf der anderen Seite setzt `items` aus `runs` wieder zusammen, statt es
+ *    zu uebertragen.
+ * 2. **Die Detailfelder** (`PROMPT_RUN_DETAIL_FIELDS`). 74 der uebrigen 100 kB,
+ *    und keines davon zeigt die Liste. Was bleibt, ist als
+ *    `PromptRunListRecord` **markiert**, damit die Ansicht ein fehlendes Feld
+ *    nicht fuer eine Aussage ueber den Lauf haelt.
+ *
+ * Rein und ohne Host: `items` wegzulassen ist eine Transportentscheidung, und
+ * sie gehoert neben den Seitenschnitt, nicht in einen Controller.
+ */
+declare function promptRunPageForTransport(seite: PromptRunPage): Omit<PromptRunPage, 'items'>;
+/**
+ * Die Gegenrichtung: `items` aus `runs` zuruecklegen.
+ *
+ * Der `Page<T>`-Vertrag gilt im Client unveraendert — er wurde nur nicht
+ * uebertragen. Ohne diesen Schritt fehlte `items` still, und jeder kuenftige
+ * Aufrufer von `Page<T>` saehe eine leere Seite statt eines Fehlers.
+ */
+declare function promptRunPageFromTransport(roh: Omit<PromptRunPage, 'items'>): PromptRunPage;
 
 /**
  * Ein Vorschlag, so wie er im Ereignis steht.
@@ -1816,6 +1771,13 @@ interface FreezeSceneSuccess {
      * eingefrorene Lauf traegt weiterhin ausschliesslich `input`.
      */
     policies: readonly ResolvedScenePolicy[];
+    /**
+     * Das eingefrorene Zielmodell, oder `null` fuer einen generischen Lauf.
+     *
+     * Wie `policies` redundant zu `input` und trotzdem hier: Der Aufrufer sieht
+     * die Provenienz, ohne sie aus `renderer_input` zurueckrechnen zu muessen.
+     */
+    targetModel: FrozenSceneTargetModel | null;
 }
 type FreezeSceneResult = FreezeSceneSuccess | FreezeFailure;
 interface FreezeSceneWorkingStateInput {
@@ -1825,6 +1787,38 @@ interface FreezeSceneWorkingStateInput {
     resolver: ReferenceResolver;
     contextChain: readonly (string | null)[];
     userInstruction?: string | null;
+    /**
+     * Das gewaehlte Zielmodell (Kette `szenen-direktlauf-target-model-policy`).
+     *
+     * Optional: Ohne Angabe bleibt der Ablauf exakt der generische von D-135 —
+     * kein Zielmodell im `RendererInput`, keine `target_model`-Policy.
+     */
+    targetModelElementId?: string | null;
+}
+/**
+ * Das gewaehlte Zielmodell eines Szene-Direktlaufs — Kette
+ * `szenen-direktlauf-target-model-policy`, Schritt 01.
+ *
+ * **Warum ueber die `element_id` und nicht ueber den Key.** Der Shot-Pfad sucht
+ * ein Zielmodell ueber `prompt_render_settings.target_model_id`, also ueber
+ * einen freien Key entlang der Kette — mit allen Ausgaengen, die dazugehoeren
+ * (`not_found`, `ambiguous`, `retired`, `fork`). Der Szene-Direktlauf bekommt
+ * das Modell dagegen von einem Menschen ausgewaehlt, und der waehlt es aus
+ * einer Liste, die schon aufgeloest ist. Die Kennung ist damit eindeutig, und
+ * sie ist dieselbe, die eine `target_model`-Policy in
+ * `applicable_target_models` nennt. Eine zweite Suche ueber einen geratenen
+ * Namen waere fehleranfaelliger als die Kennung, die vorliegt.
+ *
+ * Die **Version** waehlt trotzdem niemand von Hand: Sie kommt aus derselben
+ * D-36-Preferred-Head-Aufloesung wie der Arbeitsstand der Szene daneben.
+ */
+interface FrozenSceneTargetModel {
+    element_id: string;
+    version_id: string;
+    /** Glied der Kontextkette, auf dem das Element liegt. `0` = Arbeitskontext. */
+    chain_index: number;
+    payload: unknown;
+    head: PreferredHeadResolution;
 }
 /**
  * Friert den Arbeitsstand **einer Szene** ein und baut die Renderer-Eingabe
@@ -2879,6 +2873,113 @@ declare function claimWon(job: ImageJob | null, claimId: string): boolean;
  */
 declare function generationBatchIdOf(jobId: string): string;
 
+/**
+ * Die Statusgruppen, nach denen der Bereich filtert (§3).
+ *
+ * Bewusst **Gruppen** und nicht die rohen Auftragszustaende: Fuer die
+ * Bedienung zaehlt „offen / laeuft / fertig / fehlgeschlagen", und
+ * `succeeded` von `partial` zu trennen waere ein Filter, den niemand braucht.
+ * Die genauen Zustaende stehen weiterhin an jedem Auftrag.
+ */
+type ImageJobStatusFilter = 'pending' | 'claimed' | 'done' | 'failed' | 'all';
+/** Ob ein Auftrag noch auf Uebernahme wartet — der Arbeitsvorrat. */
+declare function istOffen(job: ImageJob): boolean;
+/**
+ * Die Herkunft eines Auftrags, soweit **aus derselben Faltung** sicher
+ * auflösbar (§3, §8 Regel 3).
+ *
+ * `null`-Felder heissen „steht nicht im Bestand", nicht „unbekannt geraten":
+ * Ein Auftrag, dessen Lauf hier nicht liegt, bekommt keinen erfundenen Titel
+ * (Regel 4).
+ */
+interface ImageJobHerkunft {
+    run_id: string;
+    /** Der Titel des benennenden Elements — meist die Szene. */
+    szene_titel: string | null;
+    /** Die Kennung dieses Elements, auch wenn kein Titel auflösbar war. */
+    szene_element_id: string | null;
+    /** Ein kurzer Ausschnitt des eingefrorenen positiven Prompts. */
+    prompt_auszug: string | null;
+    /** Ob der Lauf selbst im Bestand liegt. `false` → alle Felder oben sind leer. */
+    lauf_gefunden: boolean;
+}
+/** Ein Auftrag mit seiner gemeinsam geladenen Herkunft. */
+interface ImageJobEintrag {
+    job: ImageJob;
+    herkunft: ImageJobHerkunft;
+}
+/** Wie viele Zeichen des Prompts in einer Zeile stehen. */
+declare const PROMPT_AUSZUG_ZEICHEN = 160;
+interface ImageJobQuery {
+    /** Vorgabe: `pending` — der Bereich ist eine Arbeitsqueue, kein Archiv. */
+    status?: ImageJobStatusFilter;
+    /** Hoechstens so viele Eintraege je Seite. Fehlt: alle. */
+    limit?: number;
+    /** Die Auftragskennung, **nach** der weitergelesen wird. */
+    cursor?: string | null;
+}
+interface ImageJobSeite {
+    eintraege: readonly ImageJobEintrag[];
+    /** Die Kennung fuer die naechste Seite, oder `null` — dann ist es vollstaendig. */
+    nextCursor: string | null;
+    /** Wie viele Auftraege der Filter insgesamt trifft, unabhaengig vom Schnitt. */
+    gesamt: number;
+    /**
+     * Wie viele Auftraege des Bestands **offen** sind — unabhaengig von Filter
+     * und Seitenschnitt.
+     *
+     * Der Arbeitsvorrat muss vollstaendig ablesbar bleiben, auch wenn die Seite
+     * ihn nicht ganz zeigt (§8 Regel 4).
+     */
+    offen: number;
+}
+/**
+ * Die bestandsweite Auftragsliste aus **einem** Ereignisstrom.
+ *
+ * `storeId` schneidet auf den Bestand dieses Hosts zu — dieselbe Bindung, an
+ * der `claimAndRun()` eine fremde Uebernahme ablehnt. Ein Auftrag eines
+ * anderen Bestands gehoert nicht in diese Liste: Er waere hier weder
+ * ausfuehrbar noch auffindbar.
+ *
+ * Ein unbekannter `cursor` ist ein **Fehler** und kein leeres Ergebnis
+ * (Regel 4): Er bedeutet, dass die Seite auf einem Stand aufsetzt, den es
+ * nicht mehr gibt.
+ */
+declare function selectImageJobs(events: readonly ElementEvent[], storeId: string, query?: ImageJobQuery): ImageJobSeite;
+/** Das zuletzt gesicherte Bild des Bestands, mit seinem Nachweis (§5). */
+interface LetztesErzeugtesBild {
+    /** Der Auftrag, aus dem dieser Batch stammt — `null` bei einem Batch ohne Auftrag. */
+    job: ImageJob | null;
+    prompt_run_id: string;
+    item_id: string;
+    generation_batch_id: string;
+    /** Das **letzte** Bild dieses Batches — das zuletzt entstandene. */
+    bild: PromptBatchImageRef;
+    /** Seine Stelle im Batch, 1-basiert, und die Batchgroesse — „4 / 4". */
+    position: number;
+    anzahl: number;
+    /** Der Zeitpunkt aus dem Ereignis, nicht aus einer lokalen Uhr. */
+    gespeichert_am: string | null;
+    /** Das Zielmodell des Auftrags, soweit es einen gibt. */
+    execution_target_model_key: string | null;
+    /** Die Herkunft des Laufs, in derselben Form wie in der Liste. */
+    herkunft: ImageJobHerkunft | null;
+}
+/**
+ * Das zuletzt gesicherte Bild dieses Bestands.
+ *
+ * **Bestimmt ueber die Ereignisreihenfolge**, nicht ueber Dateinamen oder
+ * lokale Zeitstempel (§5.1): Das letzte `image_batch_persisted` im Log ist
+ * das zuletzt gesicherte, auch wenn eine Hostuhr falsch geht.
+ *
+ * Der Zuschnitt auf den Bestand laeuft ueber die Auftraege: Ein Batch, dessen
+ * `generation_batch_id` zu einem Auftrag dieses Bestands gehoert, zaehlt
+ * sicher dazu. Ein Batch ohne Auftrag — etwa aus „Bilder erzeugen" im Lauf —
+ * zaehlt ebenfalls, denn er steht im Log **dieses** Bestands; ein fremder
+ * Bestand hat sein eigenes Log.
+ */
+declare function letztesErzeugtesBild(events: readonly ElementEvent[], storeId: string): LetztesErzeugtesBild | null;
+
 /**
  * Was der Auftragskanal braucht.
  *
@@ -2936,6 +3037,28 @@ interface SzenenImageJobPort {
     listJobs(runId: string): Promise<QueryResult<readonly ImageJob[]>>;
     /** Beansprucht einen wartenden Auftrag und fuehrt ihn als Gewinner aus. */
     claimAndRun(jobId: string): Promise<ClaimAndRunResult>;
+    /**
+     * Die Auftraege des **Bestands**, unabhaengig vom Prompt-Lauf — Kette
+     * `szenen-bildauftraege-arbeitsqueue`, §8.
+     *
+     * Sie entsteht aus **einem** Lesevorgang derselben autoritativen Projektion,
+     * die `listJobs()` benutzt. Der Weg ueber alle Laeufe plus `listJobs(runId)`
+     * je Lauf waere dieselbe Liste zum N+1-fachen Preis (§8 Regel 1) — und die
+     * Auftraege stehen ohnehin im Log, nicht am Lauf.
+     *
+     * Optional wie jede Portoperation dieses Projekts: Ein Host ohne sie
+     * bekommt den Arbeitsbereich nicht, statt einen leeren zu bekommen.
+     */
+    listAllJobs?(query?: ImageJobQuery): Promise<QueryResult<ImageJobSeite>>;
+    /**
+     * Das zuletzt gesicherte Bild dieses Bestands — die Vorschau „Letztes
+     * erzeugtes Bild" (§5).
+     *
+     * Bestimmt ueber die **Ereignisreihenfolge** des autoritativen Logs, nicht
+     * ueber Dateinamen oder lokale Zeitstempel (§5.1). Erzwingt **keine** Kopie
+     * in die Library: Gelesen wird der vorhandene Batch-Nachweis (§5.2).
+     */
+    latestImage?(): Promise<QueryResult<LetztesErzeugtesBild | null>>;
 }
 interface CreateImageJobPortOptions {
     channel: ImageJobChannel;
@@ -3111,6 +3234,70 @@ interface SzenenRunPort {
      * `promptOverview: false`, und die Ansicht nennt den Grund (§8).
      */
     listAllRuns?(filter?: PromptRunFilter): Promise<QueryResult<PromptRunListing>>;
+    /**
+     * Legt einen **manuell erfassten** Promptlauf in einer Szene an — Kette
+     * `szenen-manuell-angepasste-promptlaeufe`, Schritt 01.
+     *
+     * Derselbe Weg wie `startRunFromScene`, nur ohne den Modellaufruf: Kontext
+     * ermitteln, Kette auflösen, einfrieren (D-97), Lauf ablegen. Es entsteht
+     * kein zweites Laufformat und keine zweite Ablage — der Lauf ist danach ein
+     * ganz normaler Szene-Direktlauf und über dieselben Abfragen erreichbar.
+     *
+     * Dieselben drei Fehlausgänge wie beim Szenenlauf, und aus demselben Grund:
+     * Konflikt, fachlicher Mangel und technischer Fehler sind verschiedene
+     * Auskünfte. Hier gilt in **jedem** Fall: Es wurde kein Modell gerufen — auch
+     * im Erfolgsfall nicht.
+     *
+     * Optional wie `listAllRuns`, und aus demselben Grund: Ein Host ohne diese
+     * Operation verliert genau die eine Aktion, und `capabilitiesOf()` meldet
+     * `manualPromptRun: false`, damit die Ansicht den Grund nennt statt ein
+     * Formular zu zeigen, das nichts ablegen kann (§8). Ein Pflichtmitglied
+     * hätte ausserdem jeden bestehenden Implementierer der öffentlichen
+     * Schnittstelle gebrochen.
+     */
+    addManualSceneRun?(input: AddManualSceneRunInput): Promise<StartRunFromDraftResult>;
+    /**
+     * **Eine Seite** Laeufe, neueste zuerst — Kette `szenen-listen-pagination`.
+     *
+     * Sie ersetzt die vier Abfragen darueber nicht, sie schneidet sie: derselbe
+     * Bestand, derselbe Bezugsrahmen (`selectPromptRuns`), dieselbe
+     * Gruppierungsregel — nur nicht mehr alles auf einmal. Welcher Einstieg
+     * gemeint ist, steht in `source`; damit gibt es **eine** seitenweise
+     * Operation statt vier, und die Ansicht hat eine Ladefunktion statt vier.
+     *
+     * Die Rundennummern kommen mit (`PromptRunPage.rounds`). Ohne sie muesste die
+     * Ansicht wieder den vollen Bestand lesen, um den Platz eines Laufs unter
+     * seinen Geschwistern zu kennen (U23) — genau das, was der Seitenschnitt
+     * vermeiden soll. Es entsteht keine zweite Zaehlung: gerechnet wird mit
+     * derselben Regel, dort wo der volle Bestand ohnehin liegt.
+     *
+     * Optional wie `listAllRuns`, und aus demselben Grund: Ein Pflichtmitglied
+     * haette jeden bestehenden Implementierer der oeffentlichen Schnittstelle
+     * gebrochen. Fehlt die Operation, meldet `capabilitiesOf()`
+     * `pagedRuns: false`, und die Ansicht laedt wie bisher vollstaendig — sie
+     * zeigt keinen „Mehr laden"-Knopf, den niemand bedienen koennte.
+     */
+    listRunsPage?(input: PromptRunPageInput): Promise<QueryResult<PromptRunPage>>;
+    /**
+     * Setzt die **direkten** Tags eines Laufs — Kette
+     * `szenen-prompt-anzeige-bilder-tags`.
+     *
+     * Uebergeben wird der vollstaendige Satz an Labels, nicht ein Delta:
+     * Entfernen ist ein kuerzerer Satz. Aufgeloest werden die Labels gegen die
+     * bestehende Library-Vokabel (`resolveTagLabels`) — ein unbekanntes Label
+     * wird abgelehnt und nicht nebenbei angelegt, genau wie im Library-Weg.
+     *
+     * Beruehrt **ausschliesslich** die Prompt-Tags. Die Tags zugeordneter
+     * Library-Items sind abgeleitet und liegen an ihren Items; dieser Aufruf
+     * kann sie weder schreiben noch loeschen, und das ist die Zusage, wegen der
+     * die Anzeige beide Herkuenfte mischen darf.
+     *
+     * Optional wie `listRunsPage`: Ein Host ohne autoritativen Schreibweg
+     * bekommt die Operation nicht, `capabilitiesOf()` meldet `runTags: false`,
+     * und die Ansicht zeigt die Tags dann nur an, statt einen Editor
+     * anzubieten, der nichts ablegen kann (§8).
+     */
+    setRunTags?(runId: string, labels: readonly string[]): Promise<CommandResult<readonly LibraryTagRef[]>>;
 }
 interface StartRunFromSceneInput {
     /** Das Szenen-**Element**. Ob Entwurf oder Version gilt, entscheidet der Bestand. */
@@ -3118,6 +3305,27 @@ interface StartRunFromSceneInput {
     userInstruction?: string;
     contextId?: string | null;
 }
+/** Die Eingabe eines manuell erfassten Promptlaufs (Schritt 01). */
+interface AddManualSceneRunInput {
+    /** Die bestehende Szene, zu der der Lauf gehört. */
+    sceneElementId: string;
+    /** Der vollständige Prompttext, **unverändert** wie eingegeben. */
+    promptText: string;
+    /**
+     * Das gewählte Zielmodell als Element-Kennung, oder `null`.
+     *
+     * Aufgelöst wird es beim Einfrieren — mit derselben Kontextsichtbarkeit wie
+     * überall sonst. Hier entsteht keine zweite Modellliste und kein Freitext.
+     */
+    targetModelElementId?: string | null;
+    /** Kurze Bezeichnung oder Notiz zur Variante. */
+    note?: string | null;
+    /** Der Lauf, aus dem der Prompt von Hand abgeleitet wurde — loser Bezug. */
+    derivedFromRunId?: string | null;
+    /** Wer den Lauf einträgt. */
+    enteredBy: string;
+    contextId?: string | null;
+}
 /**
  * Warum ein Draft-Lauf nicht zustande kam — **drei** verschiedene Auskünfte.
  *
@@ -3613,6 +3821,10 @@ interface PromptImageBatch {
  * heute nicht — der reguläre `unsupported`-Fall, keine Zeile Sondercode
  * (D-115-Analogie: keine Host-Verzweigung im gemeinsamen Code).
  */
+/** Die bestehende Library-Tag-Vokabel, nur lesend. */
+interface SzenenTagVocabularyPort {
+    listTags(): Promise<QueryResult<readonly LibraryTagRef[]>>;
+}
 interface SzenenImageBatchHistoryPort {
     /** Alle Batches eines Prompt-Laufs — gesucht über IDs, nicht über Titel/Zeit (D-109). */
     listBatchesForPromptRun(runId: string): Promise<QueryResult<readonly PromptImageBatch[]>>;
@@ -3760,6 +3972,17 @@ interface SzenenViewPort {
      * Ereignislog. Flow liefert sie deshalb unabhängig von Bildprovider und
      * Batch-Schreibweg — React liefert sie zusätzlich über MySQL als Index.
      */
+    /**
+     * Die Tag-Vokabel des Hosts — Kette `szenen-prompt-anzeige-bilder-tags`.
+     *
+     * Sie existiert nur, damit der Tag-Editor **vorschlagen** kann, was es
+     * bereits gibt. Geprueft wird trotzdem beim Schreiben, und zwar dort, wo die
+     * Vokabel liegt: Eine Vorschlagsliste im Browser ist keine Zusage.
+     *
+     * Optional wie alles hier: Ein Host ohne sie zeigt ein Freitextfeld, und ein
+     * unbekanntes Label wird beim Speichern mit Namen abgelehnt (Regel 11).
+     */
+    tags?: SzenenTagVocabularyPort;
     imageBatchHistory?: SzenenImageBatchHistoryPort;
     /**
      * Bild-Batch-Schreiben — fehlt ohne sicheren, hostübergreifenden
@@ -3815,8 +4038,28 @@ interface SzenenViewCapabilities {
     imageGeneration: boolean;
     /** Bildauftraege aus dem Chat uebernehmen (Kette szenen-mcp-chatgpt-flow). */
     imageJobs: boolean;
+    /**
+     * Die bestandsweite Auftragsqueue — Bereich `Bildauftraege` (Kette
+     * `szenen-bildauftraege-arbeitsqueue`).
+     *
+     * Getrennt von `imageJobs`: Ein Host kann Auftraege eines Laufs lesen und
+     * uebernehmen, ohne die globale Projektion zu liefern. Dann bleibt die
+     * bestehende Laufansicht vollstaendig und nur der Arbeitsbereich fehlt —
+     * statt leer dazustehen (§2).
+     */
+    imageJobQueue: boolean;
     /** Die herkunftsuebergreifende Prompt-Sicht (P1-A) — Bereich `Prompts`. */
     promptOverview: boolean;
+    /** „Promptlauf manuell hinzufuegen" — Kette szenen-manuell-angepasste-promptlaeufe. */
+    manualPromptRun: boolean;
+    /** Seitenweises Laden der Laufliste (Kette szenen-listen-pagination). */
+    pagedRuns: boolean;
+    /** Seitenweises Laden der Elementliste (Kette szenen-listen-pagination). */
+    pagedElements: boolean;
+    /** Prompt-Tags bearbeiten (Kette szenen-prompt-anzeige-bilder-tags). */
+    runTags: boolean;
+    /** Vorschlagsliste aus der bestehenden Library-Tag-Vokabel. */
+    tagVocabulary: boolean;
 }
 declare function capabilitiesOf(port: SzenenViewPort): SzenenViewCapabilities;
 /**
@@ -4017,7 +4260,108 @@ interface LadeVorschauenOptionen {
  */
 declare function ladeVorschauen(port: SzenenImageLibraryPort, mediaRefs: readonly string[], fertig: (mediaRef: string, quelle: string) => void, optionen?: LadeVorschauenOptionen): Promise<void>;
 
+/**
+ * Der Anbieter eines manuell erfassten Laufs.
+ *
+ * `manual` und nicht der Name des Zielmodells: `provider`/`model_id` sagen,
+ * **womit formuliert wurde**. Formuliert hat hier ein Mensch. Das Zielmodell
+ * steht dort, wo es hingehoert — in `target_model_version_id` und im
+ * eingefrorenen `input_payload`.
+ */
+declare const MANUAL_PROVIDER = "manual";
+/** Die Modellkennung eines manuell erfassten Laufs — ehrlich, nicht geraten. */
+declare const MANUAL_MODEL_ID = "manual-entry";
+/** Die Basis der Sichtbarkeitsangaben: keine Ableitung, sondern Handeingabe. */
+declare const MANUAL_VISIBILITY_BASIS = "manual_entry";
+/** Der Knotenzustand, wenn niemand die Sichtbarkeit beurteilt hat. */
+declare const MANUAL_NODE_STATE = "unassessed";
+/**
+ * Die Handeingabe am Lauf — additiv, wie `operation_id` und `execution_origin`.
+ *
+ * Sie steht **neben** `source` und nicht darin: Herkunft im Sinne von D-98 ist,
+ * welcher Stand eingefroren wurde, und der ist hier derselbe wie bei jedem
+ * anderen Szene-Direktlauf. Was dieser Block hinzufuegt, ist die Auskunft,
+ * **wie** der Text entstand.
+ */
+interface ManualPromptEntry {
+    /** Immer `true`. Ein Leser muss das nicht aus `provider` erschliessen. */
+    entered_manually: true;
+    /** Die kurze Bezeichnung oder Notiz zur Variante, oder `null`. */
+    note: string | null;
+    /**
+     * Der Lauf, aus dem dieser Prompt von Hand abgeleitet wurde — oder `null`.
+     *
+     * Bewusst eine **lose** Kennung ohne Aufloesung und ohne Pruefung gegen den
+     * Bestand: Ein manuell abgeleiteter Lauf soll auch dann lesbar bleiben, wenn
+     * sein Ursprung spaeter nicht mehr auffindbar ist. Eine harte Abhaengigkeit
+     * waere eine Zusage, die dieses Feld nicht halten kann (Schritt 01, Regel 4).
+     */
+    derived_from_run_id: string | null;
+    /** Wer eingetragen hat. */
+    entered_by: string;
+}
+/** Ein Lauf, der von Hand eingetragen wurde. */
+type ManualPromptRunRecord = PromptRunRecord & {
+    manual_entry: ManualPromptEntry;
+};
+interface BuildManualPromptRunInput {
+    runId: string;
+    /** Der eingefrorene Szenenstand — woertlich der von `freezeSceneWorkingState()`. */
+    scene: FrozenSceneState;
+    /** Die eingefrorene Renderer-Eingabe desselben Einfrierens (D-22). */
+    input: RendererInput;
+    /** Der Prompttext, **unveraendert** wie eingegeben. */
+    promptText: string;
+    note?: string | null;
+    derivedFromRunId?: string | null;
+    enteredBy: string;
+    now?: () => Date;
+}
+type BuildManualPromptRunResult = {
+    kind: 'ok';
+    record: ManualPromptRunRecord;
+} | {
+    kind: 'rejected';
+    message: string;
+};
+/**
+ * Baut den Lauf. Prueft nur, was ohne Bestandszugriff pruefbar ist.
+ *
+ * Ein leerer Prompttext ist eine Ablehnung und kein Lauf: Er waere ein
+ * erfolgreicher Lauf ohne Ergebnis und wuerde in jeder Leseansicht als
+ * vollwertige Runde erscheinen.
+ */
+declare function buildManualPromptRunRecord(eingabe: BuildManualPromptRunInput): BuildManualPromptRunResult;
+/** Der Handeingabe-Block eines Laufs, oder `null` bei jedem anderen Lauf. */
+declare function manualEntryOf(run: PromptRunPageRecord): ManualPromptEntry | null;
+
 interface CreateMemoryViewPortOptions {
+    /**
+     * Die **direkten** Tags je Lauf — Kette `szenen-prompt-anzeige-bilder-tags`.
+     *
+     * Der Speicherhost fuehrt sie als Zustand und laesst sie auch schreiben:
+     * Anders als der Ereignislog-Weg braucht er dafuer keine Vokabel-Tabelle,
+     * und ein Editor, der im Test nichts ablegen kann, prueft nichts.
+     */
+    runTags?: Record<string, readonly string[]>;
+    /**
+     * Bildanzahl, Vorschau und Library-Tags je Lauf.
+     *
+     * Vorbelegt statt aus Ereignissen gefaltet: Dieser Port haelt Laeufe als
+     * Liste, nicht als Log. Die Faltung selbst prueft
+     * `promptKarte.test.ts` gegen `annotateRunsFromEvents`.
+     */
+    runAnnotations?: Record<string, PromptRunAnnotation>;
+    /** Die Vorschlagsliste des Tag-Editors. Fehlt sie, bietet der Port keine an. */
+    tagVocabulary?: readonly string[];
+    /**
+     * Bildanzahl, Deckbild und Tags je **Element**.
+     *
+     * Vorbelegt wie `runAnnotations` und aus demselben Grund: Dieser Port haelt
+     * keinen Laufbestand, aus dem sich die Ableitung falten liesse. Die Faltung
+     * selbst prueft `promptKarte.test.ts` gegen `annotateElementsFromEvents`.
+     */
+    elementAnnotations?: Record<string, ElementAnnotation>;
     /**
      * Ob der Port Items anbietet. `false` bildet Flow-Pure nach: das Feld fehlt
      * dann ganz, statt eine Operation zu haben, die `unsupported` zurückgibt.
@@ -4295,6 +4639,30 @@ interface PromptRunPersistencePort {
      * leeren Bereich zu zeigen (§8).
      */
     listAll?(): Promise<QueryResult<readonly PromptRunRecord[]>>;
+    /**
+     * **Eine Seite** Laeufe — Kette `szenen-listen-pagination`.
+     *
+     * Optional, und zwar mit einer klaren Aufgabenteilung: Eine Persistenz, die
+     * ihren Bestand **ohne Transport** faltet (der Ereignislog in Flow), braucht
+     * sie nicht — dort schneidet der Port selbst, und das Ergebnis ist
+     * identisch. Eine Persistenz **hinter einer Leitung** (REST) braucht sie,
+     * denn dort ist die Uebertragungsmenge genau das Problem: Nachtraeglich im
+     * Browser zu schneiden hiesse, vorher alles geholt zu haben.
+     */
+    listPage?(input: PromptRunPageInput): Promise<QueryResult<PromptRunPage>>;
+    /**
+     * Setzt die direkten Tags eines Laufs — Kette
+     * `szenen-prompt-anzeige-bilder-tags`.
+     *
+     * Optional, und zwar nicht aus Bequemlichkeit: Ein Prompt-Tag ist eine
+     * **Library-Vokabel**, und die steht in `tags` (MySQL). Eine Persistenz ohne
+     * Zugang zu dieser Vokabel koennte ein Label nicht pruefen — sie muesste es
+     * entweder nebenbei anlegen (was der Library-Weg ausdruecklich nicht tut)
+     * oder ungeprueft anhaengen. Beides waere ein zweites Tag-System. Deshalb
+     * bietet nur die REST-Persistenz diese Operation an; der Ereignislog-Weg
+     * zeigt Tags an, ohne sie schreiben zu koennen (§8).
+     */
+    setTags?(runId: string, labels: readonly string[]): Promise<CommandResult<readonly LibraryTagRef[]>>;
 }
 /** Was der Eventlog-Adapter vom Kanal braucht — lesen und anhängen. */
 interface RunEventChannel {
@@ -4666,6 +5034,15 @@ interface PreparePromptOperationInput {
     contextChain: readonly (string | null)[];
     contextId: string | null;
     userInstruction?: string | null;
+    /**
+     * Das gewaehlte Zielmodell (Kette `szenen-direktlauf-target-model-policy`).
+     *
+     * Optional. Ohne Angabe bleibt der Vorgang exakt der generische von D-135;
+     * mit Angabe traegt der eingefrorene `RendererInput` die Modellprovenienz,
+     * und `completePromptOperation()` schreibt ihre `version_id` ohne Zutun in
+     * `target_model_version_id` des Laufs.
+     */
+    targetModelElementId?: string | null;
     preparedBy: string;
     now?: () => Date;
 }
@@ -4733,6 +5110,89 @@ declare function runOfOperation(runs: readonly PromptRunRecord[], operationId: s
 /** Ob eine eingereichte Antwort woertlich die des bereits gespeicherten Laufs ist. */
 declare function sameResponseAs(run: PromptRunRecord, response: string): boolean;
 
+/** Die waehlbaren Pausen zwischen zwei Auftraegen, in Sekunden (§4). */
+declare const PAUSE_SEKUNDEN_OPTIONEN: readonly number[];
+/** Die Vorgabe, wenn der Nutzer nichts waehlt (§4). */
+declare const PAUSE_SEKUNDEN_VORGABE = 3;
+/** Ob ein Wert eine angebotene Pause ist — die Liste ist die Wahrheit. */
+declare function istGueltigePause(sekunden: number): boolean;
+/** Wie ein einzelner Auftrag des Snapshots ausgegangen ist. */
+type QueueAusgang = 
+/** Uebernommen und bis zu einem sicheren Ausgang ausgefuehrt. */
+{
+    kind: 'ausgefuehrt';
+    jobId: string;
+    status: ImageJob['status'];
+    text: string;
+}
+/**
+ * Nicht mehr offen — ein anderer Host hatte ihn, oder er wurde fachlich
+ * abgelehnt. **Nichts wurde bezahlt**, und die Queue laeuft weiter (§4.3).
+ */
+ | {
+    kind: 'uebersprungen';
+    jobId: string;
+    text: string;
+}
+/**
+ * Der Ausgang steht **nicht** sicher fest. Die Queue haelt an, damit sie
+ * nicht neben einem moeglicherweise laufenden Providerjob einen zweiten
+ * startet (§4.3, letzter Punkt).
+ */
+ | {
+    kind: 'unbekannt';
+    jobId: string;
+    text: string;
+};
+type QueueZustand = 
+/** Ein Auftrag laeuft gerade. */
+'laeuft'
+/** Zwischen zwei Auftraegen — die eingestellte Pause laeuft. */
+ | 'pause'
+/** Der Snapshot ist vollstaendig abgearbeitet. */
+ | 'fertig'
+/** Der Nutzer hat abgebrochen; der zuletzt gestartete Auftrag lief zu Ende. */
+ | 'abgebrochen'
+/** Angehalten wegen unsicherem Ausgang (§4.3). */
+ | 'gestoppt';
+interface QueueFortschritt {
+    /** Die Kennungen dieses Laufs, in Startreihenfolge — fest ab dem Klick. */
+    snapshot: readonly string[];
+    /** „Job n von m": 1-basiert, `0` solange noch keiner gestartet wurde. */
+    nummer: number;
+    /** Der gerade bearbeitete Auftrag, oder `null` zwischen zwei Auftraegen. */
+    aktuell: string | null;
+    zustand: QueueZustand;
+    /** Der letzte sicher bekannte Ausgang (§4.2). */
+    letzterAusgang: QueueAusgang | null;
+    /** Warum die Queue angehalten hat — gesetzt bei `gestoppt` und `abgebrochen`. */
+    grund: string | null;
+    /** Die eingestellte Pause, damit die Laufanzeige sie nennen kann (§4.2). */
+    pauseSekunden: number;
+}
+interface QueueLaufOptionen {
+    /** Die beim Klick offenen Auftraege, aelteste zuerst (§4.1). */
+    snapshot: readonly string[];
+    pauseSekunden: number;
+    /** Der **eine** Ausfuehrungsweg — derselbe wie beim Einzelstart. */
+    claimAndRun: (jobId: string) => Promise<ClaimAndRunResult>;
+    /** Warten. Einspeisbar, damit ein Test nicht zehn Sekunden schlaeft. */
+    warte: (ms: number) => Promise<void>;
+    /** Jeder Zustandswechsel, fuer die Laufanzeige. */
+    melde: (fortschritt: QueueFortschritt) => void;
+    /** Ob der Nutzer inzwischen abgebrochen hat — vor jedem Start gefragt. */
+    abgebrochen: () => boolean;
+}
+/**
+ * Arbeitet den Snapshot streng seriell ab.
+ *
+ * Der Rueckgabewert ist der Endstand; jeder Zwischenstand kam vorher ueber
+ * `melde()`. Die Funktion wirft nicht: Ein geworfener Fehler aus
+ * `claimAndRun()` ist genau der unsichere Ausgang, wegen dem angehalten wird,
+ * und er gehoert in den Fortschritt, nicht in einen Stacktrace.
+ */
+declare function fuehreQueueAus(optionen: QueueLaufOptionen): Promise<QueueFortschritt>;
+
 interface CreateHfImageBatchPersistenceOptions {
     namespace: string;
     token: string;
@@ -4839,7 +5299,7 @@ declare function istZipDatei(datei: {
  */
 declare function leseBilderAusZip(datei: File | Blob): Promise<readonly ZipBild[]>;
 
-type SzenenAreaId = 'scene' | 'prompts' | 'elements' | 'advanced' | 'media';
+type SzenenAreaId = 'scene' | 'prompts' | 'imageJobs' | 'elements' | 'advanced' | 'media';
 interface SzenenArea {
     id: SzenenAreaId;
     title: string;
@@ -4891,7 +5351,36 @@ interface SzenenViewProps {
     initialArea?: SzenenAreaId;
     /** Meldet Bereichswechsel nach außen, damit der Host sie merken kann. */
     onAreaChange?: (area: SzenenAreaId) => void;
+    /**
+     * Ein von außen angesteuertes Ziel — der Einstieg aus der Library
+     * („Promptlauf öffnen" / „Szene öffnen").
+     *
+     * Es gibt dafür **kein** zweites Routing: Der Fokus wählt den vorhandenen
+     * Bereich und reicht die Kennung an die vorhandene Liste weiter, die ihn
+     * wie jede andere Auswahl behandelt.
+     */
+    fokus?: SzenenFokus | null;
+    /** Zurück dorthin, woher der Fokus kam. Fehlt, wenn es kein Zurück gibt. */
+    onFokusVerlassen?: () => void;
 }
+/** Das angesteuerte Ziel. Genau eines — nie beides und nie geraten. */
+type SzenenFokus = {
+    kind: 'run';
+    runId: string;
+} | {
+    kind: 'scene';
+    elementId: string;
+    /**
+     * Der Lauf, aus dem der Sprung kam — optional.
+     *
+     * Er macht das Ziel nicht mehrdeutig: Angesteuert ist die Szene. Er
+     * sagt nur, welche Runde ihrer Historie gemeint ist, damit dort nicht
+     * die neueste aufgeht und wie die Antwort auf den Sprung aussieht.
+     */
+    runId?: string | null;
+};
+/** Der Bereich, in dem ein Fokusziel zu Hause ist. */
+declare function areaForFokus(fokus: SzenenFokus): SzenenAreaId;
 declare const SzenenView: React__default.FC<SzenenViewProps>;
 
-export { type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, type BestandsGalerieEintrag, type BestandsItem, CATALOGUE_TYPES, CapabilityAnchorError, type CapabilityFlag, type CapabilityFlagName, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClaimAndRunResult, type ClientDerivationChannel, type ClientDerivationStore, type CompletePromptOperationInput, type CompletePromptOperationResult, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateImageJobPortOptions, type CreateMemoryViewPortOptions, DEFAULT_SEED_VORLAGE, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, 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, GENERAL_POLICY_SUBTYPE, 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 ImageJob, type ImageJobChannel, type ImageJobClaimedPayload, type ImageJobRequestedPayload, type ImageJobSettledPayload, 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, MCP_CLIENT_PROVIDER, type NodeContribution, NotDerivable, type Notice, type NoticeTone, PROMPT_RULE_EFFECT, type PolicySnapshot, type PreparePromptOperationInput, type PreparePromptOperationResult, type PreparedPromptOperation, type PromptBatchImageRef, type PromptBatchOrigin, type PromptDiagnostic, type PromptEffect, type PromptExecutionOrigin, type PromptImageBatch, type PromptOperationPreparedPayload, type PromptResponseContract, type PromptRunFilter, type PromptRunGroup, type PromptRunListing, type PromptRunOutcome, type PromptRunOutput, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type PromptRunSource, type PromptRunStatusFilter, 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 ResolvedScenePolicy, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_EVENT_PREFIX, SZENEN_EVENT_TYPES, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, SZENEN_SNAPSHOT_FILE, SZENEN_SNAPSHOT_PREFIX, SZENEN_SNAPSHOT_SCHEMA_VERSION, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, type ScenePolicyResult, SchemaError, type SeedVorlage, type SeedZuordnung, type SeedZuordnungEintrag, type SelectableTargetModel, type StartImageGenerationInput, type StartRunFromSceneInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, type SzenenBatchSourceKind, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageJobPort, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenLeseErgebnis, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, type SzenenSeedTemplatePort, type SzenenSnapshot, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UNVERIFIED_MODEL_ID, UPLOAD_MAX_BYTES, type UnselectableTargetModel, UnusableProposal, type VersionMedium, type VisibilityNode, type ZipBild, areasFor, batchesForPromptRun, bildPfad, buildSystemInstruction, buildSzenenSnapshot, buildUserPrompt, callOptional, capabilitiesOf, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkImageExecutionProfile, checkImageExecutionProfiles, checkImageModelParameters, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, claimWon, collectImageBatches, collectImageGenerationOrders, collectImageJobs, collectPromptOperations, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, completePromptOperation, contextOfRun, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createImageJobPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, describableContent, diagnosticOfFinding, diagnosticOfSchemaError, differentialSteps, draftRevisionOf, executableImageModels, findExecutableImageModel, findImageBatch, findImageGenerationOrder, findImageJob, findPromptOperation, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, formatSeedListe, freezeDraftChain, freezeSceneWorkingState, generationBatchIdOf, gesamtHerkunft, groupKeyOf, groupOf, gruppiereZuItems, hasPlacementCapability, isKnownElementType, isSzenenItemId, istSzenenSnapshotDatei, istZipDatei, itemIdForRun, itemsAusBestand, jobsForPromptRun, ladeVorschauen, leseBilderAusZip, locatorAus, locatorTeile, logRevisionOf, mergeSnapshotAndPending, mergeSzenenBatchOrigin, mimeTypAus, mitDefaultVorlage, namingElementOf, noticeFor, ordersForPromptRun, ordneSeedsZu, parseRunResponse, parseSeedListe, parseSzenenSnapshot, preferredHeadRevisionOf, preparePromptOperation, promptDiagnosticsOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveGeneralScenePolicies, resolveScenePayload, resolveShot, resolveShotPayload, responseContractOf, roundOfRun, rulesWithoutPromptEffect, runOfOperation, runPromptDerivation, runStoreDifferential, sameResponseAs, sceneOnlyCapabilities, scenePolicyFingerprint, scopeOfPath, seedFehlerText, selectPromptRuns, selectableTargetModels, siblingsOf, sortScenePolicies, sourceOf, szenenSnapshotFilename, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };
+export { type AddManualSceneRunInput, type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, type BestandsGalerieEintrag, type BestandsItem, type BuildManualPromptRunInput, CATALOGUE_TYPES, CapabilityAnchorError, type CapabilityFlag, type CapabilityFlagName, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClaimAndRunResult, type ClientDerivationChannel, type ClientDerivationStore, type CompletePromptOperationInput, type CompletePromptOperationResult, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateImageJobPortOptions, type CreateMemoryViewPortOptions, DEFAULT_SEED_VORLAGE, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, ElementAnnotation, ElementEvent, type ElementEventChannel, type ExecutableImageModel, type ExecutionTargetModel, type ExistingSzenenItem, FLOW_EXECUTION_PATH, type FlowGenerateImage, type FlowGenerateImageParams, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSceneResult, type FreezeSceneSuccess, type FreezeSceneWorkingStateInput, type FreezeSuccess, type FrozenChainNode, type FrozenSceneState, GENERAL_POLICY_SUBTYPE, type GeneratedImage, type GruppierbaresBild, type HfImageStore, type HfImageStoreOptions, type IdFactory, type ImageExecutionProfile, type ImageExecutionRoute, type ImageExecutionTargetModelReader, type ImageGenerationBatchPersistence, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, type ImageHostCapability, type ImageJob, type ImageJobChannel, type ImageJobClaimedPayload, type ImageJobEintrag, type ImageJobHerkunft, type ImageJobQuery, type ImageJobRequestedPayload, type ImageJobSeite, type ImageJobSettledPayload, type ImageJobStatusFilter, type ImageModelChoice, type ImageModelParameters, ImageProvenance, type ImageProviderInput, type ImportBatchImageInput, type ImportBatchInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LetztesErzeugtesBild, type LibraryImage, type LibraryImageItem, LibraryTagRef, MANUAL_MODEL_ID, MANUAL_NODE_STATE, MANUAL_PROVIDER, MANUAL_VISIBILITY_BASIS, MCP_CLIENT_PROVIDER, type ManualPromptEntry, type ManualPromptRunRecord, type NodeContribution, NotDerivable, type Notice, type NoticeTone, PAUSE_SEKUNDEN_OPTIONEN, PAUSE_SEKUNDEN_VORGABE, PROMPT_AUSZUG_ZEICHEN, PROMPT_RULE_EFFECT, PROMPT_RUN_DETAIL_FIELDS, Page, PageRequest, type PolicySnapshot, PreferredHeadResolution, type PreparePromptOperationInput, type PreparePromptOperationResult, type PreparedPromptOperation, type PromptBatchImageRef, type PromptBatchOrigin, type PromptDiagnostic, type PromptEffect, type PromptExecutionOrigin, type PromptImageBatch, type PromptOperationPreparedPayload, type PromptResponseContract, PromptRunAnnotation, type PromptRunFilter, type PromptRunGroup, type PromptRunListRecord, type PromptRunListing, type PromptRunOriginFilter, type PromptRunOutcome, type PromptRunOutput, type PromptRunPage, type PromptRunPageFilter, type PromptRunPageInput, type PromptRunPageRecord, type PromptRunPageSource, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type PromptRunSource, type PromptRunStatusFilter, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, type QueueAusgang, type QueueFortschritt, type QueueLaufOptionen, type QueueZustand, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, ReferenceResolver, type RendererInput, type ResolveFailure, type ResolveResult, type ResolveScenePayloadInput, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type ResolvedScenePolicy, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, SZENEN_SNAPSHOT_FILE, SZENEN_SNAPSHOT_PREFIX, SZENEN_SNAPSHOT_SCHEMA_VERSION, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, type ScenePolicyResult, SchemaError, type SeedVorlage, type SeedZuordnung, type SeedZuordnungEintrag, type SelectableTargetModel, type StartImageGenerationInput, type StartRunFromSceneInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, type SzenenBatchSourceKind, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenFokus, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageJobPort, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenLeseErgebnis, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, type SzenenSeedTemplatePort, type SzenenSnapshot, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UNVERIFIED_MODEL_ID, UPLOAD_MAX_BYTES, type UnselectableTargetModel, UnusableProposal, type VersionMedium, type VisibilityNode, type ZipBild, areaForFokus, areasFor, batchesForPromptRun, bildPfad, buildManualPromptRunRecord, buildSystemInstruction, buildSzenenSnapshot, buildUserPrompt, callOptional, capabilitiesOf, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkImageExecutionProfile, checkImageExecutionProfiles, checkImageModelParameters, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, claimWon, collectImageBatches, collectImageGenerationOrders, collectImageJobs, collectPromptOperations, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, completePromptOperation, contextOfRun, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createImageJobPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, describableContent, detailFehlt, diagnosticOfFinding, diagnosticOfSchemaError, differentialSteps, executableImageModels, findExecutableImageModel, findImageBatch, findImageGenerationOrder, findImageJob, findPromptOperation, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, formatSeedListe, freezeDraftChain, freezeSceneWorkingState, fuehreQueueAus, generationBatchIdOf, gesamtHerkunft, groupKeyOf, groupOf, gruppiereZuItems, hasPlacementCapability, isKnownElementType, isSzenenItemId, istGueltigePause, istOffen, istSzenenSnapshotDatei, istZipDatei, itemIdForRun, itemsAusBestand, jobsForPromptRun, ladeVorschauen, leseBilderAusZip, letztesErzeugtesBild, locatorAus, locatorTeile, manualEntryOf, mergeSnapshotAndPending, mergeSzenenBatchOrigin, mimeTypAus, mitDefaultVorlage, namingElementOf, noticeFor, ordersForPromptRun, ordneSeedsZu, pagePromptRuns, parseRunResponse, parseSeedListe, parseSzenenSnapshot, preparePromptOperation, promptDiagnosticsOf, promptRunPageForTransport, promptRunPageFromTransport, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, resolveArea, resolveGeneralScenePolicies, resolveScenePayload, resolveShot, resolveShotPayload, responseContractOf, roundOfRun, roundsOf, rulesWithoutPromptEffect, runOfOperation, runPromptDerivation, runStoreDifferential, sameResponseAs, sceneOnlyCapabilities, scenePolicyFingerprint, scopeOfPath, seedFehlerText, selectImageJobs, selectPromptRuns, selectableTargetModels, siblingsOf, sortScenePolicies, sourceOf, szenenSnapshotFilename, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };