@rslsp1/fa-app-tools 2.0.78 → 2.0.82

package/dist/storeContract-B2BDgvhN.d.mts

@@ -0,0 +1,1379 @@
+import { Q as QueryResult, T as TextGenerationPort, C as CommandResult } from './contracts-DdYOMBl9.mjs';
+
+/** Ein einzelner Validierungsbefund, im Aufbau an ajv angelehnt. */
+interface SchemaError {
+    /** JSON-Pointer auf die fehlerhafte Stelle in der Instanz, z.B. `/payload/nodes/0`. */
+    instancePath: string;
+    /** Menschenlesbare Ursache. */
+    message: string;
+    /** Schlüsselwort, das gegriffen hat, z.B. `required` oder `additionalProperties`. */
+    keyword: string;
+    /**
+     * Bei `keyword === 'required'`: der Name des fehlenden Pflichtfelds.
+     *
+     * Er steht auch in `message`, aber dort als Prosa. Wer die Fehlstelle
+     * maschinell adressieren will — die Rekonstruktion tut das —, müsste sie
+     * sonst aus dem Text parsen. Ein Feldname, der über eine Zeichenkettensuche
+     * rekonstruiert wird, ist genau die Sorte Kopplung, die später still bricht.
+     */
+    property?: string;
+}
+type Json = unknown;
+type SchemaObject = Record<string, Json>;
+/** Aufgelöste Schemasammlung, bereit zum Validieren. */
+interface CompiledSchemas {
+    /** Schema-Dokumente, geschlüsselt nach `$id`. */
+    byId: Map<string, SchemaObject>;
+    /** `$id` je Quelldateiname, z.B. `scene.schema.json`. */
+    idByFile: Map<string, string>;
+}
+/** Wirft bei einem Schema, das dieser Validator nicht vollständig abdeckt. */
+declare class UnsupportedSchemaError extends Error {
+}
+/**
+ * Baut die Schemaregistry auf und prüft dabei jedes Dokument auf Abdeckung.
+ *
+ * @param schemasByFile Rohschemas, geschlüsselt nach Quelldateiname.
+ * @throws UnsupportedSchemaError bei fehlendem `$id` oder unbekanntem Schlüsselwort.
+ */
+declare function compileSchemas(schemasByFile: Record<string, SchemaObject>): CompiledSchemas;
+/** Ergebnis einer Schemaprüfung. */
+interface SchemaValidationResult {
+    valid: boolean;
+    errors: SchemaError[];
+}
+/**
+ * Validiert eine Instanz gegen ein Schema aus der Registry.
+ *
+ * @param schemas Registry aus `compileSchemas`.
+ * @param file Quelldateiname des Einstiegsschemas, z.B. `element-version.schema.json`.
+ * @param instance Zu prüfender Wert.
+ */
+declare function validateAgainst(schemas: CompiledSchemas, file: string, instance: Json): SchemaValidationResult;
+
+/** Die dreizehn Elementtypen des Modells. Reihenfolge wie im Umschlagschema. */
+declare const SZENEN_ELEMENT_TYPES: readonly ["scene_component", "scene", "shot_concept", "camera_preset", "camera_pattern", "style", "scene_setup", "shot", "prompt_policy", "prompt_fragment", "target_model", "sequence", "scene_derivation_policy"];
+type SzenenElementType = (typeof SZENEN_ELEMENT_TYPES)[number];
+
+/** Ergebnis der strukturellen Prüfung einer Elementversion. */
+interface ElementVersionValidation {
+    valid: boolean;
+    errors: SchemaError[];
+}
+/**
+ * Kompiliert die Schemaregistry beim ersten Aufruf und merkt sie sich.
+ *
+ * @throws UnsupportedSchemaError wenn ein Schema ein Schlüsselwort verwendet,
+ * das der Validator nicht prüft. Das ist Absicht: lieber ein Fehler beim Start
+ * als eine Prüfung, die stillschweigend nichts tut.
+ */
+declare function getSzenenSchemas(): CompiledSchemas;
+/**
+ * Prüft eine vollständige Elementversion (Umschlag + typisierte Payload).
+ *
+ * Der Umschlag wählt über `type` das passende Payload-Schema — ein untypisiertes
+ * `inhalt JSON` ist ausdrücklich unzulässig (Blocker 4 des PR-336-Reviews).
+ *
+ * @param candidate Der zu prüfende Wert, üblicherweise frisch geparstes JSON.
+ */
+declare function validateElementVersion(candidate: unknown): ElementVersionValidation;
+/**
+ * Prüft nur die Payload eines bekannten Typs, ohne Umschlag.
+ *
+ * Gedacht für Editoren, die eine Payload prüfen wollen, bevor Umschlagfelder wie
+ * `server_received_at` überhaupt existieren — beim Entwurf gibt es die noch nicht.
+ */
+declare function validatePayload(type: SzenenElementType, payload: unknown): ElementVersionValidation;
+/** Fehlerliste als einzeiliger Text, für Logs und Fehlermeldungen. */
+declare function formatSchemaErrors(errors: readonly SchemaError[]): string;
+
+/** Art der Abstammung zwischen zwei Versionen (`element_version_parents.relation`). */
+type ParentRelation = 'derived_from' | 'merged_from';
+/** Kante zum Vorgänger. */
+interface VersionParentLink {
+    parent_version_id: string;
+    relation: ParentRelation;
+}
+/**
+ * Knoten des Versions-DAG.
+ *
+ * Bewusst **ohne** `client_created_at`, `server_received_at` oder eine
+ * Sequenznummer: Abstammung kommt ausschließlich aus `parents` (§2.4).
+ */
+interface VersionNode {
+    version_id: string;
+    element_id: string;
+    parents: readonly VersionParentLink[];
+}
+/** Ein Aufbaufehler des Graphen. Er verhindert den Aufbau, er meldet nicht nur. */
+declare class VersionDagError extends Error {
+}
+/** Aufgebauter, zyklenfreier Versionsgraph eines Elements. */
+interface VersionDag {
+    readonly elementId: string;
+    /** Alle Versionskennungen, in Eingabereihenfolge. */
+    readonly versionIds: readonly string[];
+    /** Version zu einer Kennung, oder `undefined`. */
+    get(versionId: string): VersionNode | undefined;
+    /** Direkte Vorgänger. */
+    parentsOf(versionId: string): readonly VersionParentLink[];
+    /** Direkte Nachfolger. */
+    childrenOf(versionId: string): readonly string[];
+    /** Versionen ohne Nachfolger — die Heads (`all_heads`, §2.5). */
+    heads(): readonly string[];
+    /** Versionen ohne Vorgänger. Normalerweise genau eine. */
+    roots(): readonly string[];
+    /** Mehr als ein Head (`has_fork`, §2.5). */
+    hasFork(): boolean;
+    /** Alle Vorfahren, transitiv, ohne die Version selbst. */
+    ancestorsOf(versionId: string): ReadonlySet<string>;
+    /** Alle Nachfahren, transitiv, ohne die Version selbst. */
+    descendantsOf(versionId: string): ReadonlySet<string>;
+    /** Ob `candidate` ein echter Vorfahre von `versionId` ist. */
+    isAncestorOf(candidate: string, versionId: string): boolean;
+}
+/**
+ * Baut den Versions-DAG eines Elements auf.
+ *
+ * Der Aufbau ist streng: doppelte Versionen, fremde Elemente, unbekannte
+ * Parents und Zyklen brechen ab. Ein halb gültiger Abstammungsgraph ist
+ * schlimmer als keiner — auf ihm ruht die Auflösung des Preferred Head.
+ *
+ * @param versions Alle bekannten Versionen **eines** Elements.
+ * @throws VersionDagError bei Duplikat, Fremdelement, unbekanntem Parent, Selbstbezug oder Zyklus.
+ */
+declare function buildVersionDag(versions: readonly VersionNode[]): VersionDag;
+/**
+ * Auswahl eines Heads für einen Kontext (`element_preferred_heads`).
+ *
+ * Ohne Zeitstempel — die Auswahl gilt, weil jemand sie getroffen hat, nicht
+ * weil sie die jüngste ist.
+ */
+interface PreferredHeadSelection {
+    context_id: string | null;
+    version_id: string;
+}
+/** Woher die geltende Auswahl stammt. Entspricht den Stufen 1–3 aus D-36. */
+type PreferredHeadSource = 
+/** Der Arbeitskontext hat eine eigene Auswahl (Stufe 1). */
+'context'
+/** Ein erbender Kontext der Kette, nach `priority` (Stufe 2). */
+ | 'inherited'
+/** Der Kontext, in dem das Element liegt (Stufe 3). */
+ | 'owning';
+/** Ergebnis der Auflösung. */
+type PreferredHeadResolution = 
+/** Genau ein Head, keine Auswahl nötig. */
+{
+    kind: 'single';
+    versionId: string;
+    heads: readonly string[];
+}
+/** Eine Auswahl greift. */
+ | {
+    kind: 'selected';
+    versionId: string;
+    source: PreferredHeadSource;
+    /** `null` = die Auswahl gilt für kontextlose Arbeit. */
+    contextId: string | null;
+    heads: readonly string[];
+    /** Die gewählte Version ist inzwischen kein Head mehr — jemand hat weitergebaut. */
+    stale: boolean;
+}
+/**
+ * Mehrere Heads und nirgends eine Auswahl (D-36 Punkt 4). **Kein** Head wird
+ * bevorzugt; die UI zeigt den Fork und verlangt eine Entscheidung.
+ */
+ | {
+    kind: 'fork';
+    heads: readonly string[];
+};
+/** Eingaben der Auflösung. */
+interface ResolvePreferredHeadOptions {
+    dag: VersionDag;
+    /**
+     * Kontext, in dem gearbeitet wird.
+     *
+     * `null` ist zulaessig und bedeutet **kontextlos** — nicht „egal". Der
+     * Serveraufrufer hat von Anfang an `null` durchgereicht; der Typ sagte
+     * `string` und verdeckte das, solange nur JavaScript ihn aufrief.
+     */
+    workingContextId: string | null;
+    /**
+     * Erbende Kontexte zwischen Arbeitskontext und besitzendem Kontext,
+     * **bereits nach `priority` sortiert** (höchste zuerst). Die Kette selbst
+     * liegt in der Zuständigkeit der Workspace-Domain, nicht hier.
+     */
+    inheritanceChain?: readonly string[];
+    /** Kontext, in dem das Element liegt. `null` = kontextloses Element. */
+    owningContextId?: string | null;
+    /** Alle bekannten Auswahlen dieses Elements, über alle Kontexte. */
+    selections?: readonly PreferredHeadSelection[];
+}
+/** Auflösung samt Befunden, die nicht das Ergebnis ändern, aber sichtbar gehören. */
+interface PreferredHeadOutcome {
+    resolution: PreferredHeadResolution;
+    /**
+     * Auswahlen, die auf eine dem Graphen unbekannte Version zeigen. Sie werden
+     * übersprungen, damit die Kette weiterläuft — aber nicht verschwiegen: das ist
+     * ein Datenfehler, kein Normalfall.
+     */
+    ignoredSelections: readonly PreferredHeadSelection[];
+}
+/**
+ * Löst den Preferred Head entlang der Vererbungskette auf (D-36).
+ *
+ * Reihenfolge: eigener Kontext → erbende Kontexte nach `priority` → besitzender
+ * Kontext. Greift nirgends eine Auswahl und gibt es mehr als einen Head, ist das
+ * Ergebnis `fork` — **niemals** ein automatisch gewählter Head. Der zeitlich
+ * jüngste Head zu nehmen wäre `MAX(ts)` durch die Hintertür und genau der
+ * Fehler, den §2.5 abstellt.
+ */
+declare function resolvePreferredHead(options: ResolvePreferredHeadOptions): PreferredHeadOutcome;
+/**
+ * Die aufzulösende Version, oder `null`, wenn eine Entscheidung aussteht.
+ *
+ * Bequemlichkeit für Aufrufer, die nur den Erfolgsfall brauchen. `null` ist ein
+ * regulärer Zustand und **kein** Anlass, einen Head zu raten.
+ */
+declare function preferredVersionId(resolution: PreferredHeadResolution): string | null;
+
+/** Ein Kandidat der Suche, so wie ihn eine Meldung nennen können muss. */
+interface TargetModelCandidate {
+    elementId: string;
+    contextId: string | null;
+}
+/**
+ * Ergebnis der Zielmodell-Auflösung.
+ *
+ * **Jeder Ausgang ist eigenständig.** Keiner fällt auf `null` zusammen, und
+ * keiner wird zu einem anderen vereinfacht: „nirgends vorhanden", „vorhanden,
+ * aber stillgelegt", „mehrdeutig" und „Fork" sind vier verschiedene Aussagen
+ * über den Bestand und verlangen vier verschiedene Meldungen.
+ */
+type TargetModelResolution = {
+    kind: 'resolved';
+    elementId: string;
+    versionId: string;
+    payload: unknown;
+    contextId: string | null;
+    /** Glied der Kette, auf dem der Treffer lag. `0` = Arbeitskontext. */
+    chainIndex: number;
+    /** Wie die Version bestimmt wurde — unverändert aus `resolvePreferredHead`. */
+    head: PreferredHeadResolution;
+    /**
+     * Stillgelegte Kandidaten, die auf dem Weg übergangen wurden (E-7).
+     *
+     * Stilllegen ist Ausblenden (D-04): Der Kandidat verlässt den Suchraum,
+     * die Kette läuft weiter. **Aber nie still** — wer eine lokale
+     * Feinabstimmung stilllegt, bekommt fortan ein anderes Modell, und genau
+     * das steht hier.
+     */
+    shadowedRetired: readonly TargetModelCandidate[];
+}
+/** Nirgends in der Kette ein Kandidat — auch kein stillgelegter. */
+ | {
+    kind: 'not_found';
+    key: string;
+    chain: readonly (string | null)[];
+}
+/** Zwei sichtbare Kandidaten auf **demselben** Glied. Es wird keiner gewählt. */
+ | {
+    kind: 'ambiguous';
+    key: string;
+    chainIndex: number;
+    candidates: readonly TargetModelCandidate[];
+}
+/** Es gab Kandidaten, aber **alle** sind stillgelegt. Liste, kein Einzelwert. */
+ | {
+    kind: 'retired';
+    key: string;
+    candidates: readonly TargetModelCandidate[];
+}
+/** Der Kandidat hat mehrere Heads und nirgends eine greifende Auswahl (D-36). */
+ | {
+    kind: 'fork';
+    key: string;
+    elementId: string;
+    heads: readonly string[];
+};
+/** Eingabe der Auflösung. */
+interface TargetModelQuery {
+    /** Der gesuchte `payload.key`, wörtlich aus `prompt_render_settings`. */
+    key: string;
+    /**
+     * Das **Shot-Element**. Sein Kontext ist der Arbeitskontext der
+     * Preferred-Head-Auflösung; zugleich wird geprüft, dass die übergebene Kette
+     * tatsächlich zu diesem Element gehört.
+     */
+    forElementId: string;
+    /**
+     * Wirksame Kontextkette aus `ContextChainPort.chainFor`: Arbeitskontext
+     * zuerst, dann die geerbten Kontexte nach `priority`, zuletzt `null` für
+     * global.
+     */
+    contextChain: readonly (string | null)[];
+}
+/** Der Lesezugriff, den die Auflösung braucht — mehr nicht. */
+type TargetModelQueries = Pick<SzenenQueries, 'listElements' | 'getElement'>;
+/**
+ * Löst `target_model_id` entlang der Kontextkette auf.
+ *
+ * Reihenfolge (§4.8.2 des Start-Events): Glied für Glied, das erste Glied mit
+ * einem sichtbaren Kandidaten gewinnt. Ein geerbter Zwischenkontext schlägt
+ * damit den globalen Fallback — „direkter Kontext plus global" wäre keine
+ * Kontextvererbung (D-04, D-36).
+ *
+ * Ein **technischer** Lesefehler wird unverändert weitergereicht und nie zu
+ * `not_found`: Das wäre eine fachliche Aussage über ein Zielmodell, das es
+ * vielleicht gibt (Grundsatzregel 5).
+ */
+declare function resolveTargetModelOver(queries: TargetModelQueries, input: TargetModelQuery): Promise<QueryResult<TargetModelResolution>>;
+/** Kette als lesbarer Text für Fehlermeldungen (Grundsatzregel 8). */
+declare function showChain(chain: readonly (string | null)[]): string;
+/**
+ * Meldung zu einem nicht auflösbaren Zielmodell.
+ *
+ * Eine Stelle, damit P-17 (S1b) und der Lauf denselben Text ausgeben — und
+ * damit jede Meldung die relevanten Werte nennt statt „nicht gefunden".
+ */
+declare function describeTargetModelFailure(resolution: Exclude<TargetModelResolution, {
+    kind: 'resolved';
+}>): string;
+
+/** Schweregrad eines Befundes. */
+type FindingSeverity = 
+/** Verhindert die Veröffentlichung. */
+'blocking'
+/** Hinweis; die erklärte Absicht gewinnt (P-11, P-14). */
+ | 'advisory';
+/** Ein Befund einer Publish-Prüfung. */
+interface PublishFinding {
+    /** Regel-ID, z.B. `P-01`. */
+    rule: string;
+    severity: FindingSeverity;
+    /** JSON-Pointer auf die Stelle in der Payload, soweit bestimmbar. */
+    path: string;
+    message: string;
+}
+/** Eine veröffentlichte Version, wie die Prüfungen sie brauchen. */
+interface ResolvedVersion {
+    version_id: string;
+    element_id: string;
+    type: SzenenElementType;
+    payload: unknown;
+    /** `false`, wenn die Version zwar existiert, aber nicht sichtbar ist (D-04). */
+    visible?: boolean;
+    /**
+     * Abstammung dieser Version. P-03 braucht sie, weil sich der Zustand einer
+     * `camera_id` (aktiv, entfernt, unbekannt) erst aus der **gesamten**
+     * erreichbaren Ahnenhistorie ergibt — nicht aus dem direkten Vorgänger.
+     *
+     * Fehlt das Feld, kann die Kette nicht weiterverfolgt werden; P-03 meldet
+     * das, statt einen unvollständigen Lauf als bestanden auszuweisen.
+     */
+    parents?: readonly {
+        parent_version_id: string;
+        relation: string;
+    }[];
+}
+/**
+ * Zugriff auf andere Versionen. Der Port, über den die referenzabhängigen
+ * Regeln arbeiten — kein Datenbankzugriff im Prüfcode (R-2).
+ */
+interface ReferenceResolver {
+    /** Eine veröffentlichte Version, oder `null`, wenn unbekannt oder Draft. */
+    getVersion(versionId: string): Promise<ResolvedVersion | null>;
+    /**
+     * Löst `target_model_id` entlang der Kontextkette auf — Stufe 3, S1a.
+     *
+     * **Optional, und das ist die Aussage:** Die Auflösung braucht die
+     * Kontextkette, und die ist eine Workspace-Tatsache. Wer sie nicht
+     * beschaffen kann, bekommt die Operation nicht — statt einer Suche, die
+     * mangels Kette nur den eigenen Kontext sieht und ein `not_found` liefert,
+     * das keines ist. `resolverFromQueries` setzt sie deshalb nur, wenn ein
+     * `ContextChainPort` übergeben wurde.
+     *
+     * Konsument ist P-17 (S1b): Fehlt die Operation, führt die Regel sich als
+     * **ungeprüft** — dieselbe Mechanik wie bei einem fehlenden Resolver, und
+     * nie ein stilles Bestehen.
+     *
+     * Wirft bei technischen Lesefehlern, wie `getVersion` sie meldet.
+     */
+    resolveTargetModel?(key: string, forElementId: string): Promise<TargetModelResolution>;
+}
+/** Eingabe der Publish-Prüfung. */
+interface PublishCheckInput {
+    type: SzenenElementType;
+    payload: unknown;
+    elementId: string;
+    /** Vorgänger im Versions-DAG; für P-03 und P-10. */
+    parents?: readonly {
+        parent_version_id: string;
+        relation: string;
+    }[];
+    /** Fehlt er, werden die referenzabhängigen Regeln als ungeprüft gemeldet. */
+    resolver?: ReferenceResolver;
+}
+interface PublishCheckResult {
+    /** `true`, wenn kein `blocking`-Befund vorliegt. */
+    ok: boolean;
+    findings: readonly PublishFinding[];
+    /** Regeln, die in diesem Lauf tatsächlich geprüft wurden. */
+    checked: readonly string[];
+    /** Regeln, die **nicht** geprüft werden konnten, mit Grund. */
+    unchecked: readonly {
+        rule: string;
+        reason: string;
+    }[];
+}
+/** Alle Regel-IDs, in der Reihenfolge aus `schemas/README.md`. */
+declare const ALL_PUBLISH_RULES: readonly ["P-01", "P-02", "P-03", "P-04", "P-05", "P-06", "P-07", "P-08", "P-09", "P-10", "P-11", "P-12", "P-13", "P-14", "P-15", "P-16", "P-17"];
+/**
+ * Führt die Publish-Prüfungen aus.
+ *
+ * @returns `ok: false`, sobald eine blockierende Regel greift. Hinweise
+ * (P-11, P-14) verhindern die Veröffentlichung **nicht**.
+ */
+declare function runPublishChecks(input: PublishCheckInput): Promise<PublishCheckResult>;
+
+/** Die Elementtypen, die eine Rekonstruktion vorschlagen kann (D-72). */
+declare const DERIVABLE_TYPES: readonly ["scene", "scene_setup", "shot"];
+type DerivableType = (typeof DERIVABLE_TYPES)[number];
+/** Wie die Rekonstruktion angestoßen wurde. */
+type DerivationInputMode = 'prompt' | 'image' | 'image_prompt';
+/**
+ * Woher ein Eingabebild stammt — **das** wird eingefroren, nicht das Bild (D-73).
+ *
+ * Base64-Daten gehören nicht in das Ereignislog: es ist der autoritative
+ * Speicher (D-62) und wird in Flow-FA Pure vollständig geladen. Ein Log, das
+ * mit Bildern vollläuft, ist dort nicht mehr ladbar.
+ */
+type ImageProvenance = {
+    kind: 'library';
+    media_ref: string;
+    mime_type: string;
+} | {
+    kind: 'upload';
+    sha256: string;
+    bytes: number;
+    mime_type: string;
+};
+/** Ein Eingabebild: die Daten für den Lauf, die Herkunft für den Bestand. */
+interface DerivationImage {
+    /** Base64, ohne `data:`-Praefix. Wird **nicht** gespeichert. */
+    data: string;
+    provenance: ImageProvenance;
+}
+/** Die Policy-Payload, so wie sie im Element steht (D-70). */
+interface DerivationPolicyPayload {
+    key: string;
+    name: string;
+    text: string;
+    locale: string;
+    input_modes: readonly DerivationInputMode[];
+    produces: readonly DerivableType[];
+    node_granularity?: 'coarse' | 'normal' | 'fine';
+    allow_placement?: boolean;
+    forbidden_inventions?: readonly string[];
+}
+/**
+ * Eine wählbare, bereits veröffentlichte Version.
+ *
+ * Ein `scene_setup` braucht `preset_ref` auf ein Camera Preset, ein `shot`
+ * kann auf ein Shot Concept zeigen — beides Versionskennungen, die das Modell
+ * unmöglich wissen kann. Ohne Katalog bliebe ihm nur, sie zu erfinden, und
+ * eine erfundene UUID sieht aus wie eine echte.
+ *
+ * Deshalb bekommt es die Auswahl vorgelegt und darf **nur** daraus wählen.
+ * Was nicht im Katalog steht, ist kein gültiger Verweis (geprüft in
+ * `checkDerivationResponse`).
+ */
+interface CatalogueEntry {
+    type: SzenenElementType;
+    element_id: string;
+    version_id: string;
+    /** Menschenlesbar, damit das Modell fachlich wählen kann statt nach UUID. */
+    title: string;
+}
+interface SceneDerivationInput {
+    policy: DerivationPolicyPayload;
+    /** Die veröffentlichte Policy-Version — sie friert die Regel ein (Konzept §8). */
+    policy_version_id: string;
+    mode: DerivationInputMode;
+    /** Der Referenzprompt, sofern es einen gibt. */
+    prompt_text: string | null;
+    images: readonly DerivationImage[];
+    /** Veröffentlichte Versionen, auf die ein Vorschlag zeigen darf. */
+    catalogue: readonly CatalogueEntry[];
+}
+/** Eine Angabe, die aus der Eingabe nicht ableitbar war (D-75). */
+interface NotDerivable {
+    /** Wohin die Angabe gehört hätte, als JSON-Pointer oder Feldname. */
+    field: string;
+    reason: string;
+}
+/** Ein Widerspruch zwischen Bild und begleitendem Prompt (D-74). */
+interface DerivationConflict {
+    field: string;
+    /** Was das Bild zeigt. */
+    from_image: string;
+    /** Was der Prompt behauptet. */
+    from_prompt: string;
+}
+/** Ein Vorschlag für genau einen Elementtyp. */
+/**
+ * Eine benannte Fehlstelle in einem Vorschlag.
+ *
+ * `pointer` ist ein JSON-Pointer auf **genau** das fehlende Pflichtfeld, etwa
+ * `/camera_rig` oder `/camera_rig/cameras/0/preset_ref`. Er wird nicht frei
+ * formuliert, sondern gegen die Schemaprüfung abgeglichen: Die Menge der
+ * benannten Lücken muss der Menge der tatsächlich fehlenden Pflichtfelder
+ * entsprechen — Stelle für Stelle.
+ */
+interface ProposalGap {
+    pointer: string;
+    reason: string;
+}
+/**
+ * Ein Rekonstruktionsvorschlag — **vollständig oder ausdrücklich teilweise**.
+ *
+ * Der Vertrag ist bewusst ein eigener und nicht „reguläre Payload, aber
+ * Pflichtfelder egal". Zwei Ebenen, die nicht vermischt werden dürfen:
+ *
+ * - Dass ein **Draft** unvollständig sein darf, ist eine Eigenschaft des
+ *   Speichermodells (`checkWriteDraftInput` prüft nur Vorhandensein).
+ * - Was ein **gültiger Vorschlag** ist, ist Semantik der Stufe 6.5.
+ *
+ * Würde man das erste als Begründung fürs zweite nehmen, entstünde ein
+ * Sondervalidator — „das normale Schema gilt, ausser `required`, sofern
+ * irgendwo ein passender `not_derivable`-Eintrag steht". Bei verschachtelten
+ * Pflichtstrukturen wie `camera_rig.cameras[0].preset_ref.version_id` müsste
+ * dann definiert werden, welche Ebene als benannt genügt. Das wäre ein
+ * zweites, implizites Schemasystem.
+ *
+ * Stattdessen: `complete` erfüllt das **normale** Element-Schema unverändert.
+ * `partial` erfüllt es bis auf fehlende Pflichtfelder, und **jede** dieser
+ * Fehlstellen ist in `gaps` benannt. Kein schwächer validierter KI-Pfad —
+ * ein anderer, engerer Vertrag.
+ */
+interface DerivationProposal {
+    type: DerivableType;
+    /** Reguläre Payload des Typs — dieselben Schemas wie bei Handarbeit. */
+    payload: Record<string, unknown>;
+    /**
+     * `complete`: erfüllt das reguläre Schema vollständig.
+     * `partial`: erfüllt es bis auf die in `gaps` benannten Pflichtfelder.
+     */
+    status: 'complete' | 'partial';
+    /** Leer bei `complete`; bei `partial` **exakt** die fehlenden Pflichtfelder. */
+    gaps: readonly ProposalGap[];
+    /**
+     * Namensvorschlag des Modells (D-83), schon getrimmt.
+     *
+     * Fehlt, wenn das Modell keinen brauchbaren geliefert hat — und zwar als
+     * **weggelassener Schlüssel**, nicht als `undefined`: Der Vorschlag reist
+     * einmal durch das Ereignislog und einmal durch REST, und ein Schlüssel mit
+     * `undefined` überlebt die JSON-Serialisierung nicht. Beide Hosts müssen
+     * denselben Datensatz erzeugen (`hostParity.test.ts`).
+     */
+    title?: string;
+}
+interface SceneDerivationOutput {
+    proposals: readonly DerivationProposal[];
+    /** Pflicht, wie `feedback` beim Prompt-Lauf (D-55): ohne Begründung nicht beurteilbar. */
+    feedback: string;
+    assumptions: readonly string[];
+    not_derivable: readonly NotDerivable[];
+    conflicts: readonly DerivationConflict[];
+    /**
+     * Die Antwort des Modells auf die Beanstandung eines Folgelaufs (D-90).
+     *
+     * **Optional, nie Pflicht** — dieselbe Begründung wie beim Titel: Ein neues
+     * Pflichtfeld ist eine neue Möglichkeit, einen bezahlten Lauf zu verlieren
+     * (D-84). Sie darf ausdrücklich ein *Widerspruch* sein: Unsere Beanstandung
+     * kann unbegründet sein, und dann ist die Antwort des Modells das
+     * Wertvollste am ganzen Lauf.
+     */
+    reply?: string;
+}
+/**
+ * Woraus ein Lauf folgt (D-88).
+ *
+ * Ein Folgelauf ist ein **eigener** Lauf, kein zweiter Versuch im selben: Ein
+ * Laufsatz ist unveränderlich (D-71) und längst geschrieben, wenn der Mensch
+ * gefragt wird, ob ein Korrektur- oder Ergänzungslauf folgen soll.
+ *
+ * Die vorige **Antwort** steht hier nicht — sie liegt im Vorgängerlauf und ist
+ * über `run_id` auffindbar. Sie zu verdoppeln hieße, dieselbe (und größte)
+ * Zeichenkette zweimal zu pflegen (R-2).
+ */
+interface DerivationFollowUp {
+    run_id: string;
+    /** Die Beanstandung, die dem Modell vorgelegt wurde — wörtlich. */
+    note: string;
+    /** Die zusätzliche Anweisung des Nutzers, sofern er eine gab. */
+    user_instruction: string | null;
+}
+/** Warum ein Lauf gescheitert ist — dieselben Klassen wie beim Prompt-Lauf. */
+type DerivationFailureClass = 'response_parse' | 'response_schema' | 'safety_blocked' | 'finish_reason' | 'empty_content' | 'provider_error';
+/**
+ * Ein maschinenlesbarer Befund an einer Antwort (A1 der Stufe 6.6).
+ *
+ * Bis 6.5 trug ein Fehlschlag nur `failure.message` — einen Satz für Menschen.
+ * Für die Fehlerrettung reicht das nicht: Die Ansicht muss sagen können,
+ * *welcher* Vorschlag *welches* Feld verletzt, ohne dafür Meldungstexte zu
+ * zerlegen. Ein geparster Fehlertext ist eine Schnittstelle, die niemand
+ * gepflegt hat und die beim nächsten Umformulieren bricht.
+ *
+ * `message` bleibt menschenlesbar und wortgleich zu dem, was `failure.message`
+ * schon immer sagte — die Diagnose ist die **Ergänzung**, nicht der Ersatz.
+ */
+interface DerivationDiagnostic {
+    /** Stabile Kennung, z. B. `proposal.schema_violation`. Nie übersetzt. */
+    code: string;
+    severity: 'error' | 'warning';
+    /** Für Menschen. Sprache folgt dem Code, nicht `locale` (es ist unsere Meldung). */
+    message: string;
+    /** Der betroffene Vorschlag, sofern der Befund einem zuzuordnen ist. */
+    proposal_type?: DerivableType;
+    /** JSON-Pointer auf die betroffene Stelle, sofern bekannt. */
+    pointer?: string;
+    /** Bei Parsefehlern: Position im Rohtext, 1-basiert. */
+    line?: number;
+    column?: number;
+}
+interface DerivationFailure {
+    class: DerivationFailureClass;
+    message: string;
+    provider_detail?: unknown;
+    /**
+     * Die strukturierte Fassung von `message` und allem, was daneben noch
+     * auffiel (6.6/A1). Fehlt bei Läufen von vor 6.6 — der Leser darf sie
+     * deshalb nie voraussetzen.
+     */
+    diagnostics?: readonly DerivationDiagnostic[];
+}
+/** Ein Vorschlag, der seinen Vertrag **nicht** erfüllt, mit dem Grund dafür. */
+interface UnusableProposal {
+    type: DerivableType;
+    diagnostics: readonly DerivationDiagnostic[];
+}
+/** Alles an einer Antwort außer den Vorschlägen — soweit es gültig war. */
+interface DerivationEnvelope {
+    feedback: string;
+    assumptions: readonly string[];
+    not_derivable: readonly NotDerivable[];
+    conflicts: readonly DerivationConflict[];
+    reply?: string;
+}
+/**
+ * Die **Bewertung** einer geparsten Antwort — ohne Urteil über den Lauf
+ * (A2 der Stufe 6.6).
+ *
+ * Bis 6.5 fielen beide Fragen zusammen: `checkDerivationResponse()` prüfte und
+ * entschied in einem Zug, und die erste Vertragsverletzung beendete alles.
+ * Für einen bezahlten Lauf, dessen Antwort teilweise brauchbar ist, war das
+ * fatal — ein einziger Formfehler im `shot` warf auch die gültige `scene` weg.
+ *
+ * Diese Funktion trennt die Fragen. Sie sagt, **was an der Antwort dran ist**:
+ * welche Vorschläge ihren Vertrag erfüllen, welche nicht und warum, und was
+ * an der Hülle verletzt ist. Ob daraus ein `succeeded`- oder ein
+ * `failed`-Lauf wird, entscheidet danach `checkDerivationResponse()` — und
+ * zwar unverändert streng (D-100 lockert die Laufsemantik nicht, sie macht das
+ * Material danach verwertbar).
+ */
+interface DerivationAssessment {
+    /**
+     * **Jeder** Befund, in genau der Reihenfolge, in der geprüft wurde.
+     *
+     * Die Reihenfolge ist Vertrag, nicht Zufall: `checkDerivationResponse()`
+     * meldet den ersten Fehler, und der muss derselbe bleiben wie vor 6.6 —
+     * sonst änderte sich die Meldung bereits abgenommener Läufe.
+     */
+    diagnostics: readonly DerivationDiagnostic[];
+    /** Vorschläge, die den Proposal-Vertrag aus D-82/D-86 erfüllen. */
+    usable: readonly DerivationProposal[];
+    /**
+     * Vorschläge, die ihn verletzen. Die Befunde sind dieselben Objekte wie in
+     * `diagnostics` — nach Vorschlag gruppiert, nicht kopiert.
+     */
+    unusable: readonly UnusableProposal[];
+    /**
+     * Hülleninhalt, soweit lesbar. `null` heißt: Die Antwort war so kaputt, dass
+     * nicht einmal `feedback` und `proposals` zu finden waren — dann gibt es
+     * auch nichts zu retten.
+     */
+    envelope: DerivationEnvelope | null;
+    /**
+     * Erfüllt die Antwort den vollständigen 6.5-Vertrag? Genau dann, wenn kein
+     * Befund die Schwere `error` trägt.
+     */
+    contract_ok: boolean;
+}
+type SceneDerivationOutcome = {
+    status: 'succeeded';
+    output: SceneDerivationOutput;
+    raw_output: string;
+    model_id: string;
+    provider: string;
+} | {
+    status: 'failed';
+    failure: DerivationFailure;
+    raw_output: string | null;
+    model_id: string;
+    provider: string;
+};
+/**
+ * Platzhalter für eine noch nicht existierende Referenz.
+ *
+ * `scene_setup` referenziert eine Szenen**version**, `shot` ein Setup — und
+ * `versionRef` verlangt eine `version_id`, Draft-Referenzen sind unzulässig
+ * (D-03). Zum Zeitpunkt des Vorschlags gibt es diese Versionen noch nicht:
+ * die Szene ist bestenfalls ein Entwurf.
+ *
+ * Damit ein Vorschlag trotzdem **sofort** gegen sein Schema geprüft werden
+ * kann — und nicht erst Minuten später bei der Übernahme —, wird für die
+ * Prüfung diese Kennung eingesetzt. Sie wird **nie gespeichert**: der
+ * Vorschlag im Laufsatz trägt das Referenzfeld gar nicht, und bei der
+ * Übernahme setzt der Server die echte, veröffentlichte Version ein und prüft
+ * erneut. Das ist die maßgebliche Prüfung; diese hier ist die frühe.
+ */
+declare const PROBE_VERSION_ID = "00000000-0000-0000-0000-000000000000";
+/** Welches Referenzfeld ein Typ braucht, und auf welchen Typ es zeigt. */
+declare const REFERENCE_FIELD: Partial<Record<DerivableType, {
+    field: string;
+    refersTo: DerivableType;
+}>>;
+/**
+ * Setzt eine Referenz in eine Vorschlagspayload ein.
+ *
+ * Wird zweimal gebraucht: mit der Probe für die frühe Prüfung und mit der
+ * echten Version bei der Übernahme. **Eine** Funktion für beides, damit die
+ * geprüfte und die gespeicherte Form nicht auseinanderlaufen können.
+ */
+declare function withReference(type: DerivableType, payload: Record<string, unknown>, reference: {
+    element_id: string;
+    version_id: string;
+} | null): Record<string, unknown>;
+/**
+ * Der Systemprompt der Rekonstruktion.
+ *
+ * Mitgespeichert wie beim Prompt-Lauf (D-22): Ändert er sich, ist an einem
+ * alten Lauf noch erkennbar, unter welchen Annahmen er entstand.
+ */
+declare function buildSystemInstruction(input: SceneDerivationInput): string;
+/** Die Nutzernachricht: der Referenzprompt, sonst der Arbeitsauftrag. */
+declare function buildUserPrompt(input: SceneDerivationInput): string;
+/**
+ * Prüft die Eingabe, **bevor** ein Modell gerufen wird.
+ *
+ * Ein Lauf ohne Eingabe oder mit einer Policy, die diesen Eingang gar nicht
+ * abdeckt, ist kein Modellfehler — er darf nicht als Lauf mit Fehlerdiagnose
+ * im Bestand landen und schon gar nichts kosten.
+ */
+declare function validateDerivationInput(input: SceneDerivationInput): string | null;
+/**
+ * Sammelt jeden Verweis auf eine Elementversion aus einer Payload, beliebig tief.
+ *
+ * Erkannt wird die Form, die `common.schema.json#/$defs/versionRef` und seine
+ * Verwandten (`componentRef`, `styleRef`) alle teilen: ein Objekt mit
+ * `element_id` **und** `version_id` als Zeichenketten. Die Suche ist bewusst
+ * strukturell und nicht an Feldnamen gebunden — eine Liste bekannter Namen
+ * würde beim nächsten Schema still unvollständig.
+ */
+declare function collectVersionRefs(value: unknown): readonly {
+    element_id: string;
+    version_id: string;
+}[];
+/**
+ * Löst das JSON aus dem Text — wortgleich zum Prompt-Lauf und aus demselben
+ * Grund: die für Prosa gedachte Bereinigung darf ein JSON-Dokument nicht
+ * anfassen (D-56). Erlaubt ist einzig das Auspacken eines Codeblocks.
+ */
+declare function parseDerivationResponse(raw: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    message: string;
+    diagnostic: DerivationDiagnostic;
+};
+/**
+ * **Bewertet** die geparste Antwort, ohne über den Lauf zu urteilen (6.6/A2).
+ *
+ * Bis 6.5 waren Bewertung und Urteil dieselbe Funktion, und die erste
+ * Vertragsverletzung beendete beides. Ein einziger Formfehler im `shot` warf
+ * damit auch eine tadellose `scene` weg — bei einem bereits bezahlten Lauf ist
+ * das der teuerste denkbare Ausgang.
+ *
+ * Hier wird deshalb nur noch festgestellt, **was an der Antwort dran ist**:
+ * jeder Vorschlag unabhängig gegen seinen Vertrag (D-82, D-86), die Hülle
+ * getrennt davon, und jeder Befund maschinenlesbar (D-100 Regel 1 und 4).
+ * Ob daraus ein `failed`-Lauf wird, entscheidet `checkDerivationResponse()`
+ * unverändert streng.
+ *
+ * Die **Reihenfolge** der Befunde ist die alte Prüfreihenfolge. Nur so bleibt
+ * der erste Fehler derselbe wie vor 6.6.
+ */
+declare function assessDerivationResponse(value: unknown, input: SceneDerivationInput): DerivationAssessment;
+/**
+ * Prüft die geparste Antwort — Struktur, Pflichtdiagnosen und **jede
+ * Vorschlagspayload gegen ihr echtes Schema**.
+ *
+ * Der letzte Punkt ist der Kern von 6.5-C: Es gibt keinen schwächer
+ * validierten AI-Pfad. Was hier nicht durchkommt, wird nicht still repariert,
+ * sondern ist ein Lauf mit Fehlerklasse `response_schema`.
+ *
+ * Seit 6.6 ist das nur noch das **Urteil**; die Prüfarbeit steht in
+ * `assessDerivationResponse()`. Die Strenge ist unverändert: Genau die
+ * Antworten, die vor 6.6 `failed` waren, sind es weiterhin (A2). Neu ist
+ * allein, dass die Bewertung daneben erhalten bleibt und in der Fehlerrettung
+ * weiterverwendet werden kann.
+ */
+declare function checkDerivationResponse(value: unknown, input: SceneDerivationInput): {
+    ok: true;
+    output: SceneDerivationOutput;
+} | {
+    ok: false;
+    message: string;
+    diagnostics: readonly DerivationDiagnostic[];
+};
+/**
+ * Ein deterministischer Port ohne Provider — für Tests **und** für eine
+ * ausdrücklich angeforderte Simulation in der Entwicklung.
+ *
+ * Er ist nie ein Rückfall: Wer ihn benutzt, hat ihn gewählt, und der
+ * gespeicherte Lauf trägt `provider: 'simulation'`. Die Antwort läuft durch
+ * denselben Parser und dieselbe Schemaprüfung wie eine echte — eine
+ * Simulation, die die Prüfungen umginge, wiese nichts nach.
+ *
+ * Er bekommt die Eingabe **ausdrücklich übergeben**, weil er anders als beim
+ * Prompt-Lauf nicht aus der Nutzernachricht ablesen kann, was verlangt ist:
+ * dort ist sie die Renderer-Eingabe als JSON, hier freier Text.
+ *
+ * Was er nicht ehrlich bauen kann, baut er nicht: Ein `scene_setup` braucht
+ * mindestens ein Camera Preset aus dem Katalog. Fehlt es, scheitert die
+ * Simulation laut, statt eine Payload zu erfinden, die am Schema vorbeiginge.
+ */
+declare function createSimulationSceneDerivationPort(input: SceneDerivationInput): TextGenerationPort;
+/**
+ * Führt den Rekonstruktionslauf aus.
+ *
+ * Gibt **immer** ein Ergebnis zurück — `succeeded` oder `failed`. Ein
+ * technischer Ausfall des Ports (Netz, fehlende Konfiguration) wirft dagegen:
+ * er ist kein Lauf, sondern ein Betriebsfehler und darf nicht als „das Modell
+ * hat abgelehnt" im Bestand stehen.
+ */
+declare function runSceneDerivation(input: SceneDerivationInput, port: TextGenerationPort, 
+/**
+ * Ersetzt die Nutzernachricht. Der Folgelauf schickt seine eigene (D-89) —
+ * dieselbe Regel, dieselben Schemas, nur ein anderer Auftrag im Gespräch.
+ */
+userPrompt?: string): Promise<SceneDerivationOutcome & {
+    system_prompt: string;
+}>;
+
+/** Die Felder, über die ein Kettenknoten auf einen anderen zeigt. */
+declare const CHAIN_LINK_FIELDS: readonly ["scene_ref", "scene_setup_ref"];
+type ChainLinkField = (typeof CHAIN_LINK_FIELDS)[number];
+/**
+ * Welche Kante 6.6 zulässt — und **nur** diese beiden.
+ *
+ * Bewusst eine Tabelle und keine freie Kantenmenge: Ein Graph, der alles
+ * erlaubt, verlangt einen Zykluscheck und eine Erreichbarkeitsanalyse. Die
+ * fachliche Kette hat genau zwei Kanten (`domain-model.md` §2), und mehr zu
+ * ermöglichen hieße, eine Allgemeinheit zu bauen, die niemand bestellt hat.
+ */
+declare const CHAIN_EDGES: Readonly<Record<ChainLinkField, {
+    /** Der Typ, der das Feld trägt. */
+    from: DerivableType;
+    /** Der Typ, auf den es zeigt. */
+    to: DerivableType;
+}>>;
+/** Ein kettenintern geführter Verweis auf einen anderen Draft derselben Kette. */
+interface DraftChainLink {
+    field: ChainLinkField;
+    target_element_id: string;
+    /**
+     * Die Draft-Kennung des Zielknotens.
+     *
+     * Dass sie über Revisionen stabil bleibt, ist in `draftIdentity.test.ts` und
+     * im Port-Vertrag belegt (Gate B0) — für HF **und** MySQL. Ohne diesen
+     * Nachweis wäre der Link wertlos.
+     */
+    target_draft_id: string;
+}
+/** Die Kettenmetadaten eines einzelnen Drafts. */
+interface DraftChainMeta {
+    /** Gemeinsame Kennung aller Knoten **einer** Übernahme. */
+    chain_id: string;
+    /** Der Rekonstruktionslauf, aus dem die Vorschläge stammen. */
+    source_run_id: string;
+    /** Gesetzt, wenn der Inhalt aus einer geprüften Arbeitsfassung kam (D-99). */
+    source_recovery_id?: string;
+    links: readonly DraftChainLink[];
+}
+type ChainVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Prüft Kettenmetadaten für sich genommen — Form, erlaubte Kanten, keine
+ * Dubletten.
+ *
+ * Was hier **nicht** geprüft werden kann: ob das Ziel existiert und ob es
+ * dieselbe `chain_id` trägt. Das weiß nur der Speicher, und dort steht die
+ * Prüfung auch (`checkChainTargets`). Diese Funktion hier behauptet nicht mehr,
+ * als sie wissen kann.
+ *
+ * @param type Der Elementtyp des Drafts, an dem die Metadaten hängen. Ohne ihn
+ *   ließe sich nicht sagen, ob eine Kante an dieser Stelle überhaupt zulässig
+ *   ist — ein `scene`-Draft mit einem `scene_ref` wäre Unsinn.
+ */
+declare function checkDraftChainMeta(meta: unknown, type: string | null): ChainVerdict;
+/** Was der Speicher über ein Linkziel wissen muss, um es zu beurteilen. */
+interface ChainTarget {
+    element_id: string;
+    /** Der Elementtyp des Ziels, oder `null`, wenn es das Element nicht gibt. */
+    type: string | null;
+    /** Der aktuelle Draft des Ziels, oder `null` — kein Draft, kein Ziel. */
+    draft: {
+        draft_id: string;
+        chain_id: string | null;
+    } | null;
+}
+/**
+ * Prüft die Links gegen die tatsächlichen Ziele.
+ *
+ * Drei Ablehnungen, und jede hat einen eigenen Grund:
+ *
+ *  * **Ziel fehlt** — ein Link ins Leere ist schlimmer als kein Link, weil er
+ *    aussieht, als gäbe es etwas.
+ *  * **Falscher Typ** — ein `scene_ref` auf einen `shot` ergäbe beim Einfrieren
+ *    eine Renderer-Eingabe, die niemand gemeint hat.
+ *  * **Fremde Kette** — der Kern von D-96. Ein Link über Kettengrenzen hinweg
+ *    hebelt die Zusage aus, dass eine Kette **eine** Übernahme ist; das
+ *    Einfrieren wüsste dann nicht mehr, welchen Umfang es einfriert.
+ */
+declare function checkChainTargets(meta: DraftChainMeta, targets: readonly ChainTarget[]): ChainVerdict;
+/** Der Link eines Feldes, oder `null`. */
+declare function linkFor(meta: DraftChainMeta | null | undefined, field: ChainLinkField): DraftChainLink | null;
+
+/** Element-Stammsatz (`elements`, §2.1). Nach Anlage unveränderlich: `id`, `type`. */
+interface ElementRecord {
+    element_id: string;
+    /** Lesbarer Stammtitel fuer Listen und Auswahlen; kein Versionsinhalt (D-35). */
+    title?: string;
+    type: SzenenElementType;
+    subtype: string | null;
+    /** Kontext, in dem das Element liegt. `null` = global. */
+    context_id: string | null;
+    retired: boolean;
+}
+/**
+ * Elementmetadaten (`element_metadata`, §2.2).
+ *
+ * Der Titel ist **kein Versionsinhalt** (D-35): eine Umbenennung erzeugt weder
+ * eine neue Version noch ein Update-Angebot.
+ */
+interface ElementMetadata {
+    element_id: string;
+    title: string;
+    description: string | null;
+    /** Autorensprache des Titels. */
+    locale: string;
+    revision: number;
+}
+/** Veröffentlichte Elementversion (`element_versions`, §2.3). Unveränderlich (D-02). */
+interface PublishedVersion extends VersionNode {
+    schema_version: string;
+    payload: unknown;
+    published_by: string;
+}
+/** Entwurf (`element_drafts`, §3). Veränderlich und **nicht** referenzierbar. */
+interface DraftRecord {
+    draft_id: string;
+    element_id: string;
+    base_version_id: string | null;
+    payload: unknown;
+    revision: number;
+    updated_by_client: string;
+    /**
+     * Kettenmetadaten, falls dieser Draft Teil einer Draft-Kette ist (D-96).
+     *
+     * **Additiv und optional.** Ein Draft ohne dieses Feld ist ein gewöhnlicher
+     * Einzelentwurf und verhält sich wie vor 6.6 — jeder Bestandsdraft ist
+     * genau das. Wer das Feld voraussetzt, bricht die Altdaten.
+     *
+     * Es liegt bewusst **neben** der Payload: Die Payload ist das, was
+     * veröffentlicht wird, und sie trägt an den Referenzstellen weiterhin keine
+     * erfundene `version_id` (D-95).
+     */
+    chain?: DraftChainMeta;
+}
+/**
+ * Ein Entwurf, den mehrere Clients gleichzeitig auf derselben Revision
+ * fortgeschrieben haben (D-29: „parallele Draft-Heads werden auf HF-Seite
+ * sichtbar gemacht").
+ */
+interface DraftFork {
+    element_id: string;
+    revision: number;
+    /** Die konkurrierenden Stände, einer je schreibendem Client. */
+    candidates: readonly DraftRecord[];
+}
+/** Vollständiger Stand eines Elements, wie ihn ein Editor braucht. */
+interface ElementSnapshot {
+    element: ElementRecord;
+    metadata: ElementMetadata | null;
+    /** Alle veröffentlichten Versionen. Eingang in `buildVersionDag`. */
+    versions: readonly PublishedVersion[];
+    /** Aktueller Entwurf, falls einer existiert. */
+    draft: DraftRecord | null;
+    /** Gesetzt, wenn mehrere Clients denselben Entwurf gleichzeitig fortgeschrieben haben. */
+    draftFork: DraftFork | null;
+    /** Preferred-Head-Auswahlen über alle Kontexte (§2.6). */
+    preferredHeads: readonly PreferredHeadSelection[];
+}
+/**
+ * Konflikt beim Schreiben mit erwarteter Revision (§3.1).
+ *
+ * **Kein Fehler, sondern ein regulärer Ausgang.** Die Regel lautet: kein stilles
+ * Last-Write-Wins. Der Aufrufer bekommt die aktuelle Revision und den aktuellen
+ * Stand und entscheidet zwischen Verwerfen, Übernehmen und Zusammenführen.
+ */
+interface WriteConflict<T> {
+    kind: 'conflict';
+    expectedRevision: number;
+    actualRevision: number;
+    current: T;
+}
+/**
+ * Eine Veröffentlichung, die an der Validierung gescheitert ist.
+ *
+ * Getrennt von `error`, weil es kein technisches Problem ist, sondern eine
+ * fachliche Ablehnung mit einer Befundliste, die die UI anzeigen soll.
+ */
+interface PublishRejected {
+    kind: 'rejected';
+    errors: readonly SchemaError[];
+    /**
+     * Prüfungen, die dieser Port nicht durchführen konnte. Solange
+     * P-01…P-16 nicht implementiert sind, steht hier deren Kennung —
+     * damit niemand `ok` für eine vollständige Freigabe hält.
+     */
+    unchecked: readonly string[];
+}
+/** Ergebnis eines Szenen-Kommandos: die Standardfälle plus Konflikt und Ablehnung. */
+type SzenenCommandResult<T, C = T> = CommandResult<T> | WriteConflict<C> | PublishRejected;
+/** 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[]>>;
+    /** Vollständiger Stand eines Elements, oder `null`, wenn unbekannt. */
+    getElement(elementId: string): Promise<QueryResult<ElementSnapshot | null>>;
+    /**
+     * Eine **veröffentlichte** Version, so wie die Publish-Prüfungen sie
+     * brauchen — oder `null`, wenn die Kennung unbekannt ist oder nur zu einem
+     * Entwurf gehört. Entwürfe sind nie referenzierbar (D-03).
+     *
+     * Der Grund für diese Operation im Lesevertrag (D-67): Ohne sie kommt kein
+     * Aufrufer an einen `ReferenceResolver` und kann die referenzabhängigen
+     * Regeln **vor** dem Schreiben nicht laufen lassen. `resolverOver()` im
+     * HF-Speicher ist privat und läuft nur intern beim Veröffentlichen.
+     *
+     * Rückgabetyp ist `ResolvedVersion` und nicht `PublishedVersion`: Die
+     * Prüfungen brauchen `type` und `visible`, und beide hängen am **Element**,
+     * nicht an der Version.
+     *
+     * Ein stillgelegtes Element liefert die Version mit `visible: false` —
+     * nicht `null`. Stilllegen ist Ausblenden, kein Löschen (D-04), und P-04
+     * muss den Unterschied zwischen „unbekannt" und „unsichtbar" melden können.
+     */
+    getVersion(versionId: string): Promise<QueryResult<ResolvedVersion | null>>;
+    /**
+     * Löst `shot.prompt_render_settings.target_model_id` entlang der
+     * Kontextkette auf — Stufe 3, S1a.
+     *
+     * Der Grund für diese Operation im Lesevertrag: `target_model_id` ist ein
+     * freier String und keine `versionRef`. P-17 (beim Veröffentlichen) und der
+     * Prompt-Ableitungslauf müssen **dieselbe** Auflösung sehen; stünde sie in
+     * einem der Speicher, gäbe es zwei.
+     *
+     * Die **Kette** kommt von außen (`ContextChainPort`) und wird nicht hier
+     * abgeleitet: Sie steht in `contexts`/`context_inheritance` und damit in
+     * MySQL. Ein Elementspeicher, der sie selbst ermittelte, wäre in Flow-FA
+     * Pure nicht erfüllbar.
+     */
+    resolveTargetModel(input: TargetModelQuery): Promise<QueryResult<TargetModelResolution>>;
+}
+/**
+ * Die wirksame Kontextkette — **eigener Port**, weil die Vererbung nicht der
+ * Szenen-Domain gehört.
+ *
+ * Sie liegt in `contexts` und `context_inheritance` (Workspace-Domain), wird
+ * dort nach `priority` aufgelöst und ist für die Szenen-Domain eine Eingabe wie
+ * jede andere. Ein Host ohne Kontextgraph liefert `[eigenerKontext, null]` —
+ * das ist dort keine verkürzte Vererbung, sondern die vollständige. Damit der
+ * Unterschied nicht unsichtbar bleibt, friert der Prompt-Lauf die verwendete
+ * Kette ein.
+ */
+interface ContextChainPort {
+    /**
+     * Arbeitskontext zuerst, dann die geerbten Kontexte nach `priority`,
+     * zuletzt `null` für global. `null` ist immer das letzte Glied.
+     */
+    chainFor(contextId: string | null): Promise<QueryResult<readonly (string | null)[]>>;
+}
+/**
+ * Macht aus einem Lese-Port den `ReferenceResolver` der Publish-Prüfungen.
+ *
+ * Bewusst klein und ohne Kenntnis der Command-Varianten: `SzenenQueries` ist
+ * der Lesevertrag, dort gibt es weder `conflict` noch `rejected`.
+ *
+ * **Ein technischer Lesefehler wirft.** Er wird nicht zu `null`, denn `null`
+ * hieße für P-04 „diese Version ist nicht veröffentlicht" — eine fachliche
+ * Aussage über eine Referenz, die einwandfrei sein kann. Eine kaputte
+ * Datenbankverbindung darf keinen Publish-Blocker erfinden (Grundsatzregel 5).
+ */
+declare function resolverFromQueries(queries: SzenenQueries, contexts?: ContextChainPort): ReferenceResolver;
+/** Eingabe zum Anlegen eines Elements. */
+interface CreateElementInput {
+    type: SzenenElementType;
+    subtype?: string | null;
+    contextId?: string | null;
+    title: string;
+    description?: string | null;
+    locale?: string;
+}
+/** Eingabe zum Schreiben eines Entwurfs. */
+interface WriteDraftInput {
+    elementId: string;
+    payload: unknown;
+    /** Version, auf der der Entwurf aufsetzt. `null` bei der ersten Version. */
+    baseVersionId?: string | null;
+    /**
+     * Kettenmetadaten setzen oder fortschreiben (D-96).
+     *
+     * Weggelassen heißt **unverändert lassen**, nicht löschen: Wer eine Payload
+     * fortschreibt, soll die Kette seines Drafts nicht versehentlich kappen.
+     * `null` löscht sie ausdrücklich — der Draft wird dann wieder ein
+     * gewöhnlicher Einzelentwurf.
+     */
+    chain?: DraftChainMeta | null;
+    /**
+     * Erwartete Revision des Entwurfs. `0` heißt: es soll noch keinen geben.
+     * Weicht sie ab, ist das Ergebnis ein `conflict` — nie ein stiller Überschreiber.
+     */
+    expectedRevision: number;
+}
+/** Eingabe zum Veröffentlichen einer Version. */
+interface PublishVersionInput {
+    elementId: string;
+    payload: unknown;
+    schemaVersion: string;
+    /** Vorgänger im Versions-DAG. Leer bei der ersten Version. */
+    parents?: readonly {
+        parent_version_id: string;
+        relation: 'derived_from' | 'merged_from';
+    }[];
+    publishedBy: string;
+}
+/** Eingabe zum Setzen des Preferred Head. */
+interface SetPreferredHeadInput {
+    elementId: string;
+    contextId: string;
+    versionId: string;
+    expectedRevision: number;
+    selectedBy: string;
+}
+/**
+ * Eingabe zum Ändern der Elementmetadaten.
+ *
+ * **Partielles Update** (Review §8): Ein Feld, das **fehlt**, behält seinen
+ * bisherigen Wert; ein Feld, das ausdrücklich auf `null` gesetzt wird, wird
+ * gelöscht. Vorher war es eine Mischform — `description` verschwand, wenn sie
+ * nicht mitgesendet wurde, `locale` blieb erhalten. Ein reiner Titelwechsel
+ * löschte damit eine bestehende Beschreibung.
+ *
+ * `title` ist Pflicht: ein Element ohne Titel wäre in keiner Liste auffindbar.
+ */
+interface ReviseMetadataInput {
+    elementId: string;
+    title: string;
+    /** Fehlt = unverändert. `null` = löschen. */
+    description?: string | null;
+    /** Fehlt = unverändert. */
+    locale?: string;
+    expectedRevision: number;
+}
+/**
+ * Schreibzugriffe.
+ *
+ * Ein Host, der eine Operation nicht anbietet, lässt das Feld weg — das ist der
+ * `unsupported`-Fall aus R-1 und kein Fehler.
+ */
+interface SzenenCommands {
+    createElement(input: CreateElementInput): Promise<SzenenCommandResult<ElementRecord>>;
+    writeDraft(input: WriteDraftInput): Promise<SzenenCommandResult<DraftRecord, DraftRecord | null>>;
+    publishVersion(input: PublishVersionInput): Promise<SzenenCommandResult<PublishedVersion>>;
+    setPreferredHead?(input: SetPreferredHeadInput): Promise<SzenenCommandResult<PreferredHeadSelection, PreferredHeadSelection | null>>;
+    reviseMetadata?(input: ReviseMetadataInput): Promise<SzenenCommandResult<ElementMetadata, ElementMetadata | null>>;
+    /**
+     * Legt ein Element still — **idempotent** (Review §9).
+     *
+     * Ein zweiter Aufruf auf ein bereits stillgelegtes Element liefert wieder
+     * `ok` mit demselben Stand und ändert nichts. Es gibt keine erwartete
+     * Revision: Stilllegen kennt nur einen sinnvollen Zielzustand, und zwei
+     * gleichzeitige Aufrufe können sich nicht widersprechen. Das unterscheidet
+     * es bewusst von den übrigen mutierenden Operationen.
+     */
+    retireElement?(elementId: string): Promise<SzenenCommandResult<ElementRecord>>;
+}
+/** Der vollständige Elementspeicher eines Hosts. */
+interface SzenenElementStore extends SzenenQueries, SzenenCommands {
+}
+/** Rolle eines Speichers im Gefälle aus D-62. */
+type StoreAuthority = 
+/** Führt die fachliche Wahrheit. Nur HF erfüllt das in allen Hosts. */
+'authoritative'
+/** Materialisierte Ableitung eines autoritativen Bestands. */
+ | 'projection';
+/**
+ * Der autoritative fachliche Speicher.
+ *
+ * Fachliche Änderungen werden **hier** abgeschlossen; erst danach gilt eine
+ * Änderung als erfolgt. Konflikte und `expectedRevision` entscheiden
+ * ausschließlich gegen diesen Stand.
+ */
+interface AuthoritativeSzenenStore extends SzenenElementStore {
+    readonly authority: 'authoritative';
+}
+/**
+ * Zustand einer Projektion (D-62 §2.4).
+ *
+ * `current`    – nachweislich auf dem Stand der Quellrevision
+ * `stale`      – die Quelle ist weiter, die Projektion hinterher
+ * `rebuilding` – wird gerade vollständig neu aufgebaut
+ * `failed`     – der letzte Projektionsversuch ist gescheitert
+ */
+type ProjectionStatus = 'current' | 'stale' | 'rebuilding' | 'failed';
+/**
+ * Buchführung einer Projektion.
+ *
+ * Ohne sie lässt sich nicht entscheiden, ob ein MySQL-Lesezugriff die aktuelle
+ * Wahrheit trifft — und genau das darf nach D-62 nie stillschweigend
+ * angenommen werden.
+ */
+interface ProjectionState {
+    status: ProjectionStatus;
+    /** Quellrevision oder Cursor im autoritativen Speicher; `null` = nie projiziert. */
+    sourceRevision: string | null;
+    /** Zeitpunkt der letzten **erfolgreichen** Projektion, ISO-8601. */
+    projectedAt: string | null;
+    /** Letzter Projektionsfehler, solange er nicht durch Erfolg abgelöst ist. */
+    lastError: string | null;
+}
+/**
+ * Eine materialisierte Projektion des autoritativen Bestands.
+ *
+ * Lesen darf bevorzugt hier geschehen, **solange die Projektion nachweisbar
+ * aktuell ist**. Ist sie es nicht, muss der Aufrufer auf den autoritativen
+ * Speicher zurückfallen oder den Stand ausdrücklich als veraltet ausweisen.
+ * Deshalb ist `getProjectionState` Teil des Vertrags und nicht Beiwerk.
+ */
+interface SzenenProjection extends SzenenQueries {
+    readonly authority: 'projection';
+    getProjectionState(): Promise<QueryResult<ProjectionState>>;
+}
+/**
+ * Ist diese Projektion als Wahrheit lesbar?
+ *
+ * Bewusst eine Funktion und kein Feld: der einzige Zustand, der zum Lesen
+ * berechtigt, ist `current` — jede spätere Erweiterung der Statuswerte fällt
+ * damit automatisch auf die sichere Seite.
+ */
+declare const isProjectionCurrent: (state: ProjectionState) => boolean;
+/** Schmales Prädikat für `SzenenCommandResult`. */
+declare const isOk: <T, C>(result: SzenenCommandResult<T, C>) => result is {
+    kind: "ok";
+    value: T;
+};
+
+/** Optionale Kommandos, ohne die einzelne Prüfungen entfallen. */
+type OptionalCommand = 'setPreferredHead' | 'reviseMetadata' | 'retireElement';
+/** Eine einzelne Vertragsprüfung. */
+interface ContractCheck {
+    /** Thematische Gruppe, für die Ausgabe. */
+    group: string;
+    name: string;
+    /**
+     * Kommando, das dieser Check braucht. Bietet der Port es nicht an, wird
+     * übersprungen statt rot — `unsupported` ist der Normalfall aus R-1.
+     */
+    requires?: OptionalCommand;
+    run(store: SzenenElementStore): Promise<void>;
+}
+/** Was ein Kandidat für den Contract-Test mitbringen muss. */
+interface ElementStoreContractHarness {
+    /** Ein frischer, leerer Speicher je Prüfung. */
+    createStore(): Promise<SzenenElementStore> | SzenenElementStore;
+    /** Kommandos, die dieser Port nicht anbietet. */
+    optionalCommandsMissing?: readonly OptionalCommand[];
+}
+/** Schemagültige Payload eines `style` — der einfachste Typ ohne Referenzen. */
+declare const STYLE_PAYLOAD: {
+    readonly role: "medium";
+    readonly name: "Kohlezeichnung";
+    readonly text: "grobe Kohle auf Papier";
+    readonly locale: "de";
+};
+/** Zweite, ebenfalls gültige `style`-Payload. */
+declare const STYLE_PAYLOAD_V2: {
+    readonly role: "medium";
+    readonly name: "Kohlezeichnung, weicher";
+    readonly text: "weiche Kohle, gewischt";
+    readonly locale: "de";
+};
+declare class ContractViolation extends Error {
+}
+/**
+ * Alle Prüfungen, die jeder `SzenenElementStore` erfüllen muss.
+ *
+ * Rein und zustandslos: jede Prüfung bekommt einen frischen Speicher.
+ */
+declare function elementStoreContractChecks(): readonly ContractCheck[];
+/** Ausgang einer einzelnen Prüfung. */
+interface ContractCheckResult {
+    group: string;
+    name: string;
+    status: 'passed' | 'failed' | 'skipped';
+    /** Bei `failed`: die Meldung. Bei `skipped`: warum. */
+    message?: string;
+}
+interface ContractRunResult {
+    results: readonly ContractCheckResult[];
+    passed: number;
+    failed: number;
+    skipped: number;
+    /** Kurzform: keine Prüfung fehlgeschlagen. */
+    ok: boolean;
+}
+/**
+ * Führt den Vertrag gegen einen Port aus, ohne Testframework.
+ *
+ * Für Umgebungen, die kein vitest haben — insbesondere den Szenario-Runner des
+ * Backends, der den MySQL-Port aus Stufe 1d prüft. Der vitest-Adapter für
+ * fa-app-tools liegt in `storeContractVitest.ts` und nutzt dieselben Prüfungen.
+ */
+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 };