@rslsp1/fa-app-tools 9.0.0 → 9.4.4

package/dist/{storeContract-5vApx6VA.d.mts → storeContract-CJi0fpCA.d.mts}

@@ -978,7 +978,220 @@ declare function checkChainTargets(meta: DraftChainMeta, targets: readonly Chain
 /** Der Link eines Feldes, oder `null`. */
 declare function linkFor(meta: DraftChainMeta | null | undefined, field: ChainLinkField): DraftChainLink | null;
 
+/** Wie viele Eintraege eine Seite traegt, wenn niemand etwas anderes sagt. */
+declare const LOAD_MORE_PAGE_SIZE = 10;
+interface PageRequest {
+    /** Hoechstzahl der Eintraege dieser Seite. Muss groesser als 0 sein. */
+    limit: number;
+    /**
+     * Kennung des **letzten bereits geladenen** Eintrags, oder `null`/weggelassen
+     * fuer die erste Seite. Geliefert wird, was danach kommt.
+     */
+    after?: string | null;
+}
+interface Page<T> {
+    /** Die Eintraege dieser Seite, in der Reihenfolge der Eingabe. */
+    items: readonly T[];
+    /** Ob nach dieser Seite noch etwas kommt. */
+    hasMore: boolean;
+    /** Was als `after` der naechsten Seite mitzugeben ist. `null` am Ende. */
+    nextCursor: string | null;
+    /** Gesamtzahl der Eintraege **nach** Filter, **vor** dem Seitenschnitt. */
+    total: number;
+}
+/**
+ * Schneidet eine Seite aus einer bereits geordneten und gefilterten Liste.
+ *
+ * @param alle Alle Eintraege in Anzeigereihenfolge.
+ * @param idOf Stabile Kennung eines Eintrags — sie ist der Cursor.
+ * @param request Seitenwunsch. Ohne Angabe wird **nicht** geschnitten; die
+ *   Antwort traegt dann alles und `hasMore: false`. Das ist der bestehende
+ *   Vertrag jeder Operation, die diesen Schnitt nur optional anbietet.
+ * @throws Wenn `after` in `alle` nicht vorkommt.
+ */
+declare function pageOf<T>(alle: readonly T[], idOf: (eintrag: T) => string, request?: PageRequest | null): Page<T>;
+/**
+ * Liest einen Seitenwunsch aus Abfrageparametern — die eine Stelle, an der aus
+ * `limit`/`after` ein `PageRequest` wird.
+ *
+ * Ohne `limit` gibt es **keinen** Seitenschnitt (`null`): Eine Voreinstellung
+ * wuerde bestehende Aufrufer stillschweigend beschneiden. Ein unbrauchbares
+ * `limit` ist ein Fehler, keine Vorgabe.
+ */
+declare function pageRequestFrom(roh: {
+    limit?: unknown;
+    after?: unknown;
+} | null | undefined): PageRequest | null;
+
+/**
+ * Ein Tag in der Form, in der die Library ihn fuehrt.
+ *
+ * `l` ist das Label und die Identitaet — dieselbe, gegen die
+ * `resolveTagLabels` prueft. `v` und `cat` sind die aufgeloeste Vokabel und
+ * werden mitgefuehrt, nicht neu erfunden.
+ */
+interface LibraryTagRef {
+    l: string;
+    v?: string | null;
+    cat?: string | null;
+}
+/** Nutzlast von `szenen.prompt_run_tags_set` — der vollstaendige Tagsatz eines Laufs. */
+interface PromptRunTagsSetPayload {
+    run_id: string;
+    /** Der **ganze** Satz, nicht ein Delta: Entfernen ist ein kuerzerer Satz. */
+    tags: readonly LibraryTagRef[];
+    set_at: string;
+}
+/** Woher ein angezeigter Tag kommt. */
+type TagHerkunft = 'prompt' | 'library';
+/** Ein Tag, wie die Promptanzeige ihn zeigt — mit seiner Herkunft. */
+interface AngezeigterTag {
+    label: string;
+    value: string | null;
+    category: string | null;
+    /**
+     * Alle Herkuenfte dieses Labels, in der Reihenfolge `prompt` vor `library`.
+     *
+     * Ein Tag kann **beides** sein. Genau dieser Fall entscheidet die
+     * Bearbeitung: Nur `prompt` darf am Lauf entfernt werden, `library` nicht —
+     * und ein Tag, der beides ist, verliert beim Entfernen nur seine
+     * Prompt-Zuordnung, nicht seine Library-Herkunft.
+     */
+    herkunft: readonly TagHerkunft[];
+}
+/**
+ * Liest eine Tagliste, wie sie in `user_library.tags` oder in einem
+ * Tag-Ereignis steht.
+ *
+ * Fail loud (Regel 4): Ein Eintrag ohne brauchbares Label ist ein Datenfehler
+ * und wird benannt, nicht uebersprungen. Ein uebersprungener Tag saehe aus wie
+ * „dieses Item hat den Tag nicht" und waere von der Wahrheit nicht zu
+ * unterscheiden.
+ *
+ * @param quelle Woher die Liste stammt — steht in der Fehlermeldung.
+ */
+declare function tagRefsAus(roh: unknown, quelle: string): readonly LibraryTagRef[];
+/**
+ * Die direkten Tags **jedes** Laufs aus dem Ereignislog.
+ *
+ * Der letzte Satz je `run_id` gilt. Anders als bei `collectPromptRuns` gewinnt
+ * hier nicht der erste: Ein Lauf ist unveraenderlich, seine Beschlagwortung ist
+ * es ausdruecklich nicht — sie ist eine Auswahl, die revidiert werden darf.
+ */
+declare function collectPromptRunTags(events: readonly ElementEvent[]): ReadonlyMap<string, readonly LibraryTagRef[]>;
+/** Die direkten Tags genau eines Laufs. */
+declare function promptRunTagsOf(events: readonly ElementEvent[], runId: string): readonly LibraryTagRef[];
+/**
+ * Die gemeinsame sichtbare Tag-Menge eines Prompts.
+ *
+ * Reihenfolge: erst die Prompt-Tags in ihrer gespeicherten Reihenfolge, dann
+ * die Library-Tags, die noch nicht dabei waren. Dubletten werden ueber das
+ * **Label** zusammengefuehrt — es ist die Identitaet eines Tags in der
+ * Vokabel-Tabelle (`resolveTagLabels` sucht ueber `label`).
+ *
+ * Zusammengefuehrt wird nur die Anzeige. Welcher Tag am Prompt haengt, bleibt
+ * an `herkunft` ablesbar; die Bearbeitung liest genau dieses Feld.
+ */
+declare function mergeRunTags(promptTags: readonly LibraryTagRef[], libraryTags: readonly LibraryTagRef[]): readonly AngezeigterTag[];
+/** Nur die Labels — die Form, in der der Schreibweg Tags entgegennimmt. */
+declare function labelsOf(tags: readonly LibraryTagRef[]): readonly string[];
+
+/** Das Vorschaubild einer Promptkarte — ein Locator, keine Bilddaten. */
+interface PromptRunPreviewImage {
+    /** Derselbe Locator wie im Batch (D-118) — aufgeloest ueber den Bildbestand. */
+    media_ref: string;
+    /** Soweit der Nachweis ihn fuehrt; aeltere Batches tragen ihn nicht. */
+    mime_type: string | null;
+}
+/**
+ * Was die Karte ueber die Ergebnisse eines Laufs weiss.
+ *
+ * `imageCount: 0` heisst **belegt keine Bilder** — nicht „unbekannt". Die
+ * Unterscheidung traegt das Feld nicht, sondern die Anwesenheit der Annotation
+ * selbst: Ein Host, der den Bestand nicht lesen kann, liefert sie nicht
+ * (D-75).
+ */
+interface PromptRunAnnotation {
+    /** Wie viele Bilder dem Lauf ueber seine Batches zugeordnet sind. */
+    imageCount: number;
+    /** Ein Bild als Vorschau, oder `null` — bei `imageCount === 0` immer `null`. */
+    previewImage: PromptRunPreviewImage | null;
+    /**
+     * Die Library-Items dieses Laufs. Sie stehen hier, weil die Tag-Herkunft
+     * daran haengt und der Host sonst nicht wuesste, welche Items er nachschlagen
+     * soll.
+     */
+    itemIds: readonly string[];
+    /**
+     * Die Tags dieser Items — **abgeleitet**, nie am Lauf gespeichert.
+     *
+     * Leer, wenn die Items keine Tags haben **oder** der Host sie nicht lesen
+     * konnte. Diese beiden Faelle zu trennen waere hier eine Erfindung: Der
+     * Aufrufer weiss, ob er die Vokabel gefragt hat.
+     */
+    libraryTags: readonly LibraryTagRef[];
+}
+interface AnnotateRunsOptions {
+    /**
+     * Tags je `item_id`, soweit der Host sie lesen kann.
+     *
+     * Fehlt die Angabe, tragen alle Annotationen `libraryTags: []`. Die Bilder
+     * stimmen trotzdem — sie kommen aus dem Log.
+     */
+    libraryTagsByItem?: ReadonlyMap<string, readonly LibraryTagRef[]>;
+}
+/**
+ * Die Annotationen **aller** Laeufe, die im Log ein Batch haben.
+ *
+ * Ein einziger Durchlauf ueber `collectImageBatches()`. Ein Lauf ohne Batch
+ * kommt nicht vor — der Aufrufer liest das als „null Bilder", und die Karte
+ * zeigt dann keine leere Bildflaeche, sondern nur die Zahl.
+ *
+ * Die Vorschau ist das Bild mit der kleinsten `position` im **ersten** Batch
+ * des Laufs. Stabil gewaehlt und nicht geraten: Dieselbe Karte zeigt morgen
+ * dasselbe Bild, auch wenn spaeter Batches dazukommen (D-113 — ein Lauf bleibt
+ * ein Item, weitere Batches werden angehaengt).
+ */
+declare function annotateRunsFromEvents(events: readonly ElementEvent[], options?: AnnotateRunsOptions): ReadonlyMap<string, PromptRunAnnotation>;
+/** Die Annotation eines Laufs, oder die leere Aussage „keine Bilder". */
+declare const KEINE_BILDER: PromptRunAnnotation;
+/** Was eine Elementkarte ueber die Ergebnisse ihres Elements weiss. */
+interface ElementAnnotation {
+    /** Bilder ueber **alle** Laeufe dieses Elements. */
+    imageCount: number;
+    /** Das Deckbild, oder `null`. */
+    previewImage: PromptRunPreviewImage | null;
+    /** Die Library-Items aller Laeufe — der Nachschlagepunkt fuer die Tags. */
+    itemIds: readonly string[];
+    /** Die direkten Tags der Laeufe, zusammengefuehrt ueber das Label. */
+    promptTags: readonly LibraryTagRef[];
+    /** Die Tags der zugeordneten Library-Items, ebenso zusammengefuehrt. */
+    libraryTags: readonly LibraryTagRef[];
+}
+/**
+ * Die Annotationen **aller** Elemente, die mindestens einen Lauf haben.
+ *
+ * Ein Durchgang ueber die Laeufe in Logreihenfolge. Welches Element zu einem
+ * Lauf gehoert, entscheidet `namingElementOf()` — dieselbe Funktion, aus der
+ * die Laufliste ihren Titel holt. Zwei Zuordnungsregeln waeren zwei
+ * Wahrheiten darueber, wessen Lauf das ist.
+ *
+ * Das Deckbild ist die Vorschau des **juengsten** Laufs mit Bildern. Anders
+ * als bei der Promptkarte, die ihr erstes Bild behaelt: Eine Szene wird
+ * weiterbearbeitet, und ihr Deckbild soll den aktuellen Stand zeigen, nicht
+ * den ersten Versuch. Deterministisch bleibt es trotzdem — dieselben
+ * Ereignisse ergeben dasselbe Bild.
+ */
+declare function annotateElementsFromEvents(events: readonly ElementEvent[], options?: AnnotateRunsOptions): ReadonlyMap<string, ElementAnnotation>;
+
 /** Element-Stammsatz (`elements`, §2.1). Nach Anlage unveränderlich: `id`, `type`. */
+/** Der Filter beider Elementlisten — ein Typ, damit sie nicht auseinanderlaufen. */
+interface ElementListFilter {
+    contextId?: string | null;
+    type?: SzenenElementType;
+    types?: readonly SzenenElementType[];
+    includeRetired?: boolean;
+}
 interface ElementRecord {
     element_id: string;
     /** Lesbarer Stammtitel fuer Listen und Auswahlen; kein Versionsinhalt (D-35). */
@@ -1088,12 +1301,23 @@ type SzenenCommandResult<T, C = T> = CommandResult<T> | WriteConflict<C> | Publi
 /** Lesezugriffe auf den Elementspeicher. */
 interface SzenenQueries {
     /** Alle Elemente eines Kontexts, optional nach einem Typ oder einer Typmenge gefiltert. */
-    listElements(filter?: {
-        contextId?: string | null;
-        type?: SzenenElementType;
-        types?: readonly SzenenElementType[];
-        includeRetired?: boolean;
-    }): Promise<QueryResult<readonly ElementRecord[]>>;
+    listElements(filter?: ElementListFilter): Promise<QueryResult<readonly ElementRecord[]>>;
+    /**
+     * **Eine Seite** Elemente, neueste zuerst — Kette `szenen-listen-pagination`.
+     *
+     * Derselbe Speicher, derselbe Filter, dieselbe Sichtbarkeitsregel wie
+     * `listElements`; nur wird nicht alles uebertragen. „Neueste zuerst" ist die
+     * umgekehrte Reihenfolge des Ereignislogs — ein Element traegt keinen
+     * Zeitstempel, und einen zu erfinden waere eine Aussage ohne Beleg (D-75).
+     *
+     * `listElements` bleibt unveraendert: Die Zielmodellauflösung, die
+     * Kontextsichtbarkeit und die Policy-Suche brauchen **alle** Kandidaten und
+     * duerfen keine Seite bekommen.
+     *
+     * Optional, damit kein bestehender Implementierer der oeffentlichen
+     * Schnittstelle bricht. Fehlt sie, laedt die Ansicht vollstaendig weiter.
+     */
+    listElementsPage?(filter?: ElementListFilter, page?: PageRequest | null): Promise<QueryResult<ElementPage>>;
     /** Vollständiger Stand eines Elements, oder `null`, wenn unbekannt. */
     getElement(elementId: string): Promise<QueryResult<ElementSnapshot | null>>;
     /**
@@ -1149,6 +1373,32 @@ interface ContextChainPort {
      */
     chainFor(contextId: string | null): Promise<QueryResult<readonly (string | null)[]>>;
 }
+/**
+ * `listElementsPage` aus einem vorhandenen `listElements` — die eine
+ * Implementierung fuer alle Speicher.
+ *
+ * Warum als Adapter und nicht in jedem Speicher neu: Der Filter, die
+ * Sichtbarkeitsregel (D-04) und die Reihenfolge stehen damit weiterhin genau
+ * einmal — im jeweiligen `listElements`. Dieser Adapter dreht und schneidet,
+ * er entscheidet nichts.
+ *
+ * **Neueste zuerst** ist die umgekehrte Reihenfolge des Ereignislogs. Ein
+ * Element traegt keinen Zeitstempel (`ElementRecord`); die Anlagereihenfolge
+ * ist das, was belegbar ist. Einen Zeitstempel zu erfinden oder nach Titel zu
+ * sortieren waere eine andere Aussage als „neueste zuerst".
+ */
+/**
+ * Eine Seite Elemente, dazu was ihre Laeufe hergeben — Kette
+ * `szenen-prompt-anzeige-bilder-tags`.
+ *
+ * `annotations` fehlt, wo der Host den Laufbestand nicht lesen kann. Das ist
+ * eine andere Aussage als „keine Bilder" und wird deshalb nicht mit Nullen
+ * gefuellt (D-75).
+ */
+interface ElementPage extends Page<ElementRecord> {
+    annotations?: Readonly<Record<string, ElementAnnotation>>;
+}
+declare function listElementsPageOver(liste: (filter?: ElementListFilter) => Promise<QueryResult<readonly ElementRecord[]>>, filter?: ElementListFilter, page?: PageRequest | null): Promise<QueryResult<Page<ElementRecord>>>;
 /**
  * Macht aus einem Lese-Port den `ReferenceResolver` der Publish-Prüfungen.
  *
@@ -1324,6 +1574,292 @@ declare const isOk: <T, C>(result: SzenenCommandResult<T, C>) => result is {
     value: T;
 };
 
+/** 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";
+    /**
+     * Die direkten Tags eines Prompt-Laufs — Kette
+     * `szenen-prompt-anzeige-bilder-tags`.
+     *
+     * Ein eigener Typ, **kein** Feld am Lauf: Ein Lauf ist unveraenderlich
+     * (E-3b), seine Beschlagwortung ist es ausdruecklich nicht. Die Nutzlast
+     * traegt jedes Mal den **vollstaendigen** Satz; Entfernen ist ein kuerzerer
+     * Satz, kein Loeschereignis, weil ein append-only Log nichts zuruecknehmen
+     * kann und ein Delta-Paar (`added`/`removed`) beim ersten verlorenen
+     * Ereignis auseinanderliefe.
+     *
+     * Die Tags sind Library-Vokabeln in der Library-Form `{ l, v, cat }` und
+     * werden auf dem Schreibweg gegen `tags` aufgeloest — es gibt kein zweites
+     * Tag-Vokabular fuer Prompts. Tags **zugeordneter Library-Items** stehen
+     * nie hier: Sie sind ueber die Relation Lauf → Item ableitbar, und eine
+     * Kopie waere ab dem naechsten Library-Edit falsch.
+     *
+     * Der Elementreducer ignoriert diesen Typ (`default:`-Zweig); gelesen wird
+     * mit `collectPromptRunTags` (`promptRunTags.ts`).
+     */
+    readonly promptRunTagsSet: "szenen.prompt_run_tags_set";
+};
+/** 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;
+
 /** Optionale Kommandos, ohne die einzelne Prüfungen entfallen. */
 type OptionalCommand = 'setPreferredHead' | 'reviseMetadata' | 'retireElement';
 /** Eine einzelne Vertragsprüfung. */
@@ -1392,4 +1928,4 @@ interface ContractRunResult {
  */
 declare function runElementStoreContract(harness: ElementStoreContractHarness): Promise<ContractRunResult>;
 
-export { type PublishVersionInput as $, ALL_PUBLISH_RULES as A, type DraftChainMeta as B, CHAIN_EDGES as C, DERIVABLE_TYPES as D, type DraftFork as E, type DraftRecord as F, type ElementMetadata as G, type ElementRecord as H, type ElementSnapshot as I, type ElementStoreContractHarness as J, type ElementVersionValidation as K, type FindingSeverity as L, type ImageProvenance as M, type NotDerivable as N, type OptionalCommand as O, PROBE_VERSION_ID as P, type ParentRelation as Q, type PreferredHeadOutcome as R, type PreferredHeadResolution as S, type PreferredHeadSelection as T, type PreferredHeadSource as U, type ProjectionState as V, type ProjectionStatus as W, type PublishCheckInput as X, type PublishCheckResult as Y, type PublishFinding as Z, type PublishRejected as _, type AuthoritativeSzenenStore as a, validatePayload as a$, type PublishedVersion as a0, REFERENCE_FIELD as a1, type ReferenceResolver as a2, type ResolvePreferredHeadOptions as a3, type ResolvedVersion as a4, type ReviseMetadataInput as a5, STYLE_PAYLOAD as a6, STYLE_PAYLOAD_V2 as a7, SZENEN_ELEMENT_TYPES as a8, type SceneDerivationInput as a9, buildUserPrompt as aA, buildVersionDag as aB, checkChainTargets as aC, checkDerivationResponse as aD, checkDraftChainMeta as aE, collectVersionRefs as aF, compileSchemas as aG, createSimulationSceneDerivationPort as aH, describeTargetModelFailure as aI, elementStoreContractChecks as aJ, formatSchemaErrors as aK, getSzenenSchemas as aL, isOk as aM, isProjectionCurrent as aN, linkFor as aO, parseDerivationResponse as aP, preferredVersionId as aQ, resolvePreferredHead as aR, resolveTargetModelOver as aS, resolverFromQueries as aT, runElementStoreContract as aU, runPublishChecks as aV, runSceneDerivation as aW, showChain as aX, validateAgainst as aY, validateDerivationInput as aZ, validateElementVersion as a_, type SceneDerivationOutcome as aa, type SceneDerivationOutput as ab, type SchemaError as ac, type SchemaValidationResult as ad, type SetPreferredHeadInput as ae, type StoreAuthority as af, type SzenenCommandResult as ag, type SzenenCommands as ah, type SzenenElementStore as ai, type SzenenElementType as aj, type SzenenProjection as ak, type SzenenQueries as al, type TargetModelCandidate as am, type TargetModelQueries as an, type TargetModelQuery as ao, type TargetModelResolution as ap, UnsupportedSchemaError as aq, type UnusableProposal as ar, type VersionDag as as, VersionDagError as at, type VersionNode as au, type VersionParentLink as av, type WriteConflict as aw, type WriteDraftInput as ax, assessDerivationResponse as ay, buildSystemInstruction as az, CHAIN_LINK_FIELDS as b, withReference as b0, type CatalogueEntry as c, type ChainLinkField as d, type ChainTarget as e, type ChainVerdict as f, type CompiledSchemas as g, type ContextChainPort as h, type ContractCheck as i, type ContractCheckResult as j, type ContractRunResult as k, ContractViolation as l, type CreateElementInput as m, type DerivableType as n, type DerivationAssessment as o, type DerivationConflict as p, type DerivationDiagnostic as q, type DerivationEnvelope as r, type DerivationFailure as s, type DerivationFailureClass as t, type DerivationFollowUp as u, type DerivationImage as v, type DerivationInputMode as w, type DerivationPolicyPayload as x, type DerivationProposal as y, type DraftChainLink as z };
+export { type Page as $, ALL_PUBLISH_RULES as A, type DerivationProposal as B, CHAIN_EDGES as C, DERIVABLE_TYPES as D, type DraftChainLink as E, type DraftChainMeta as F, type DraftFork as G, type DraftRecord as H, type ElementAnnotation as I, type ElementEvent as J, type ElementListFilter as K, type ElementMetadata as L, type ElementRecord as M, type ElementSnapshot as N, type ElementStoreContractHarness as O, type ElementStoreState as P, type ElementVersionValidation as Q, type FindingSeverity as R, type ImageBatchPersistedImage as S, type ImageBatchPersistedPayload as T, type ImageProvenance as U, KEINE_BILDER as V, LOAD_MORE_PAGE_SIZE as W, type LibraryTagRef as X, type NotDerivable as Y, type OptionalCommand as Z, PROBE_VERSION_ID as _, type AngezeigterTag as a, collectPromptRunTags as a$, type PageRequest as a0, type ParentRelation as a1, type PreferredHeadOutcome as a2, type PreferredHeadResolution as a3, type PreferredHeadSelection as a4, type PreferredHeadSource as a5, type ProjectionState as a6, type ProjectionStatus as a7, type PromptRunAnnotation as a8, type PromptRunPreviewImage as a9, type SzenenCommands as aA, type SzenenElementStore as aB, type SzenenElementType as aC, type SzenenProjection as aD, type SzenenQueries as aE, type TagHerkunft as aF, type TargetModelCandidate as aG, type TargetModelQueries as aH, type TargetModelQuery as aI, type TargetModelResolution as aJ, UnsupportedSchemaError as aK, type UnusableProposal as aL, type VersionDag as aM, VersionDagError as aN, type VersionNode as aO, type VersionParentLink as aP, type WriteConflict as aQ, type WriteDraftInput as aR, annotateElementsFromEvents as aS, annotateRunsFromEvents as aT, assessDerivationResponse as aU, buildSystemInstruction as aV, buildUserPrompt as aW, buildVersionDag as aX, checkChainTargets as aY, checkDerivationResponse as aZ, checkDraftChainMeta as a_, type PromptRunTagsSetPayload as aa, type PublishCheckInput as ab, type PublishCheckResult as ac, type PublishFinding as ad, type PublishRejected as ae, type PublishVersionInput as af, type PublishedVersion as ag, REFERENCE_FIELD as ah, type ReducerFinding as ai, type ReferenceResolver as aj, type ResolvePreferredHeadOptions as ak, type ResolvedVersion as al, type ReviseMetadataInput as am, STYLE_PAYLOAD as an, STYLE_PAYLOAD_V2 as ao, SZENEN_ELEMENT_TYPES as ap, SZENEN_EVENT_PREFIX as aq, SZENEN_EVENT_TYPES as ar, type SceneDerivationInput as as, type SceneDerivationOutcome as at, type SceneDerivationOutput as au, type SchemaError as av, type SchemaValidationResult as aw, type SetPreferredHeadInput as ax, type StoreAuthority as ay, type SzenenCommandResult as az, type AnnotateRunsOptions as b, collectVersionRefs as b0, compileSchemas as b1, createSimulationSceneDerivationPort as b2, describeTargetModelFailure as b3, draftRevisionOf as b4, elementStoreContractChecks as b5, formatSchemaErrors as b6, getSzenenSchemas as b7, isOk as b8, isProjectionCurrent as b9, labelsOf as ba, linkFor as bb, listElementsPageOver as bc, logRevisionOf as bd, mergeRunTags as be, pageOf as bf, pageRequestFrom as bg, parseDerivationResponse as bh, preferredHeadRevisionOf as bi, preferredVersionId as bj, promptRunTagsOf as bk, reduceElementEvents as bl, resolvePreferredHead as bm, resolveTargetModelOver as bn, resolverFromQueries as bo, runElementStoreContract as bp, runPublishChecks as bq, runSceneDerivation as br, showChain as bs, tagRefsAus as bt, validateAgainst as bu, validateDerivationInput as bv, validateElementVersion as bw, validatePayload as bx, withReference as by, type AuthoritativeSzenenStore as c, CHAIN_LINK_FIELDS as d, type CatalogueEntry as e, type ChainLinkField as f, type ChainTarget as g, type ChainVerdict as h, type CompiledSchemas as i, type ContextChainPort as j, type ContractCheck as k, type ContractCheckResult as l, type ContractRunResult as m, ContractViolation as n, type CreateElementInput as o, type DerivableType as p, type DerivationAssessment as q, type DerivationConflict as r, type DerivationDiagnostic as s, type DerivationEnvelope as t, type DerivationFailure as u, type DerivationFailureClass as v, type DerivationFollowUp as w, type DerivationImage as x, type DerivationInputMode as y, type DerivationPolicyPayload as z };