@cat-factory/app 0.205.0 → 0.207.0

package/app/utils/binaryOutput.spec.ts

@@ -253,6 +253,41 @@ describe('the generative half of the read model', () => {
     expect(binaryOutputHasWarnings(view!)).toBe(true)
   })
 
+  it('surfaces an UNCHECKED generative verdict, and does not let it read as a clean one', () => {
+    // The settlement-side twin of the picker's `generators_unavailable`. An empty
+    // `unknownDeclaredGenerators` normally means every claimed id checked out, so a reader
+    // deciding whether these artifacts are real would take silence here as confirmation. The
+    // flag has to reach both the line AND the collapsed summary's tone, or the one place it is
+    // stated is behind a section that looks like it has nothing to say.
+    const view = binaryOutputView(
+      step({
+        stepOptions: { binaryOutput: { storageServiceId: 'files', generatorIds: ['retro'] } },
+        binaryOutputs: report({
+          stored: [{ ...artifact('files', 'a.png'), generator: 'retro' }],
+          generatorsUnverified: true,
+        }),
+      }),
+    )
+    expect(view?.generatorsUnverified).toBe(true)
+    expect(view?.unknownDeclaredGenerators).toEqual([])
+    // The artifacts themselves survived the outage — that is the whole point of recording them.
+    expect(view?.rows).toHaveLength(1)
+    expect(binaryOutputHasWarnings(view!)).toBe(true)
+  })
+
+  it('reads a checked-and-clean report as clean, which is what makes the flag mean anything', () => {
+    const view = binaryOutputView(
+      step({
+        stepOptions: { binaryOutput: { storageServiceId: 'files', generatorIds: ['retro'] } },
+        binaryOutputs: report({
+          stored: [{ ...artifact('files', 'a.png'), generator: 'retro' }],
+        }),
+      }),
+    )
+    expect(view?.generatorsUnverified).toBe(false)
+    expect(binaryOutputHasWarnings(view!)).toBe(false)
+  })
+
   it('carries the step selection through, and treats empty as a real state', () => {
     const configured = binaryOutputView(
       step({
@@ -276,6 +311,66 @@ describe('the generative half of the read model', () => {
   })
 })
 
+// The one judgement this surface can make that admission cannot: admission checked what the
+// selected integrations CAN emit, this checks what the run actually came back with.
+describe('the delivered-format check', () => {
+  const required = (mediaTypes: string[], stored: { location: string; contentType?: string }[]) =>
+    binaryOutputView(
+      step({
+        stepOptions: { binaryOutput: { storageServiceId: 'files', mediaTypes } },
+        binaryOutputs: report({
+          stored: stored.map((entry) => ({ service: 'files', ...entry })),
+        }),
+      }),
+    )
+
+  it('names a required format no declared artifact reports', () => {
+    const view = required(
+      ['model/gltf-binary', 'model/fbx'],
+      [{ location: 'a.glb', contentType: 'model/gltf-binary' }],
+    )
+    expect(view?.undeliveredMediaTypes).toEqual(['model/fbx'])
+    expect(binaryOutputHasWarnings(view!)).toBe(true)
+  })
+
+  it('reduces the agent’s own spelling before comparing, and only then', () => {
+    // The requirement came through `mediaTypeSchema`; the artifact's content type is the model's
+    // prose. Comparing them raw reports a format as undelivered while the file sits where it was
+    // asked for.
+    expect(
+      required(['model/gltf-binary'], [{ location: 'a.glb', contentType: 'Model/GLTF-Binary' }])
+        ?.undeliveredMediaTypes,
+    ).toEqual([])
+  })
+
+  it('does not accept a near neighbour of the required format', () => {
+    // The entire point of requiring a format rather than a content type: both of these are 3D.
+    expect(
+      required(['model/gltf-binary'], [{ location: 'a.fbx', contentType: 'model/fbx' }])
+        ?.undeliveredMediaTypes,
+    ).toEqual(['model/gltf-binary'])
+  })
+
+  it('counts an artifact that reports no content type as covering nothing', () => {
+    expect(required(['model/gltf-binary'], [{ location: 'a.glb' }])?.undeliveredMediaTypes).toEqual(
+      ['model/gltf-binary'],
+    )
+  })
+
+  it('stays silent when there are no artifacts, because the state line already said so', () => {
+    // "It did not deliver a GLB" on top of "it declared nothing" is one fact stated twice as if
+    // it were two, and the second one adds nothing a reader can act on.
+    const view = binaryOutputView(
+      step({
+        stepOptions: { binaryOutput: { storageServiceId: 'files', mediaTypes: ['model/obj'] } },
+        binaryOutputs: report({ undeclared: true }),
+      }),
+    )
+    expect(view?.mediaTypes).toEqual(['model/obj'])
+    expect(view?.undeliveredMediaTypes).toEqual([])
+  })
+})
+
 describe('binaryOutputPickIssues, generative half', () => {
   const catalog = [{ id: 'files', capabilities: ['asset-storage'] }]
   const generators = [
@@ -332,6 +427,80 @@ describe('binaryOutputPickIssues, generative half', () => {
     const pick = binaryOutputPickIssues({ storageServiceId: 'files' }, catalog, true, generators)
     expect(pick.issues).toEqual([])
   })
+
+  // The FORMAT half, mirroring kernel's `binaryFormatCoverage` — and its three outcomes, which
+  // are what a second copy of the rule most easily loses.
+  const meshy = {
+    id: 'meshy',
+    modalities: ['3d-model' as const],
+    mediaTypes: ['model/gltf-binary'],
+  }
+
+  it('mirrors the refusal for a format no DECLARING integration emits', () => {
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: 'files', generatorIds: ['meshy'], mediaTypes: ['model/fbx'] },
+      catalog,
+      true,
+      [meshy],
+    )
+    expect(pick.issues).toContain('media_type_uncovered')
+    expect(pick.uncoveredMediaTypes).toEqual(['model/fbx'])
+    expect(pick.unverifiableMediaTypes).toEqual([])
+  })
+
+  it('keeps an UNCHECKABLE format apart from a refused one, because the step still starts', () => {
+    // `retro` declares no formats — "only my modality is known". Flagging this as a refusal would
+    // send someone editing a selection the backend admits; saying nothing would present an
+    // unchecked requirement as a checked one.
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: 'files', generatorIds: ['retro'], mediaTypes: ['image/webp'] },
+      catalog,
+      true,
+      generators,
+    )
+    expect(pick.issues).toContain('media_type_unverifiable')
+    expect(pick.issues).not.toContain('media_type_uncovered')
+    expect(pick.unverifiableMediaTypes).toEqual(['image/webp'])
+  })
+
+  it('accepts a format the selection covers, however many other formats it emits', () => {
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: 'files', generatorIds: ['meshy'], mediaTypes: ['model/gltf-binary'] },
+      catalog,
+      true,
+      [meshy],
+    )
+    expect(pick.issues).toEqual([])
+  })
+
+  it('reports an UNREADABLE set as an outage and makes no claim about the selection', () => {
+    // The picker's half of the mothership-mode disposition. A failed read arrives as the same
+    // empty list an unregistering deployment produces, so judging the selection against it would
+    // tell someone their step names an integration nobody registered — about an id that is very
+    // likely fine, and with the remedy pointing at the wrong repository.
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: 'files', generatorIds: ['retro'], modalities: ['audio'] },
+      catalog,
+      true,
+      [],
+      true,
+    )
+    expect(pick.issues).toEqual(['generators_unavailable'])
+    expect(pick.unknownGeneratorIds).toEqual([])
+    expect(pick.uncoveredModalities).toEqual([])
+  })
+
+  it('still judges an EMPTY set, which is a real answer about the deployment', () => {
+    // The distinction the flag exists for: same empty list, opposite fact, opposite message.
+    const pick = binaryOutputPickIssues(
+      { storageServiceId: 'files', generatorIds: ['retro'] },
+      catalog,
+      true,
+      [],
+      false,
+    )
+    expect(pick.issues).toContain('unknown_generator')
+  })
 })
 
 describe('binaryOutputPickIssues', () => {

package/app/utils/binaryOutput.ts

@@ -1,4 +1,4 @@
-import { ASSET_STORAGE_CAPABILITY } from '@cat-factory/contracts'
+import { ASSET_STORAGE_CAPABILITY, normalizeMediaType } from '@cat-factory/contracts'
 import type { BinaryModality, RegisteredBinaryGenerator } from '@cat-factory/contracts'
 import type {
   BinaryOutputArtifact,
@@ -118,6 +118,28 @@ export interface BinaryOutputView {
    * Empty ⇒ the step imposes no requirement, so nothing is uncovered by construction.
    */
   modalities: readonly BinaryModality[]
+  /**
+   * The concrete FORMATS the step declares it must deliver
+   * (`stepOptions.binaryOutput.mediaTypes`), for the deliverables where the container is the
+   * requirement rather than a preference — a mesh the engine can import.
+   */
+  mediaTypes: readonly string[]
+  /**
+   * Required formats no DECLARED artifact reports a matching `contentType` for.
+   *
+   * The one judgement this surface can make that admission cannot: admission checked what the
+   * selected integrations CAN emit, and this checks what the run actually came back with. It is
+   * derived in code from the two records the step already carries — never read off the agent's
+   * prose — and it is the question a human opens this panel to answer once a mesh is supposed to
+   * load in a build.
+   *
+   * Computed only when there ARE artifacts to compare against: with none, the state line above
+   * already says nothing was recorded, and "it did not deliver a GLB" on top of "it declared
+   * nothing" is the same fact stated twice as if it were two. An artifact that reports no
+   * `contentType` covers nothing — the platform does not guess a format from a filename — so a
+   * report with formats required and none reported says so rather than passing.
+   */
+  undeliveredMediaTypes: readonly string[]
   /**
    * Integration ids the AGENT named that the deployment does not register. The generative twin of
    * {@link unknownDeclaredServices}, and it needs no exclusion to stay disjoint from anything —
@@ -126,6 +148,14 @@ export interface BinaryOutputView {
    * would leave an artifact attributed to something nobody can look up, with nothing saying so.
    */
   unknownDeclaredGenerators: readonly string[]
+  /**
+   * True when the deployment's integrations could not be READ at settlement, so no claimed id was
+   * checked against them. Rendered as its own line and never as an empty
+   * {@link unknownDeclaredGenerators}: that list being empty otherwise means "every id checked
+   * out", and a reader deciding whether these artifacts are real must not be shown a clean bill
+   * of health nobody actually issued.
+   */
+  generatorsUnverified: boolean
   /** Entries dropped because they were not `{ service, location }` objects. */
   invalidEntries: number
   /** Valid entries dropped past the report's cap — so {@link rows} is a PREFIX. */
@@ -160,6 +190,7 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
   const contextServices = config?.contextServiceIds ?? []
   const generators = config?.generatorIds ?? []
   const modalities = config?.modalities ?? []
+  const mediaTypes = config?.mediaTypes ?? []
   if (!report) {
     return {
       // A step still queued has not had the chance to record anything, which is a different
@@ -172,7 +203,10 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
       unknownDeclaredServices: [],
       generators,
       modalities,
+      mediaTypes,
+      undeliveredMediaTypes: [],
       unknownDeclaredGenerators: [],
+      generatorsUnverified: false,
       invalidEntries: 0,
       omitted: 0,
       misdirected: 0,
@@ -199,13 +233,40 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
     unknownDeclaredServices: report.unknownServices.filter((id) => id !== target),
     generators,
     modalities,
+    mediaTypes,
+    undeliveredMediaTypes: undeliveredMediaTypes(mediaTypes, rows),
     unknownDeclaredGenerators: report.unknownGenerators,
+    generatorsUnverified: report.generatorsUnverified === true,
     invalidEntries: report.invalidEntries,
     omitted: report.omitted,
     misdirected: rows.filter((row) => row.misdirected).length,
   }
 }
 
+/**
+ * The required formats {@link BinaryOutputRow.contentType} does not account for.
+ *
+ * Compared through `normalizeMediaType` on the DECLARED side only: the step's requirement already
+ * came through `mediaTypeSchema` at the write boundary, while the artifact's content type is the
+ * agent's own prose and matches nothing until it is reduced the same way. Exact match after that,
+ * never a modality fallback — an artifact reported as `model/fbx` does not satisfy a requirement
+ * for `model/gltf-binary` just because both are 3D, and that is the entire point of requiring a
+ * format rather than a content type.
+ */
+function undeliveredMediaTypes(
+  required: readonly string[],
+  rows: readonly BinaryOutputRow[],
+): string[] {
+  if (required.length === 0 || rows.length === 0) return []
+  const delivered = new Set(
+    rows.flatMap((row) => {
+      const normalized = row.contentType ? normalizeMediaType(row.contentType) : null
+      return normalized ? [normalized] : []
+    }),
+  )
+  return required.filter((mediaType) => !delivered.has(mediaType))
+}
+
 /**
  * Which failure the report records, in the order the parser can produce them. `parseFailed`
  * and `undeclared` are checked BEFORE the (always empty in those cases) `stored` list, so a
@@ -275,6 +336,10 @@ export const BINARY_OUTPUT_STATE_KEYS: Record<
  * unknown service ids, dropped entries, a truncated list, or a misdirected artifact. Drives
  * the collapsed summary row's tone, so a report with losses can't read as a clean one from
  * the outside of a collapsed section.
+ *
+ * An UNCHECKED verdict counts as one of those qualifications, and it is the only member here
+ * that is not itself a loss: nothing went wrong with the run, but the report is quieter than it
+ * looks, and a collapsed section that renders it as clean would hide the one line saying so.
  */
 export function binaryOutputHasWarnings(view: BinaryOutputView): boolean {
   return (
@@ -283,6 +348,8 @@ export function binaryOutputHasWarnings(view: BinaryOutputView): boolean {
     view.targetUnknown ||
     view.unknownDeclaredServices.length > 0 ||
     view.unknownDeclaredGenerators.length > 0 ||
+    view.generatorsUnverified ||
+    view.undeliveredMediaTypes.length > 0 ||
     view.invalidEntries > 0 ||
     view.omitted > 0 ||
     view.misdirected > 0
@@ -310,6 +377,11 @@ export type BinaryOutputPickIssue =
   | 'catalog_unavailable'
   /** The catalog resolved, but nothing in it declares the `asset-storage` capability. */
   | 'no_storage_service'
+  /** The deployment's registered integrations could not be READ (a mothership-mode node whose
+   *  mothership is unreachable). Kept apart from an empty set for the same reason
+   *  `catalog_unavailable` is: an empty picker is a claim about the deployment's BUILD, and
+   *  acting on it during an outage sends someone looking in the wrong repository. */
+  | 'generators_unavailable'
   /** An enabled generator step with no storage selection — refused at save AND at start. */
   | 'not_selected'
   /** The selected storage id is not in the resolved catalog (kernel's `unknown_service`). */
@@ -325,6 +397,21 @@ export type BinaryOutputPickIssue =
   | 'unknown_generator'
   /** A content type the step declares it delivers is produced by NO selected integration. */
   | 'modality_uncovered'
+  /**
+   * A concrete FORMAT the step declares it delivers is emitted by no selected integration that
+   * declared its formats (kernel's `media_type_uncovered` spelling verbatim). A refusal, like the
+   * two above it.
+   */
+  | 'media_type_uncovered'
+  /**
+   * A declared format nothing selected claims, where a selected integration declares no formats
+   * at all — so it MIGHT be met and nothing may say otherwise. ADVISORY: unlike every other
+   * member here it is not a refusal and must not be styled as one, or a step that is going to
+   * start perfectly well reads as broken. It is here rather than nowhere because the alternative
+   * is silence about a requirement the platform could not check, which is how "nobody looked"
+   * comes to look exactly like "this is fine".
+   */
+  | 'media_type_unverifiable'
 
 /** What the builder found wrong with one step's selection, and which ids to name. */
 export interface BinaryOutputPickState {
@@ -335,6 +422,10 @@ export interface BinaryOutputPickState {
   unknownGeneratorIds: readonly string[]
   /** The declared content types nothing selected can produce, for the message that names them. */
   uncoveredModalities: readonly BinaryModality[]
+  /** The declared formats no DECLARING integration emits — the refusal's own list. */
+  uncoveredMediaTypes: readonly string[]
+  /** The declared formats that could not be judged, kept apart from the refusal above. */
+  unverifiableMediaTypes: readonly string[]
 }
 
 /**
@@ -342,28 +433,84 @@ export interface BinaryOutputPickState {
  * `binaryGeneratorSelectionIssues` so the builder surfaces the `binary_output_generator_invalid`
  * refusal before the round trip rather than inventing a second opinion.
  *
- * It needs no `available` tri-state, unlike the catalog half: the integrations ride the workspace
- * SNAPSHOT rather than their own probe, so there is no "not read yet" state distinct from the
- * board not having loaded — if the caller has a snapshot at all, this list is the whole truth. An
- * empty list is therefore a real EMPTY (this deployment registers none), which is exactly why a
- * selected id in that state is `unknown_generator` and not silence.
+ * `unavailable` is the one state that is NOT derivable from the list, which is why the snapshot
+ * carries it as its own flag. An empty list normally IS a real empty — this deployment registers
+ * none — and that is exactly why a selected id in that state is `unknown_generator` rather than
+ * silence. But on a mothership-mode deployment the set is read from the mothership, and a failed
+ * read is the same empty list about a completely different fact. Reporting `unknown_generator`
+ * there would tell someone their step names an integration nobody registered, about an id that
+ * is very likely fine — the same misattribution the backend refuses to make at admission. So an
+ * unavailable set reports THAT and stops: every other judgement below is a claim about a list
+ * nobody managed to read.
  */
 function generatorPickIssues(
   config: BinaryOutputConfig | undefined,
-  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities'>[],
-): { issues: BinaryOutputPickIssue[]; unknownGeneratorIds: string[]; uncovered: BinaryModality[] } {
+  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities' | 'mediaTypes'>[],
+  unavailable: boolean,
+): {
+  issues: BinaryOutputPickIssue[]
+  unknownGeneratorIds: string[]
+  uncovered: BinaryModality[]
+  uncoveredMediaTypes: string[]
+  unverifiableMediaTypes: string[]
+} {
+  const none = {
+    unknownGeneratorIds: [],
+    uncovered: [],
+    uncoveredMediaTypes: [],
+    unverifiableMediaTypes: [],
+  }
+  if (unavailable) return { issues: ['generators_unavailable'], ...none }
   const byId = new Map(generators.map((g) => [g.id, g]))
   const selectedIds = config?.generatorIds ?? []
   const unknownGeneratorIds = selectedIds.filter((id) => !byId.has(id))
   // Coverage is judged against what RESOLVED, exactly as admission judges it: an unknown id
   // contributes no content types, so a step whose only audio generator is unregistered is told
   // BOTH things — the id is gone, and the requirement it was covering is now uncovered.
-  const covered = new Set(selectedIds.flatMap((id) => byId.get(id)?.modalities ?? []))
+  const selected = selectedIds.flatMap((id) => byId.get(id) ?? [])
+  const covered = new Set(selected.flatMap((g) => g.modalities))
   const uncovered = (config?.modalities ?? []).filter((m) => !covered.has(m))
+  const format = formatCoverage(config?.mediaTypes ?? [], selected)
   const issues: BinaryOutputPickIssue[] = []
   if (unknownGeneratorIds.length) issues.push('unknown_generator')
   if (uncovered.length) issues.push('modality_uncovered')
-  return { issues, unknownGeneratorIds, uncovered }
+  if (format.uncovered.length) issues.push('media_type_uncovered')
+  if (format.unverifiable.length) issues.push('media_type_unverifiable')
+  return {
+    issues,
+    unknownGeneratorIds,
+    uncovered,
+    uncoveredMediaTypes: format.uncovered,
+    unverifiableMediaTypes: format.unverifiable,
+  }
+}
+
+/**
+ * The SPA's copy of kernel's `binaryFormatCoverage`, restated for the reason the two `*_service`
+ * members above are: the builder cannot see kernel, and the wire vocabulary that does cross
+ * (`@cat-factory/contracts`) carries the schema, not the rule.
+ *
+ * The THIRD outcome is what must not be lost in the copying. A generator that declares no formats
+ * has said "only my modality is known" — a documented state, not an empty answer — so a
+ * requirement it cannot be judged against is unverifiable and the step still starts. Collapsing
+ * that into `uncovered` would flag steps the backend admits (and send someone editing a selection
+ * that is fine); collapsing it into silence would present an unchecked requirement as a checked
+ * one.
+ */
+function formatCoverage(
+  required: readonly string[],
+  selected: readonly Pick<RegisteredBinaryGenerator, 'mediaTypes'>[],
+): { uncovered: string[]; unverifiable: string[] } {
+  const emitted = new Set(selected.flatMap((g) => g.mediaTypes ?? []))
+  const undeclared = selected.some((g) => (g.mediaTypes ?? []).length === 0)
+  const uncovered: string[] = []
+  const unverifiable: string[] = []
+  for (const mediaType of required) {
+    if (emitted.has(mediaType)) continue
+    if (undeclared) unverifiable.push(mediaType)
+    else uncovered.push(mediaType)
+  }
+  return { uncovered, unverifiable }
 }
 
 /**
@@ -397,7 +544,11 @@ export function binaryOutputPickIssues(
   // that registers no integrations cannot satisfy a step that selects one. So a call site that
   // omits this FLAGS a selection rather than passing it — the loud direction — and the default
   // stays a legitimate value rather than a hole.
-  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities'>[] = [],
+  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities' | 'mediaTypes'>[] = [],
+  // Whether the deployment's integrations could not be READ. Defaulted to `false` — the honest
+  // default, since every deployment but a mothership-mode node reads them in-process and cannot
+  // fail — so an omitting call site judges the list it was given rather than claiming an outage.
+  generatorsUnavailable = false,
 ): BinaryOutputPickState {
   const resolved = available === true
   const issues: BinaryOutputPickIssue[] = []
@@ -405,7 +556,7 @@ export function binaryOutputPickIssues(
   // resolve against different registries and a step missing its storage pick routinely has a
   // generative fault too. Reporting them one round at a time is exactly the fix-and-retry cycle
   // this function returns every issue to avoid.
-  const generative = generatorPickIssues(config, generators)
+  const generative = generatorPickIssues(config, generators, generatorsUnavailable)
   const noStorageService =
     resolved && !catalog.some((s) => s.capabilities.includes(ASSET_STORAGE_CAPABILITY))
   if (available === false) issues.push('catalog_unavailable')
@@ -419,6 +570,8 @@ export function binaryOutputPickIssues(
       unknownContextIds: [],
       unknownGeneratorIds: generative.unknownGeneratorIds,
       uncoveredModalities: generative.uncovered,
+      uncoveredMediaTypes: generative.uncoveredMediaTypes,
+      unverifiableMediaTypes: generative.unverifiableMediaTypes,
     }
   }
 
@@ -440,5 +593,7 @@ export function binaryOutputPickIssues(
     unknownContextIds,
     unknownGeneratorIds: generative.unknownGeneratorIds,
     uncoveredModalities: generative.uncovered,
+    uncoveredMediaTypes: generative.uncoveredMediaTypes,
+    unverifiableMediaTypes: generative.unverifiableMediaTypes,
   }
 }

package/i18n/locales/de.json

@@ -3744,16 +3744,25 @@
       "binaryOutputContextMissing": "Diese Kontextdienste sind nicht mehr im Katalog: {ids}",
       "binaryOutputUnavailable": "Der Katalog der grundlegenden Dienste ist nicht erreichbar, deshalb lässt sich hier noch nichts wählen.",
       "binaryOutputGenerators": "Erzeugen mit",
+      "binaryOutputGeneratorsUnavailable": "Die generativen Integrationen dieser Installation konnten nicht gelesen werden, daher lässt sich hier noch nichts auswählen. Das ist ein Verbindungsproblem, keine fehlende Registrierung.",
       "binaryOutputGeneratorsPlaceholder": "Keine Integration ausgewählt",
       "binaryOutputModalities": "Muss liefern",
       "binaryOutputModalitiesPlaceholder": "Keine Anforderung",
+      "binaryOutputMediaTypes": "Exakte Formate",
+      "binaryOutputMediaTypesPlaceholder": "Keine Formatanforderung",
+      "binaryOutputDeclaredFormats": "Ausgewählte Integrationen geben an: {formats}",
+      "binaryOutputMediaTypeUncovered": "Keine ausgewählte Integration erzeugt {formats}, was dieser Schritt liefern soll. Wähle eine, die das kann, oder entferne die Anforderung.",
+      "binaryOutputMediaTypeUnverifiable": "Keine ausgewählte Integration gibt {formats} an, aber eine von ihnen gibt überhaupt keine Formate an, daher konnte das nicht geprüft werden. Der Schritt startet trotzdem; prüfe in der API der Integration, ob sie das erzeugen kann.",
+      "binaryOutputMediaTypeUnusable": "Nicht gespeichert, denn dies sind keine Medientypen: {entries}. Schreibe jeden als type/subtype.",
       "binaryOutputGeneratorMissing": "Diese Installation registriert diese generativen Integrationen nicht: {ids}. Sie werden im Code der Installation registriert, nicht in diesem Workspace.",
       "binaryOutputModalityUncovered": "Keine ausgewählte Integration erzeugt {modalities}, was dieser Schritt liefern soll.",
+      "binaryOutputModalityRetired": "{modality} (nicht mehr verfügbar — wähle die Inhaltstypen dieses Schritts neu)",
       "binaryOutputModality": {
         "image": "Bilder",
         "audio": "Audio",
         "video": "Video",
-        "3d": "3D-Modelle",
+        "3d-model": "3D-Modelle",
+        "3d-scene": "3D-Szenen",
         "document": "Dokumente"
       }
     },
@@ -4411,6 +4420,7 @@
     "target": "Speicherdienst",
     "targetNone": "Für diesen Schritt nicht erfasst",
     "contextServices": "Kontext der Erzeugung",
+    "mediaTypes": "Geforderte Formate",
     "misdirectedBadge": "Anderer Dienst",
     "unknownBadge": "Nicht im Katalog",
     "storedCount": "{outcome}, 1 Artefakt | {outcome}, {count} Artefakte",
@@ -4442,10 +4452,12 @@
     "warning": {
       "unknownServices": "Nennt einen Dienst, den der Katalog nicht enthält: {ids}. Der Eintrag bleibt wie angegeben erhalten; prüfe die Kennung gegen den Katalog des Boards. | Nennt Dienste, die der Katalog nicht enthält: {ids}. Die Einträge bleiben wie angegeben erhalten; prüfe die Kennungen gegen den Katalog des Boards.",
       "targetUnknown": "Der Katalog enthält den eigenen Speicherdienst dieses Schritts nicht mehr ({id}), deshalb konnte nichts unten dagegen geprüft werden. Registriere ihn erneut, oder verweise den Schritt auf einen anderen Dienst.",
+      "undeliveredMediaTypes": "Dieser Schritt sollte {formats} liefern, und kein Artefakt unten meldet dieses Format. | Dieser Schritt sollte {formats} liefern, und kein Artefakt unten meldet diese Formate.",
       "misdirected": "1 Artefakt ging an einen anderen Dienst als {target}. | {count} Artefakte gingen an einen anderen Dienst als {target}.",
       "invalidEntries": "1 angegebener Eintrag wurde verworfen: er nannte weder Dienst noch Ablageort. | {count} angegebene Einträge wurden verworfen: sie nannten weder Dienst noch Ablageort.",
       "omitted": "1 weiteres Artefakt wurde jenseits der Berichtsgrenze angegeben und ist nicht aufgeführt. | {count} weitere Artefakte wurden jenseits der Berichtsgrenze angegeben und sind nicht aufgeführt.",
-      "unknownGenerators": "Eine generative Integration genannt, die diese Installation nicht registriert: {ids}. Der Eintrag bleibt wie angegeben erhalten; die Integration wird im Code der Installation registriert, nicht in diesem Workspace. | Generative Integrationen genannt, die diese Installation nicht registriert: {ids}. Ihre Einträge bleiben wie angegeben erhalten; Integrationen werden im Code der Installation registriert, nicht in diesem Workspace."
+      "unknownGenerators": "Eine generative Integration genannt, die diese Installation nicht registriert: {ids}. Der Eintrag bleibt wie angegeben erhalten; die Integration wird im Code der Installation registriert, nicht in diesem Workspace. | Generative Integrationen genannt, die diese Installation nicht registriert: {ids}. Ihre Einträge bleiben wie angegeben erhalten; Integrationen werden im Code der Installation registriert, nicht in diesem Workspace.",
+      "generatorsUnverified": "Die generativen Integrationen dieser Installation konnten beim Abschluss des Schritts nicht gelesen werden, daher wurden die unten genannten Integrationen nicht dagegen geprüft. Die Einträge bleiben wie angegeben erhalten."
     },
     "unknownGeneratorBadge": "Nicht registriert"
   },
@@ -4909,6 +4921,12 @@
         "unexpected": "Der Server hat eine unerwartete Antwort zurückgegeben. Versuche es erneut und gib die Details an den Betreiber des Deployments weiter, wenn es weiterhin auftritt."
       }
     },
+    "unavailable": {
+      "description": {
+        "binary_generators_unreachable": "Die generativen Integrationen dieser Installation konnten gerade nicht gelesen werden, deshalb wurde der Lauf nicht gestartet. Es ist nichts falsch konfiguriert und keine Änderung nötig: versuchen Sie es erneut, sobald die Verbindung wieder steht.",
+        "foundational_builtins_unreachable": "Die integrierten Basisdienste dieser Installation konnten gerade nicht gelesen werden. Es ist nichts falsch konfiguriert und keine Änderung nötig: versuchen Sie es erneut, sobald die Verbindung wieder steht."
+      }
+    },
     "action": {
       "retryFailed": "Wiederholung fehlgeschlagen",
       "startFailed": "Start fehlgeschlagen",

package/i18n/locales/en.json

@@ -548,6 +548,12 @@
         }
       }
     },
+    "unavailable": {
+      "description": {
+        "binary_generators_unreachable": "This deployment's generative integrations could not be read just now, so the run was not started. Nothing is misconfigured and no change is needed: try again once the connection recovers.",
+        "foundational_builtins_unreachable": "This deployment's built-in foundational services could not be read just now. Nothing is misconfigured and no change is needed: try again once the connection recovers."
+      }
+    },
     "action": {
       "retryFailed": "Retry failed",
       "startFailed": "Failed to start",
@@ -4223,16 +4229,26 @@
       "binaryOutputContextMissing": "These context services are no longer in the catalog: {ids}",
       "binaryOutputUnavailable": "The foundational services catalog is unreachable, so nothing can be picked here yet.",
       "binaryOutputGenerators": "Generate with",
+      "binaryOutputGeneratorsUnavailable": "This deployment's generative integrations could not be read, so nothing can be picked here yet. This is a connection problem, not a missing registration.",
       "binaryOutputGeneratorsPlaceholder": "No integration selected",
       "binaryOutputModalities": "Must deliver",
       "binaryOutputModalitiesPlaceholder": "No requirement",
+      "binaryOutputMediaTypes": "Exact formats",
+      "binaryOutputMediaTypesPlaceholder": "No format requirement",
+      "binaryOutputDeclaredFormats": "Selected integrations declare: {formats}",
+      "binaryOutputMediaTypeUncovered": "No selected integration emits {formats}, which this step is set to deliver. Pick one that does, or drop the requirement.",
+      "binaryOutputMediaTypeUnverifiable": "No selected integration declares {formats}, but one of them declares no formats at all, so this could not be checked. The step still starts; confirm from the integration's API that it can emit this.",
+      "binaryOutputMediaTypeUnusable": "Not saved, because these are not media types: {entries}. Write each one as type/subtype.",
       "binaryOutputGeneratorMissing": "This deployment does not register these generative integrations: {ids}. They are registered in the deployment's code, not in this workspace.",
       "binaryOutputModalityUncovered": "No selected integration produces {modalities}, which this step is set to deliver.",
+      "binaryOutputModalityRetired": "{modality} (no longer offered — re-pick this step's content types)",
+      "@binaryOutputModalityRetired": "A content type saved on a step that this build no longer defines. {modality} is a raw machine value (e.g. 3d) and must not be translated. Appears inside the binaryOutputModalityUncovered sentence, so keep it a short noun phrase, not a sentence.",
       "binaryOutputModality": {
         "image": "Images",
         "audio": "Audio",
         "video": "Video",
-        "3d": "3D models",
+        "3d-model": "3D models",
+        "3d-scene": "3D scenes",
         "document": "Documents"
       }
     },
@@ -5623,6 +5639,7 @@
     "target": "Storage service",
     "targetNone": "None recorded on this step",
     "contextServices": "Generation context",
+    "mediaTypes": "Required formats",
     "misdirectedBadge": "Other service",
     "unknownBadge": "Not in catalog",
     "storedCount": "{outcome}, 1 artifact | {outcome}, {count} artifacts",
@@ -5654,10 +5671,12 @@
     "warning": {
       "unknownServices": "Named a service the catalog does not contain: {ids}. The entry is kept as claimed; check the id against the workspace catalog. | Named services the catalog does not contain: {ids}. Their entries are kept as claimed; check the ids against the workspace catalog.",
       "targetUnknown": "The catalog no longer contains this step's own storage service ({id}), so nothing below could be checked against it. Register it again, or point the step at another service.",
+      "undeliveredMediaTypes": "This step was set to deliver {formats}, and no artifact below reports that format. | This step was set to deliver {formats}, and no artifact below reports those formats.",
       "misdirected": "1 artifact went to a service other than {target}. | {count} artifacts went to a service other than {target}.",
       "invalidEntries": "1 declared entry was dropped: it named no service and location. | {count} declared entries were dropped: they named no service and location.",
       "omitted": "1 more artifact was declared beyond the report's limit and is not listed. | {count} more artifacts were declared beyond the report's limit and are not listed.",
-      "unknownGenerators": "Named a generative integration this deployment does not register: {ids}. The entry is kept as claimed; the integration is registered in the deployment's code, not in this workspace. | Named generative integrations this deployment does not register: {ids}. Their entries are kept as claimed; integrations are registered in the deployment's code, not in this workspace."
+      "unknownGenerators": "Named a generative integration this deployment does not register: {ids}. The entry is kept as claimed; the integration is registered in the deployment's code, not in this workspace. | Named generative integrations this deployment does not register: {ids}. Their entries are kept as claimed; integrations are registered in the deployment's code, not in this workspace.",
+      "generatorsUnverified": "This deployment's generative integrations could not be read when the step settled, so the integrations named below were not checked against them. The entries are kept as claimed."
     },
     "unknownGeneratorBadge": "Not registered"
   },