@rslsp1/fa-app-tools 2.0.85 → 2.0.86

package/dist/szenen.d.ts

@@ -2,8 +2,8 @@ import { ac as SchemaError, Z as PublishFinding, Y as PublishCheckResult, aj as
 export { A as ALL_PUBLISH_RULES, C as CHAIN_EDGES, b as CHAIN_LINK_FIELDS, c as CatalogueEntry, d as ChainLinkField, e as ChainTarget, f as ChainVerdict, g as CompiledSchemas, i as ContractCheck, j as ContractCheckResult, k as ContractRunResult, l as ContractViolation, m as CreateElementInput, D as DERIVABLE_TYPES, r as DerivationEnvelope, t as DerivationFailureClass, x as DerivationPolicyPayload, y as DerivationProposal, z as DraftChainLink, E as DraftFork, F as DraftRecord, G as ElementMetadata, H as ElementRecord, J as ElementStoreContractHarness, K as ElementVersionValidation, L as FindingSeverity, O as OptionalCommand, P as PROBE_VERSION_ID, Q as ParentRelation, R as PreferredHeadOutcome, S as PreferredHeadResolution, T as PreferredHeadSelection, U as PreferredHeadSource, V as ProjectionState, W as ProjectionStatus, X as PublishCheckInput, _ as PublishRejected, $ as PublishVersionInput, a0 as PublishedVersion, a1 as REFERENCE_FIELD, a3 as ResolvePreferredHeadOptions, a4 as ResolvedVersion, a5 as ReviseMetadataInput, a6 as STYLE_PAYLOAD, a7 as STYLE_PAYLOAD_V2, a8 as SZENEN_ELEMENT_TYPES, a9 as SceneDerivationInput, aa as SceneDerivationOutcome, ab as SceneDerivationOutput, ad as SchemaValidationResult, ae as SetPreferredHeadInput, af as StoreAuthority, ag as SzenenCommandResult, ak as SzenenProjection, am as TargetModelCandidate, an as TargetModelQueries, ao as TargetModelQuery, aq as UnsupportedSchemaError, as as VersionDag, at as VersionDagError, au as VersionNode, av as VersionParentLink, aw as WriteConflict, ax as WriteDraftInput, ay as assessDerivationResponse, az as buildDerivationSystemInstruction, aA as buildDerivationUserPrompt, aB as buildVersionDag, aC as checkChainTargets, aD as checkDerivationResponse, aE as checkDraftChainMeta, aF as collectVersionRefs, aG as compileSchemas, aH as createSimulationSceneDerivationPort, aI as describeTargetModelFailure, aJ as elementStoreContractChecks, aK as formatSchemaErrors, aL as getSzenenSchemas, aM as isOk, aN as isProjectionCurrent, aO as linkFor, aP as parseDerivationResponse, aQ as preferredVersionId, aR as resolvePreferredHead, aS as resolveTargetModelOver, aT as resolverFromQueries, aU as runElementStoreContract, aV as runPublishChecks, aW as runSceneDerivation, aX as showChain, aY as validateAgainst, aZ as validateDerivationInput, a_ as validateElementVersion, a$ as validatePayload, b0 as withReference } from './storeContract-D7vBM8nv.js';
 import { T as TextGenerationPort, Q as QueryResult, C as CommandResult } from './contracts-DdYOMBl9.js';
 export { S as SIMULATION_PROVIDER, c as TextGenerationRequest, d as TextGenerationResult, g as createFakeTextGenerationPort, h as createSimulationTextGenerationPort, s as simulatedAnswerFor } from './contracts-DdYOMBl9.js';
-import { F as FlowGenerateText } from './flowTextGenerationPort-KHjCGt_S.js';
-export { C as CreateFlowTextGenerationPortOptions, i as createFlowTextGenerationPort } from './flowTextGenerationPort-KHjCGt_S.js';
+import { g as HFStateSnapshot, F as FlowGenerateText } from './hfEventTypes-C_PX6RFR.js';
+export { C as CreateFlowTextGenerationPortOptions, t as createFlowTextGenerationPort } from './hfEventTypes-C_PX6RFR.js';
 import React__default from 'react';
 
 /** Rohes JSON-Schema, wie es in der Spezifikation steht. */
@@ -662,6 +662,19 @@ interface ImageBatchPersistedImage {
     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;
@@ -2121,8 +2134,16 @@ interface SzenenImageLibraryPort {
         search?: string;
         limit?: number;
     }): Promise<QueryResult<readonly LibraryImage[]>>;
-    /** Base64 **ohne** `data:`-Präfix und der MIME-Typ — die Modelleingabe. */
-    resolveImage(mediaRef: string): Promise<QueryResult<{
+    /**
+     * Base64 **ohne** `data:`-Präfix und der MIME-Typ — die Modelleingabe.
+     *
+     * `mimeTypeHinweis` ist ein **Hinweis**, kein Zwang: Kennt der Aufrufer den
+     * bestätigten Typ aus dem Batch-Nachweis (`PromptBatchImageRef.mime_type`,
+     * Review 2026-08-18 §5 P2), erspart er dem Host das Raten der Dateiendung,
+     * solange der Bestand das Bild noch nicht führt. Ein Host, der ihn nicht
+     * braucht, ignoriert ihn.
+     */
+    resolveImage(mediaRef: string, mimeTypeHinweis?: string | null): Promise<QueryResult<{
         data: string;
         mime_type: string;
     }>>;
@@ -2183,6 +2204,14 @@ interface PromptBatchImageRef {
     media_ref: string;
     position: number;
     file?: string;
+    /**
+     * Der bestätigte MIME-Typ der abgelegten Datei, soweit der Nachweis ihn führt
+     * (Review 2026-08-18 §5 P2).
+     *
+     * Der Lesepfad bildet daraus den Dateipfad, statt zwischen den Endungen zu
+     * raten. Optional, weil ältere Batches ihn nicht tragen.
+     */
+    mime_type?: string | null;
     model?: string | null;
     seed?: number | null;
     width?: number | null;
@@ -2391,6 +2420,54 @@ declare function unsupportedReason(capability: string): string;
  */
 declare function callOptional<T>(capability: string, operation: (() => Promise<CommandResult<T>>) | undefined): Promise<CommandResult<T>>;
 
+interface HfImageStoreOptions {
+    namespace: string;
+    token: string;
+    now?: () => number;
+    /**
+     * Wie oft ein Bild, das im Bestand fehlt, direkt von HF geholt wird, und wie
+     * lange dazwischen gewartet wird.
+     *
+     * Der Verzug ist real, aber kurz. Ersetzbar, damit ein Test ihn nicht
+     * aussitzen muss.
+     */
+    leseVersuche?: number;
+    leseBasisMs?: number;
+    schlafen?: (ms: number) => Promise<void>;
+}
+interface AufgeloestesBild {
+    data: string;
+    mimeType: string;
+}
+interface HfImageStore {
+    /**
+     * Legt ein Bild unter einer **vorgegebenen** Kennung ab.
+     *
+     * Reihenfolge zwingend: erst die Datei, dann das Ereignis (R3 der
+     * 6.9.2-Spezifikation). Ein Nachweis, der auf eine fehlende Datei zeigt,
+     * wäre für jeden Leser ein Fehler; umgekehrt ist es nur eine Datei, die noch
+     * kein Ereignis kennt.
+     */
+    putWithId(id: string, base64: string, mimeType: string, titel?: string): Promise<void>;
+    /** Löst eine Kennung auf. `mimeType` ist ein Hinweis, kein Zwang. */
+    resolve(id: string, mimeType?: string | null): Promise<AufgeloestesBild>;
+    /** Der aktuelle Bestand — Schnappschuss plus die Ereignisse danach. */
+    bestand(): Promise<HFStateSnapshot>;
+}
+/** Der HF-Pfad einer Bildkennung — für die Fehlermeldung, die ihn nennen muss (R7). */
+declare function bildPfad(id: string, mimeType: string | null | undefined): string;
+/**
+ * Der MIME-Typ aus den tatsächlichen Bildbytes.
+ *
+ * Review §5 P2: `image/png` einfach anzunehmen genügt nicht — für importierte
+ * oder künftig anders kodierte Bilder wäre der Typ dann falsch deklariert, und
+ * die Datei läge unter einer Endung, unter der sie niemand sucht. Geprüft
+ * werden die Signaturen am Anfang der Daten; nur wenn keine passt, bleibt es
+ * bei der Angabe des Aufrufers.
+ */
+declare function typAusBytes(base64: string, vorgabe?: string): string;
+declare function createHfImageStore(options: HfImageStoreOptions): HfImageStore;
+
 interface CreateHfImageLibraryOptions {
     namespace: string;
     token: string;
@@ -2398,6 +2475,15 @@ interface CreateHfImageLibraryOptions {
     newImageId?: () => string;
     /** Die Uhr — dieselbe Begründung. */
     now?: () => number;
+    /**
+     * Der gemeinsame Bildspeicher (Review §5 P1).
+     *
+     * Wird er übergeben, teilen sich Bildbestand und Batch-Persistenz **eine**
+     * Instanz — nur dann ist ein gerade erzeugtes Bild hier sofort auflösbar.
+     * Fehlt er, baut dieser Adapter sich einen eigenen; das ist für den
+     * Alleinbetrieb richtig und für den Flow-Port ausdrücklich nicht gewollt.
+     */
+    store?: HfImageStore;
 }
 declare function createHfImageLibrary(options: CreateHfImageLibraryOptions): SzenenImageLibraryPort;
 
@@ -2836,6 +2922,14 @@ interface CreateHfImageBatchPersistenceOptions {
     /** Kennung je abgelegtem Bild. Ersetzbar, damit ein Test nicht würfelt. */
     newImageId?: (generationBatchId: string, position: number) => string;
     now?: () => Date;
+    /**
+     * Der gemeinsame Bildspeicher (Review §5 P1).
+     *
+     * Dieselbe Instanz wie im Bildbestand: nur dadurch ist ein hier abgelegtes
+     * Bild dort sofort auflösbar. Fehlt er, entsteht ein eigener — dann gilt die
+     * Sofortauflösung nur innerhalb dieses Adapters.
+     */
+    store?: HfImageStore;
 }
 /**
  * `ImageGenerationBatchPersistence` für Flow — derselbe kanonische Weg wie
@@ -2929,4 +3023,4 @@ interface SzenenViewProps {
 }
 declare const SzenenView: React__default.FC<SzenenViewProps>;
 
-export { type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, CATALOGUE_TYPES, type CallableImageModel, CapabilityAnchorError, type CapabilityFlag, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClientDerivationChannel, type ClientDerivationStore, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateMemoryViewPortOptions, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, type ElementEvent, type ElementEventChannel, ElementSnapshot, type ElementStoreState, type ExistingSzenenItem, FLOW_MODEL_DISPLAY_NAMES, type FlowGenerateImage, type FlowGenerateImageParams, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSuccess, type FrozenChainNode, type GeneratedImage, type IdFactory, type ImageBatchPersistedImage, type ImageBatchPersistedPayload, type ImageGenerationBatchPersistence, type ImageGenerationCapability, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, ImageProvenance, type ImageProviderAccessCheck, type ImageProviderInput, type ImportBatchImageInput, type ImportBatchInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LibraryImage, type NodeContribution, NotDerivable, type Notice, type NoticeTone, type PromptBatchImageRef, type PromptImageBatch, type PromptRunOutcome, type PromptRunOutput, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, type ReducerFinding, ReferenceResolver, type RendererInput, type ResolveFailure, type ResolveResult, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_EVENT_PREFIX, SZENEN_EVENT_TYPES, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, SchemaError, type StartImageGenerationInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UnusableProposal, type VersionMedium, type VisibilityNode, areasFor, batchesForPromptRun, buildSystemInstruction, buildUserPrompt, callOptional, callableImageModelFor, capabilitiesOf, capabilityForTargetModel, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, collectImageBatches, collectImageGenerationOrders, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createImageGenerationPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, differentialSteps, draftRevisionOf, findImageBatch, findImageGenerationOrder, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, flowImageProviderHasAccess, freezeDraftChain, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, logRevisionOf, mergeSzenenBatchOrigin, noticeFor, ordersForPromptRun, parseRunResponse, preferredHeadRevisionOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveShot, resolveShotPayload, roundOfRun, runPromptDerivation, runStoreDifferential, scopeOfPath, totalModelCalls, unclassifiedPublishRules, unsupportedReason };
+export { type AttachLibraryItemInput, type AttachLibraryItemResult, AuthoritativeSzenenStore, CATALOGUE_TYPES, type CallableImageModel, CapabilityAnchorError, type CapabilityFlag, type CapabilityReason, type CapabilityReport, type CapabilityReportInput, type CapabilityScope, type CapabilityState, type ChainQueries, type ClientDerivationChannel, type ClientDerivationStore, ContextChainPort, type CreateBrowserTextGenerationPortOptions, type CreateClientDerivationPortOptions, type CreateClientRunPortOptions, type CreateFlowSzenenViewPortOptions, type CreateHfElementStoreOptions, type CreateHfEventChannelOptions, type CreateHfImageBatchHistoryOptions, type CreateHfImageBatchPersistenceOptions, type CreateImageGenerationPortOptions, type CreateMemoryViewPortOptions, DerivableType, DerivationAssessment, DerivationConflict, DerivationDiagnostic, DerivationFailure, DerivationImage, DerivationInputMode, type DeriveItemInput, type DerivedItem, type DerivedLineage, type DerivedRelationship, type DerivedSzenenReference, type DifferentialResult, type DifferentialStep, type Divergence, DraftChainMeta, ELEMENT_VERSION_SCHEMA_FILE, type ElementEvent, type ElementEventChannel, ElementSnapshot, type ElementStoreState, type ExistingSzenenItem, FLOW_MODEL_DISPLAY_NAMES, type FlowGenerateImage, type FlowGenerateImageParams, FlowGenerateText, type FreezeDraftChainInput, type FreezeFailure, type FreezeResult, type FreezeSuccess, type FrozenChainNode, type GeneratedImage, type HfImageStore, type HfImageStoreOptions, type IdFactory, type ImageBatchPersistedImage, type ImageBatchPersistedPayload, type ImageGenerationBatchPersistence, type ImageGenerationCapability, type ImageGenerationEventChannel, type ImageGenerationFinishedPayload, type ImageGenerationOrder, type ImageGenerationProviderPort, type ImageGenerationResult, type ImageGenerationRunReader, type ImageGenerationStartedPayload, ImageProvenance, type ImageProviderAccessCheck, type ImageProviderInput, type ImportBatchImageInput, type ImportBatchInput, type InMemoryEventChannel, type InputError, type IntegrityVerdict, type ItemDerivationFailure, type ItemDerivationFailureClass, type ItemDerivationResult, type ItemMedium, type LibraryImage, type NodeContribution, NotDerivable, type Notice, type NoticeTone, type PromptBatchImageRef, type PromptImageBatch, type PromptRunOutcome, type PromptRunOutput, type PromptRunPersistencePort, type PromptRunRecord, type PromptRunRecordedPayload, type ProviderCheckRecord, type ProviderCheckRecordedPayload, type ProviderCheckResult, PublishCheckResult, PublishFinding, RULES_WITHOUT_CAPABILITY_EFFECT, RULE_SCOPES, type RawSchema, type RecordedDerivationInput, type RecordedProposal, type RecoveryStatus, type ReducerFinding, ReferenceResolver, type RendererInput, type ResolveFailure, type ResolveResult, type ResolveShotInput, type ResolveShotPayloadInput, ResolveTechnicalError, type ResolvedCamera, type ResolvedNode, type ResolvedPlacement, type RunEventChannel, type RunFailure, type RunFailureClass, type RunItemReference, SZENEN_EVENT_PREFIX, SZENEN_EVENT_TYPES, SZENEN_ITEM_PREFIX, SZENEN_SCHEMAS, type SaveRunAsItemInput, type SceneDerivationPersistencePort, type SceneDerivationRecord, type SceneDerivationRecordedPayload, type SceneDerivationRecoveryRecord, type SceneDerivationRecoveryRecordedPayload, SchemaError, type StartImageGenerationInput, type StartRunInput, type StepState, type SzenenArea, type SzenenAreaId, type SzenenBatchOrigin, type SzenenBatchOriginFailure, type SzenenBatchOriginVerdict, SzenenCommands, SzenenElementStore, SzenenElementType, type SzenenImageBatchHistoryPort, type SzenenImageBatchWritePort, type SzenenImageGenerationPort as SzenenImageGenerationPortContract, type SzenenImageLibraryPort, type SzenenItemPort, type SzenenMediaPort, SzenenQueries, type SzenenRunPort, SzenenView, type SzenenViewCapabilities, type SzenenViewPort, type SzenenViewProps, TargetModelResolution, TextGenerationPort, UNCHECKED_PUBLISH_RULES, UnusableProposal, type VersionMedium, type VisibilityNode, areasFor, batchesForPromptRun, bildPfad, buildSystemInstruction, buildUserPrompt, callOptional, callableImageModelFor, capabilitiesOf, capabilityForTargetModel, capabilityGate, capabilityReport, catalogueFor, checkCreateElementInput, checkElementType, checkOptionalId, checkParents, checkPayloadPresent, checkPromptRunRecord, checkPublishVersionInput, checkRequiredId, checkReviseMetadataInput, checkRevision, checkRunResponse, checkSceneDerivationRecord, checkSceneDerivationRecoveryRecord, checkSetPreferredHeadInput, checkSzenenBatchOrigin, checkTitle, checkWriteDraftInput, collectImageBatches, collectImageGenerationOrders, collectPromptRuns, collectProviderChecks, collectSceneDerivationRecoveries, collectSceneDerivations, createBrowserTextGenerationPort, createClientDerivationPort, createClientRunPort, createEventLogDerivationPersistence, createEventLogRunPersistence, createFlowImageProvider, createFlowSzenenViewPort, createHfElementStore, createHfEventChannel, createHfImageBatchHistory, createHfImageBatchWrite, createHfImageGenerationBatchPersistence, createHfImageLibrary, createHfImageStore, createImageGenerationPort, createInMemoryEventChannel, createMemoryViewPort, derivationPoliciesOf, deriveItemFromRun, deriveLineage, differentialSteps, draftRevisionOf, findImageBatch, findImageGenerationOrder, findPromptRun, findProviderCheck, findSceneDerivation, findSceneDerivationRecovery, firstError, flowImageProviderHasAccess, freezeDraftChain, hasPlacementCapability, isKnownElementType, isSzenenItemId, itemIdForRun, logRevisionOf, mergeSzenenBatchOrigin, noticeFor, ordersForPromptRun, parseRunResponse, preferredHeadRevisionOf, publishedHeadsOf, recoveriesForRun, recoveryStatusOf, reduceElementEvents, resolveArea, resolveShot, resolveShotPayload, roundOfRun, runPromptDerivation, runStoreDifferential, scopeOfPath, totalModelCalls, typAusBytes, unclassifiedPublishRules, unsupportedReason };

package/dist/szenen.js

@@ -59,6 +59,7 @@ __export(szenen_exports, {
   areasFor: () => areasFor,
   assessDerivationResponse: () => assessDerivationResponse,
   batchesForPromptRun: () => batchesForPromptRun,
+  bildPfad: () => bildPfad,
   buildDerivationSystemInstruction: () => buildSystemInstruction2,
   buildDerivationUserPrompt: () => buildUserPrompt2,
   buildSystemInstruction: () => buildSystemInstruction,
@@ -114,6 +115,7 @@ __export(szenen_exports, {
   createHfImageBatchWrite: () => createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence: () => createHfImageGenerationBatchPersistence,
   createHfImageLibrary: () => createHfImageLibrary,
+  createHfImageStore: () => createHfImageStore,
   createImageGenerationPort: () => createImageGenerationPort,
   createInMemoryEventChannel: () => createInMemoryEventChannel,
   createMemoryViewPort: () => createMemoryViewPort,
@@ -172,6 +174,7 @@ __export(szenen_exports, {
   showChain: () => showChain,
   simulatedAnswerFor: () => simulatedAnswerFor,
   totalModelCalls: () => totalModelCalls,
+  typAusBytes: () => typAusBytes,
   unclassifiedPublishRules: () => unclassifiedPublishRules,
   unsupportedReason: () => unsupportedReason,
   validateAgainst: () => validateAgainst,
@@ -7595,8 +7598,8 @@ async function mitGeduld(anfrage) {
     letzte = res;
     if (versuch === DROSSEL_VERSUCHE - 1) break;
     const angesagt = Number(res.headers.get("retry-after"));
-    const warten = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
-    await schlafen(warten);
+    const warten2 = Number.isFinite(angesagt) && angesagt > 0 ? angesagt * 1e3 : DROSSEL_BASIS_MS * 2 ** versuch;
+    await schlafen(warten2);
   }
   return letzte;
 }
@@ -9352,6 +9355,179 @@ async function hfLoadImageAsBase64(id, token, namespace, filename, on404, mimeTy
   return result === "ABORT" ? null : result;
 }
 
+// src/lib/hfReducer.ts
+function applyEvent(state, event) {
+  if (event.v.major > 1) return state;
+  switch (event.type) {
+    // SPEZ: image_added (state/spez/hf-state.spez.yaml)
+    case "image_added": {
+      const p = event.payload;
+      if (state.metadata.some((m) => m.id === p.id)) return state;
+      return { ...state, metadata: [...state.metadata, p] };
+    }
+    // SPEZ: task_requested (global/spez/task-queue.spez.yaml)
+    case "task_requested": {
+      const p = event.payload;
+      if (p.expiresAt && p.expiresAt < event.ts) return state;
+      const openTasks = { ...state.openTasks || {} };
+      openTasks[p.taskId] = p;
+      return { ...state, openTasks };
+    }
+    // SPEZ: task_completed (global/spez/task-queue.spez.yaml)
+    case "task_completed": {
+      const p = event.payload;
+      if (!state.openTasks || !state.openTasks[p.taskId]) return state;
+      const openTasks = { ...state.openTasks };
+      delete openTasks[p.taskId];
+      return { ...state, openTasks };
+    }
+    // SPEZ: tag_upserted (state/spez/hf-state.spez.yaml) — Legacy, wird nicht mehr erzeugt
+    case "tag_upserted": {
+      const p = event.payload;
+      const tags = state.tags;
+      const cat = tags.by_category[p.category] || [];
+      const existing = cat.find((t) => t.value === p.value);
+      const updated = { label: p.label, value: p.value, is_user_created: p.is_user_created, is_deleted: p.is_deleted };
+      const newCat = existing ? cat.map((t) => t.value === p.value ? { ...t, ...updated } : t) : [...cat, updated];
+      const newAll = tags.all.some((t) => t.value === p.value && t.category === p.category) ? tags.all.map((t) => t.value === p.value && t.category === p.category ? { ...t, ...updated, category: p.category } : t) : [...tags.all, { ...updated, category: p.category }];
+      return { ...state, tags: { by_category: { ...tags.by_category, [p.category]: newCat }, all: newAll } };
+    }
+    // SPEZ: thumb_added (state/spez/hf-state.spez.yaml)
+    case "thumb_added": {
+      const p = event.payload;
+      return {
+        ...state,
+        metadata: state.metadata.map((m) => m.id === p.id ? { ...m, hasThumb: true } : m)
+      };
+    }
+    // SPEZ: metadata_updated (state/spez/hf-state.spez.yaml)
+    case "metadata_updated": {
+      const p = event.payload;
+      return {
+        ...state,
+        metadata: state.metadata.map((m) => m.id === p.id ? { ...m, ...p.delta } : m)
+      };
+    }
+    // SPEZ: title_set (state/spez/hf-state.spez.yaml)
+    case "title_set": {
+      const p = event.payload;
+      return {
+        ...state,
+        metadata: state.metadata.map((m) => m.id === p.id ? { ...m, titleTs: event.ts } : m)
+      };
+    }
+    default:
+      return state;
+  }
+}
+function applyEvents(state, events) {
+  return events.reduce(applyEvent, state);
+}
+
+// src/lib/szenen/hfImageStore.ts
+var LEERER_BESTAND = {
+  metadata: [],
+  tags: { by_category: {}, all: [] },
+  meta: { consolidatedAt: 0, version: 1 }
+};
+function endungFuer(mimeType) {
+  return mimeType === "image/png" ? "png" : "jpg";
+}
+function bildPfad(id, mimeType) {
+  return `images/${id}.${endungFuer(mimeType)}`;
+}
+function typAusBytes(base64, vorgabe = "image/png") {
+  const kopf = base64.slice(0, 16);
+  if (kopf.startsWith("iVBORw0KGgo")) return "image/png";
+  if (kopf.startsWith("/9j/")) return "image/jpeg";
+  if (kopf.startsWith("UklGR")) return "image/webp";
+  if (kopf.startsWith("R0lGOD")) return "image/gif";
+  return vorgabe;
+}
+var warten = (ms) => new Promise((r) => setTimeout(r, ms));
+function createHfImageStore(options) {
+  const { namespace, token } = options;
+  const now = options.now ?? (() => Date.now());
+  const versuche = options.leseVersuche ?? 4;
+  const basisMs = options.leseBasisMs ?? 400;
+  const schlafen2 = options.schlafen ?? warten;
+  const abgelegt = /* @__PURE__ */ new Map();
+  const bekanntePfade = /* @__PURE__ */ new Set();
+  let gefalteterBestand = null;
+  let laufenderAbgleich = null;
+  async function bestandLesen() {
+    const grundlage = gefalteterBestand ?? await loadHFState(namespace, token) ?? LEERER_BESTAND;
+    const neue = await loadPendingEvents(
+      namespace,
+      token,
+      grundlage.meta.consolidatedAt,
+      bekanntePfade
+    );
+    const danach = neue.filter((e) => e.ts > grundlage.meta.consolidatedAt);
+    gefalteterBestand = danach.length ? applyEvents(grundlage, danach) : grundlage;
+    return gefalteterBestand;
+  }
+  function bestandAbgleichen() {
+    if (!laufenderAbgleich) {
+      laufenderAbgleich = bestandLesen().finally(() => {
+        laufenderAbgleich = null;
+      });
+    }
+    return laufenderAbgleich;
+  }
+  return {
+    bestand: bestandAbgleichen,
+    async putWithId(id, base64, mimeType, titel) {
+      const echterTyp = typAusBytes(base64, mimeType);
+      await hfUploadImage(base64, id, token, echterTyp);
+      await writeHFEvent(namespace, token, "image_added", {
+        id,
+        prompt: titel ?? id,
+        tags: [],
+        timestamp: now(),
+        mimeType: echterTyp
+      }, []);
+      abgelegt.set(id, { data: base64, mimeType: echterTyp });
+    },
+    async resolve(id, mimeType) {
+      const eben = abgelegt.get(id);
+      if (eben) return eben;
+      const zustand = await bestandAbgleichen();
+      const eintrag = zustand.metadata.find((e) => e.id === id);
+      const typ = eintrag?.mimeType || mimeType || null;
+      if (eintrag) {
+        const base64 = await hfLoadImageAsBase64(
+          id,
+          token,
+          void 0,
+          eintrag.filename,
+          void 0,
+          eintrag.mimeType,
+          false
+        );
+        if (base64) return { data: base64, mimeType: eintrag.mimeType || "image/jpeg" };
+      }
+      const pfadTyp = typ ?? "image/png";
+      for (let versuch = 0; versuch < versuche; versuch += 1) {
+        if (versuch > 0) await schlafen2(basisMs * 2 ** (versuch - 1));
+        const base64 = await hfLoadImageAsBase64(
+          id,
+          token,
+          void 0,
+          void 0,
+          void 0,
+          pfadTyp,
+          false
+        );
+        if (base64) return { data: base64, mimeType: pfadTyp };
+      }
+      throw new Error(
+        `Das Bild ${id} ist auf HF nicht auffindbar. Geprueft: ${bildPfad(id, pfadTyp)} in ${versuche} Versuchen` + (eintrag ? " (im Bestand verzeichnet, aber nicht ladbar)." : " (nicht im Bestand verzeichnet).")
+      );
+    }
+  };
+}
+
 // src/lib/szenen/hfImageLibrary.ts
 function fehler(nachricht, retryable = false) {
   return { kind: "error", message: nachricht, retryable };
@@ -9367,14 +9543,16 @@ function alsBild(eintrag) {
   };
 }
 function createHfImageLibrary(options) {
-  const { namespace, token } = options;
   const newImageId = options.newImageId ?? (() => crypto.randomUUID());
-  const now = options.now ?? (() => Date.now());
-  const frisch = /* @__PURE__ */ new Map();
+  const store = options.store ?? createHfImageStore({
+    namespace: options.namespace,
+    token: options.token,
+    ...options.now ? { now: options.now } : {}
+  });
   return {
     async listImages(query) {
       try {
-        const zustand = await loadHFState(namespace, token);
+        const zustand = await store.bestand();
         const eintraege = zustand?.metadata ?? [];
         const gesucht = query?.search?.trim().toLowerCase();
         const gefiltert = gesucht ? eintraege.filter((e) => (e.prompt ?? "").toLowerCase().includes(gesucht) || e.id.toLowerCase().includes(gesucht)) : eintraege;
@@ -9388,54 +9566,18 @@ function createHfImageLibrary(options) {
         );
       }
     },
-    async resolveImage(mediaRef) {
-      const eben = frisch.get(mediaRef);
-      if (eben) return { kind: "ok", value: { data: eben.data, mime_type: eben.mimeType } };
+    async resolveImage(mediaRef, mimeTypeHinweis) {
       try {
-        const zustand = await loadHFState(namespace, token);
-        const eintrag = (zustand?.metadata ?? []).find((e) => e.id === mediaRef);
-        if (eintrag) {
-          const base64 = await hfLoadImageAsBase64(
-            mediaRef,
-            token,
-            void 0,
-            eintrag.filename,
-            void 0,
-            eintrag.mimeType,
-            false
-          );
-          if (!base64) {
-            return fehler(`Das Bild ${mediaRef} ist im Bestand verzeichnet, aber nicht ladbar.`, true);
-          }
-          return { kind: "ok", value: { data: base64, mime_type: eintrag.mimeType || "image/jpeg" } };
-        }
-        for (const mimeType of ["image/png", "image/jpeg"]) {
-          const base64 = await hfLoadImageAsBase64(mediaRef, token, void 0, void 0, void 0, mimeType, false);
-          if (base64) return { kind: "ok", value: { data: base64, mime_type: mimeType } };
-        }
-        return fehler(
-          `Das Bild ${mediaRef} steht nicht im Bestand. Moeglicherweise hat der Abgleich es noch nicht uebertragen.`,
-          true
-        );
+        const bild = await store.resolve(mediaRef, mimeTypeHinweis);
+        return { kind: "ok", value: { data: bild.data, mime_type: bild.mimeType } };
       } catch (error) {
-        return fehler(
-          `Das Bild ${mediaRef} konnte nicht geladen werden: ${error instanceof Error ? error.message : String(error)}`,
-          true
-        );
+        return fehler(error instanceof Error ? error.message : String(error), true);
       }
     },
     async putImage(input) {
       const id = newImageId();
       try {
-        await hfUploadImage(input.data, id, token, input.mime_type);
-        await writeHFEvent(namespace, token, "image_added", {
-          id,
-          prompt: input.title,
-          tags: [],
-          timestamp: now(),
-          mimeType: input.mime_type
-        }, []);
-        frisch.set(id, { mimeType: input.mime_type, data: input.data });
+        await store.putWithId(id, input.data, input.mime_type, input.title);
         return {
           kind: "ok",
           value: { mediaRef: id, title: input.title, mimeType: input.mime_type, thumbUrl: null }
@@ -11142,6 +11284,11 @@ function alsBilder(rohe) {
     media_ref: b.media_ref,
     position: b.position,
     ...istText4(b.asset_id) ? { asset_id: b.asset_id } : {},
+    // Der bestätigte MIME-Typ (Review 2026-08-18 §5 P2) muss durch das
+    // Rücklesen hindurch: Genau hier braucht ihn der Lesepfad, um den
+    // Dateipfad `images/<id>.<ext>` zu bilden, statt ihn zu erraten. Nur
+    // gesetzt, wenn er im Ereignis steht — ältere Batches tragen ihn nicht.
+    ...istText4(b.mime_type) ? { mime_type: b.mime_type } : {},
     model: b.model ?? null,
     seed: b.seed ?? null,
     width: b.width ?? null,
@@ -11230,6 +11377,7 @@ async function legeBatchAb(options, input) {
   const { namespace, token, channel } = options;
   const newImageId = options.newImageId ?? ((batchId, position) => `${batchId}-${position}`);
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const store = options.store ?? createHfImageStore({ namespace, token });
   const itemId = itemIdForRun(input.runId);
   let vorhandeneEvents;
   try {
@@ -11248,15 +11396,14 @@ async function legeBatchAb(options, input) {
   for (let offset = 0; offset < input.images.length; offset++) {
     const bild = input.images[offset];
     const id = newImageId(input.generationBatchId, startPosition + offset);
+    const echterTyp = typAusBytes(bild.imageBase64, bild.mimeType);
     try {
-      await hfUploadImage(bild.imageBase64, id, token, bild.mimeType);
-      await writeHFEvent(namespace, token, "image_added", {
+      await store.putWithId(
         id,
-        prompt: input.title ?? `Batch ${input.generationBatchId}`,
-        tags: [],
-        timestamp: now().getTime(),
-        mimeType: bild.mimeType
-      }, []);
+        bild.imageBase64,
+        echterTyp,
+        input.title ?? `Batch ${input.generationBatchId}`
+      );
     } catch (error) {
       return fehler3(
         `Bild ${offset + 1}/${input.images.length} des Batches ${input.generationBatchId} konnte nicht im Bildbestand abgelegt werden: ${error instanceof Error ? error.message : String(error)}. Bereits abgelegte Bilder dieses Versuchs (${abgelegt.length}) bleiben im Bestand, geh\xF6ren aber zu keinem Batch, solange das Batch-Ereignis nicht geschrieben ist.`
@@ -11266,6 +11413,7 @@ async function legeBatchAb(options, input) {
       position: startPosition + offset,
       media_ref: id,
       asset_id: id,
+      mime_type: echterTyp,
       model: bild.model ?? null,
       seed: bild.seed ?? null,
       width: bild.width ?? null,
@@ -11309,8 +11457,11 @@ function createHfImageGenerationBatchPersistence(options) {
         images: input.images.map((bild) => ({
           imageBase64: bild.imageBase64,
           // Flow liefert PNG-Base64 (bestehende Konvention, s. AvatarArchitectApp.tsx
-          // `data:image/png;base64,${base64}`); der gemeinsame Vertrag führt
-          // keinen MIME-Typ je Bild.
+          // `data:image/png;base64,${base64}`), und der gemeinsame Vertrag führt
+          // keinen MIME-Typ je Bild. Das ist deshalb nur die **Vorgabe**:
+          // Entschieden wird nach den echten Bytes (Review §5 P2) — ein künftig
+          // anders kodiertes Bild läge sonst unter einer Endung, unter der es
+          // niemand sucht.
           mimeType: "image/png",
           model: bild.model ?? null,
           seed: bild.seed ?? null,
@@ -11331,6 +11482,8 @@ function createHfImageBatchWrite(options) {
         title: input.title,
         images: input.images.map((bild) => ({
           imageBase64: bild.imageBase64,
+          // Vorgabe, kein Urteil — der Import bringt beliebig kodierte Bilder
+          // mit, und der Typ wird aus den Bytes bestimmt (Review §5 P2).
           mimeType: "image/png",
           model: bild.model ?? null,
           seed: bild.seed ?? null,
@@ -11404,7 +11557,17 @@ function createFlowSzenenViewPort(options) {
     ...options.newRunId ? { newRunId: options.newRunId } : {},
     ...options.now ? { now: options.now } : {}
   });
-  const imageLibrary = options.imageLibrary ?? (options.namespace?.trim() && options.token?.trim() ? createHfImageLibrary({ namespace: options.namespace, token: options.token }) : void 0);
+  const hatHfZugangsdaten = Boolean(options.namespace?.trim() && options.token?.trim());
+  const bildSpeicher = hatHfZugangsdaten ? createHfImageStore({
+    namespace: options.namespace,
+    token: options.token,
+    ...options.now ? { now: () => options.now().getTime() } : {}
+  }) : void 0;
+  const imageLibrary = options.imageLibrary ?? (bildSpeicher ? createHfImageLibrary({
+    namespace: options.namespace,
+    token: options.token,
+    store: bildSpeicher
+  }) : void 0);
   const derivation = createClientDerivationPort({
     store: elements,
     derivations: createEventLogDerivationPersistence(channel),
@@ -11414,11 +11577,11 @@ function createFlowSzenenViewPort(options) {
     ...options.now ? { now: options.now } : {}
   });
   const imageBatchHistory = createHfImageBatchHistory({ channel });
-  const hatHfZugangsdaten = Boolean(options.namespace?.trim() && options.token?.trim());
-  const imageBatchWrite = hatHfZugangsdaten ? createHfImageBatchWrite({
+  const imageBatchWrite = bildSpeicher ? createHfImageBatchWrite({
     namespace: options.namespace,
     token: options.token,
     channel,
+    store: bildSpeicher,
     ...options.newBatchImageId ? { newImageId: options.newBatchImageId } : {},
     ...options.now ? { now: options.now } : {}
   }) : void 0;
@@ -11432,6 +11595,9 @@ function createFlowSzenenViewPort(options) {
       namespace: options.namespace,
       token: options.token,
       channel,
+      // Dieselbe Instanz wie der Bildbestand — sonst wäre das gerade
+      // erzeugte Bild in der Laufansicht wieder unauffindbar (R1).
+      store: bildSpeicher,
       ...options.newBatchImageId ? { newImageId: options.newBatchImageId } : {},
       ...options.now ? { now: options.now } : {}
     }),
@@ -12915,8 +13081,8 @@ var BestandsBild = ({ port, mediaRef }) => {
 };
 var BatchBild = ({ port, bild }) => {
   const [phase] = usePortQuery(
-    () => port.imageLibrary ? port.imageLibrary.resolveImage(bild.media_ref) : Promise.resolve({ kind: "ok", value: null }),
-    [port, bild.media_ref]
+    () => port.imageLibrary ? port.imageLibrary.resolveImage(bild.media_ref, bild.mime_type ?? null) : Promise.resolve({ kind: "ok", value: null }),
+    [port, bild.media_ref, bild.mime_type]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("li", { "data-testid": `batchbild-${bild.media_ref}`, children: [
     phase.status === "ready" && phase.value && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
@@ -14961,6 +15127,7 @@ var SzenenView = ({
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildDerivationSystemInstruction,
   buildDerivationUserPrompt,
   buildSystemInstruction,
@@ -15016,6 +15183,7 @@ var SzenenView = ({
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createInMemoryEventChannel,
   createMemoryViewPort,
@@ -15074,6 +15242,7 @@ var SzenenView = ({
   showChain,
   simulatedAnswerFor,
   totalModelCalls,
+  typAusBytes,
   unclassifiedPublishRules,
   unsupportedReason,
   validateAgainst,

package/dist/szenen.mjs

@@ -26,6 +26,7 @@ import {
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildSystemInstruction,
   buildSystemInstruction2,
   buildUserPrompt,
@@ -75,6 +76,7 @@ import {
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createSimulationSceneDerivationPort,
   createSimulationTextGenerationPort,
@@ -123,6 +125,7 @@ import {
   scopeOfPath,
   showChain,
   simulatedAnswerFor,
+  typAusBytes,
   unclassifiedPublishRules,
   unsupportedReason,
   validateAgainst,
@@ -130,7 +133,7 @@ import {
   validateElementVersion,
   validatePayload,
   withReference
-} from "./chunk-MILMVOK7.mjs";
+} from "./chunk-DGFMONWO.mjs";
 import {
   ContractViolation,
   STYLE_PAYLOAD,
@@ -1477,6 +1480,7 @@ export {
   areasFor,
   assessDerivationResponse,
   batchesForPromptRun,
+  bildPfad,
   buildSystemInstruction as buildDerivationSystemInstruction,
   buildUserPrompt as buildDerivationUserPrompt,
   buildSystemInstruction2 as buildSystemInstruction,
@@ -1532,6 +1536,7 @@ export {
   createHfImageBatchWrite,
   createHfImageGenerationBatchPersistence,
   createHfImageLibrary,
+  createHfImageStore,
   createImageGenerationPort,
   createInMemoryEventChannel,
   createMemoryViewPort,
@@ -1590,6 +1595,7 @@ export {
   showChain,
   simulatedAnswerFor,
   totalModelCalls,
+  typAusBytes,
   unclassifiedPublishRules,
   unsupportedReason,
   validateAgainst,