@cat-factory/app 0.206.0 → 0.207.0

package/app/components/binaryOutput/BinaryOutputReport.vue

@@ -88,6 +88,16 @@ const state = computed(() => {
         <dt class="text-slate-500">{{ t('binaryOutput.contextServices') }}</dt>
         <dd class="min-w-0 font-mono text-slate-400">{{ view.contextServices.join(', ') }}</dd>
       </template>
+      <!-- The formats the step REQUIRED, beside where they were meant to go. Rendered whenever
+           the step stated any, including on a run that delivered them: the requirement is what
+           makes the content types below it readable, and a reader checking whether a mesh will
+           load needs to see what was asked for even when nothing went wrong. -->
+      <template v-if="view.mediaTypes.length">
+        <dt class="text-slate-500">{{ t('binaryOutput.mediaTypes') }}</dt>
+        <dd class="min-w-0 font-mono text-slate-400" data-testid="binary-output-media-types">
+          {{ view.mediaTypes.join(', ') }}
+        </dd>
+      </template>
     </dl>
 
     <!-- The artifacts. `location` is the service's OWN addressing — an object key, a path, a
@@ -201,6 +211,22 @@ const state = computed(() => {
       <li v-if="view.generatorsUnverified" data-testid="binary-output-generators-unverified">
         {{ t('binaryOutput.warning.generatorsUnverified') }}
       </li>
+      <!-- The one judgement this panel can make that admission could not: admission checked what
+           the selected integrations CAN emit, this checks what came back. Derived in code from
+           the step's own two records — the requirement and the reported content types — never
+           read off the agent's prose. -->
+      <li v-if="view.undeliveredMediaTypes.length" data-testid="binary-output-undelivered-formats">
+        {{
+          t(
+            'binaryOutput.warning.undeliveredMediaTypes',
+            {
+              formats: view.undeliveredMediaTypes.join(', '),
+              count: view.undeliveredMediaTypes.length,
+            },
+            view.undeliveredMediaTypes.length,
+          )
+        }}
+      </li>
       <li v-if="view.misdirected" data-testid="binary-output-misdirected-note">
         {{
           t(

package/app/components/pipeline/BinaryOutputStepPicker.logic.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+import { parseMediaTypeRequirement, sameFormats } from './BinaryOutputStepPicker.logic'
+
+describe('parseMediaTypeRequirement', () => {
+  it('stores the reduction the backend compares against, not what was typed', () => {
+    // The field is forgiving on the way in and exact on the way out. A locally-lowercased copy
+    // would store a format that matches nothing and then reads everywhere as one that was simply
+    // never emitted — indistinguishable from a real delivery failure.
+    expect(parseMediaTypeRequirement(' Model/GLTF-Binary , image/PNG ').usable).toEqual([
+      'model/gltf-binary',
+      'image/png',
+    ])
+  })
+
+  it('drops a parameter, because a requirement is a format and not one request encoding', () => {
+    expect(parseMediaTypeRequirement('model/gltf-binary; charset=binary').usable).toEqual([
+      'model/gltf-binary',
+    ])
+  })
+
+  it('NAMES what it refused rather than quietly shortening the requirement', () => {
+    // A requirement someone typed and the step does not carry is the "absent reads as fine"
+    // failure the rest of this surface is built to avoid, so the entry survives verbatim for the
+    // warning to quote.
+    const parsed = parseMediaTypeRequirement('gltf, model/obj, ')
+    expect(parsed.usable).toEqual(['model/obj'])
+    expect(parsed.unusable).toEqual(['gltf'])
+  })
+
+  it('deduplicates what two spellings reduce to, keeping first-stated order', () => {
+    const parsed = parseMediaTypeRequirement('model/obj, MODEL/OBJ, model/gltf-binary')
+    expect(parsed.usable).toEqual(['model/obj', 'model/gltf-binary'])
+  })
+
+  it('maps no synonyms, so a near neighbour stays a separate requirement', () => {
+    // `model/obj` and `application/x-tgif` are the same file. Collapsing them would make the
+    // admission check accept a GLB where an OBJ was required — the failure it exists to prevent.
+    const parsed = parseMediaTypeRequirement('model/obj, application/x-tgif')
+    expect(parsed.usable).toEqual(['model/obj', 'application/x-tgif'])
+  })
+
+  it('reads an empty requirement as no requirement', () => {
+    expect(parseMediaTypeRequirement('  ,  ')).toEqual({ usable: [], unusable: [] })
+  })
+})
+
+describe('sameFormats', () => {
+  it('treats an absent list and an empty one as the same write', () => {
+    // Clearing the field stores `undefined`, so the two spellings of "no requirement" must not
+    // read as a change that came from elsewhere.
+    expect(sameFormats(undefined, [])).toBe(true)
+  })
+
+  it('is order-sensitive, because the field writes back exactly what it read', () => {
+    expect(sameFormats(['a/b', 'c/d'], ['c/d', 'a/b'])).toBe(false)
+    expect(sameFormats(['a/b', 'c/d'], ['a/b', 'c/d'])).toBe(true)
+  })
+})

package/app/components/pipeline/BinaryOutputStepPicker.logic.ts

@@ -0,0 +1,55 @@
+import { mediaTypeSchema, normalizeMediaType } from '@cat-factory/contracts'
+import * as v from 'valibot'
+
+// The pure half of BinaryOutputStepPicker: reading a free-text FORMAT requirement, and telling
+// this field's own write apart from one that landed underneath it. Extracted for the reason every
+// `*.logic.ts` here is — a decision worth a test should not need a mounted component to reach.
+
+/** A parsed format requirement: what the step will carry, and what was refused on the way in. */
+export interface ParsedMediaTypeRequirement {
+  /** Normalised, deduplicated, order-preserving — exactly what gets stored. */
+  usable: string[]
+  /** Entries that are not a `type/subtype` at all, kept VERBATIM so the warning can quote them. */
+  unusable: string[]
+}
+
+/**
+ * Read a comma-separated format requirement the way the field accepts it and the way the backend
+ * will hold it.
+ *
+ * Forgiving on the way IN, exact on the way out, and both halves are the backend's own rules
+ * imported rather than re-implemented: `normalizeMediaType` is the same reduction the comparison
+ * uses at both ends (a divergent local lowercasing would store a format that matches nothing and
+ * reads everywhere as one that was simply never emitted), and `mediaTypeSchema` is what the save
+ * boundary holds this to — so what is refused here is exactly what would come back as a 422 one
+ * round trip later.
+ *
+ * A refused entry is REPORTED, never quietly dropped: a requirement someone typed and the step
+ * does not carry is the "absent reads as fine" failure the rest of this surface exists to avoid.
+ */
+export function parseMediaTypeRequirement(text: string): ParsedMediaTypeRequirement {
+  const usable: string[] = []
+  const unusable: string[] = []
+  for (const entry of text
+    .split(',')
+    .map((part) => part.trim())
+    .filter(Boolean)) {
+    const normalized = normalizeMediaType(entry)
+    if (normalized && v.safeParse(mediaTypeSchema, normalized).success) usable.push(normalized)
+    else unusable.push(entry)
+  }
+  return { usable: [...new Set(usable)], unusable }
+}
+
+/**
+ * Whether two stored format lists are the same write.
+ *
+ * Order-sensitive on purpose: the field writes back what it read, so a differing order means the
+ * value came from somewhere else, which is precisely what the caller is asking about.
+ */
+export function sameFormats(
+  a: readonly string[] | undefined,
+  b: readonly string[] | undefined,
+): boolean {
+  return (a ?? []).join(',') === (b ?? []).join(',')
+}

package/app/components/pipeline/BinaryOutputStepPicker.vue

@@ -19,14 +19,16 @@
 // ride the workspace snapshot (`binaryGenerators`) rather than a catalog read. Both halves are
 // offered here because a step needs both to work, and only this surface can tell a human that the
 // content types it promises to deliver are not covered by anything it selected.
-import { computed } from 'vue'
+import { computed, ref, watch } from 'vue'
 import {
   ASSET_STORAGE_CAPABILITY,
   GENERATION_CONTEXT_CAPABILITY,
+  isBinaryModality,
   type BinaryModality,
   type BinaryOutputConfig,
 } from '@cat-factory/contracts'
 import { binaryOutputPickIssues, type BinaryOutputPickIssue } from '~/utils/binaryOutput'
+import { parseMediaTypeRequirement, sameFormats } from './BinaryOutputStepPicker.logic'
 
 const props = defineProps<{ index: number }>()
 
@@ -44,12 +46,42 @@ const MODALITY_LABELS: Record<BinaryModality, () => string> = {
   image: () => t('pipeline.builder.binaryOutputModality.image'),
   audio: () => t('pipeline.builder.binaryOutputModality.audio'),
   video: () => t('pipeline.builder.binaryOutputModality.video'),
-  '3d': () => t('pipeline.builder.binaryOutputModality.3d'),
+  '3d-model': () => t('pipeline.builder.binaryOutputModality.3d-model'),
+  '3d-scene': () => t('pipeline.builder.binaryOutputModality.3d-scene'),
   document: () => t('pipeline.builder.binaryOutputModality.document'),
 }
-const MODALITY_ORDER: BinaryModality[] = ['image', 'audio', 'video', '3d', 'document']
+const MODALITY_ORDER: BinaryModality[] = [
+  'image',
+  'audio',
+  'video',
+  '3d-model',
+  '3d-scene',
+  'document',
+]
+/**
+ * A content type in the reader's language, INCLUDING one this build no longer defines.
+ *
+ * The `Record` above is exhaustive over the union, so the lookup looks total — and is not, because
+ * `modalities` is PERSISTED: a step saved under an earlier vocabulary carries a member that has
+ * since been retired (`3d` did exactly that when it split into `3d-model` and `3d-scene`). Such a
+ * value is by construction uncovered by every registered integration, so it lands in the
+ * `modality_uncovered` warning below — the one line whose job is to tell someone what to re-pick —
+ * and a bare `MODALITY_LABELS[modality]()` there is a `TypeError` that takes the whole builder
+ * down, on exactly the surface the fix has to be made on.
+ *
+ * The guard is `isBinaryModality` (contracts, derived from the picklist itself) rather than an
+ * optional call on the `Record`, so the narrowing says WHY it is needed and a member added to the
+ * vocabulary is known here without anyone remembering to widen anything.
+ *
+ * The retired value is NAMED rather than silently dropped or guessed at a current member: nothing
+ * here knows which one was meant, and a modality quietly missing from the list reads as a step
+ * that never required it. This is the standing "absent is not zero" rule at the one place the
+ * typed-key check cannot reach — the key is static, but the LOOKUP is a runtime value.
+ */
 function modalityLabel(modality: BinaryModality): string {
-  return MODALITY_LABELS[modality]()
+  return isBinaryModality(modality)
+    ? MODALITY_LABELS[modality]()
+    : t('pipeline.builder.binaryOutputModalityRetired', { modality: String(modality) })
 }
 
 const config = computed(() => pipelines.draftBinaryOutput(props.index))
@@ -143,6 +175,64 @@ function setGenerators(ids: string[]) {
 function setModalities(modalities: BinaryModality[]) {
   patch({ modalities })
 }
+
+/**
+ * The FORMAT requirement is free text, not a pick from the selection, and that is deliberate: the
+ * whole reason a step states a format is that the selected integrations might not cover it, and a
+ * picker offering only what they declare could never express the requirement whose violation this
+ * feature exists to catch. What the selection declares is offered as a HINT below instead.
+ *
+ * Held in a local ref rather than bound straight to the config so a half-typed `model/` is not
+ * parsed on every keystroke, and so the normalisation the field applies is VISIBLE — the text
+ * snaps back to what was stored.
+ */
+const mediaTypeText = ref((config.value?.mediaTypes ?? []).join(', '))
+
+/**
+ * Entries that are not a `type/subtype` at all, named rather than silently dropped — a
+ * requirement someone typed and the step does not carry is exactly the "absent reads as fine"
+ * failure the rest of this surface is built to avoid.
+ */
+const unusableMediaTypes = ref<string[]>([])
+
+/**
+ * What this field last wrote, so the watch below can tell its OWN patch from a config that
+ * changed underneath it.
+ */
+let lastWritten: string[] | undefined = config.value?.mediaTypes
+
+watch(
+  () => config.value?.mediaTypes,
+  (mediaTypes) => {
+    mediaTypeText.value = (mediaTypes ?? []).join(', ')
+    // The rejected entries belong to the TEXT that was typed, so they outlive this field's own
+    // patch — clearing them on every config change would erase the warning in the same tick it
+    // was raised, since accepting `image/png` out of `foo, image/png` is itself a patch. Any
+    // OTHER route to a new value (the picker rebound to another step, the draft reloaded,
+    // storage cleared and the bag dropped) is describing text that no longer exists, and a
+    // warning about entries nobody can see is the same "absent reads as fine" failure pointed
+    // the other way.
+    if (!sameFormats(mediaTypes, lastWritten)) unusableMediaTypes.value = []
+    lastWritten = mediaTypes
+  },
+)
+
+function setMediaTypes(text: string) {
+  const { usable, unusable } = parseMediaTypeRequirement(text)
+  unusableMediaTypes.value = unusable
+  mediaTypeText.value = usable.join(', ')
+  // Claimed BEFORE the patch, so the watch above reads this write as its own however it is
+  // flushed, and the entries just rejected survive to be rendered.
+  lastWritten = usable.length ? usable : undefined
+  patch({ mediaTypes: lastWritten })
+}
+
+/** What the SELECTED integrations say they emit — the discoverable half of the free-text field. */
+const declaredFormats = computed(() => {
+  const byId = new Map(agents.binaryGenerators.map((generator) => [generator.id, generator]))
+  const selected = (config.value?.generatorIds ?? []).flatMap((id) => byId.get(id) ?? [])
+  return [...new Set(selected.flatMap((generator) => generator.mediaTypes ?? []))]
+})
 </script>
 
 <template>
@@ -216,6 +306,33 @@ function setModalities(modalities: BinaryModality[]) {
       />
     </div>
 
+    <!-- The FORMAT requirement, one notch finer than the content types above it and shown right
+         under them. Both tiers: like the rest of this picker it is not an override of a default —
+         a format nobody stated is a format the run does not check. -->
+    <div v-if="config?.storageServiceId" class="flex items-center gap-2">
+      <span class="text-[10px] text-slate-500">{{
+        t('pipeline.builder.binaryOutputMediaTypes')
+      }}</span>
+      <UInput
+        class="w-56"
+        :model-value="mediaTypeText"
+        size="xs"
+        :placeholder="t('pipeline.builder.binaryOutputMediaTypesPlaceholder')"
+        data-testid="binary-output-media-type-input"
+        @update:model-value="mediaTypeText = String($event)"
+        @change="setMediaTypes(mediaTypeText)"
+      />
+    </div>
+    <p
+      v-if="config?.storageServiceId && declaredFormats.length"
+      class="ms-1 text-[10px] text-slate-500"
+      data-testid="binary-output-declared-formats"
+    >
+      {{
+        t('pipeline.builder.binaryOutputDeclaredFormats', { formats: declaredFormats.join(', ') })
+      }}
+    </p>
+
     <!-- Every refusal this step would hit, named where it is fixable. Each is its own line
          with its own remedy: an unreachable catalog is not an empty one, a lost service is not
          an untagged one, and a lost CONTEXT service is not a lost storage target. -->
@@ -280,5 +397,42 @@ function setModalities(modalities: BinaryModality[]) {
         })
       }}
     </p>
+    <p
+      v-if="has('media_type_uncovered')"
+      class="text-[10px] text-amber-400"
+      data-testid="binary-output-media-type-uncovered"
+    >
+      {{
+        t('pipeline.builder.binaryOutputMediaTypeUncovered', {
+          formats: pick.uncoveredMediaTypes.join(', '),
+        })
+      }}
+    </p>
+    <!-- ADVISORY, and styled apart from every line above it: the step starts. The backend admits
+         a format requirement it could not judge, because a generator that declares no formats has
+         said only that its formats are unknown — and a surface that dressed that up as a refusal
+         would send someone editing a selection that is fine. -->
+    <p
+      v-if="has('media_type_unverifiable')"
+      class="text-[10px] text-slate-500"
+      data-testid="binary-output-media-type-unverifiable"
+    >
+      {{
+        t('pipeline.builder.binaryOutputMediaTypeUnverifiable', {
+          formats: pick.unverifiableMediaTypes.join(', '),
+        })
+      }}
+    </p>
+    <p
+      v-if="unusableMediaTypes.length"
+      class="text-[10px] text-amber-400"
+      data-testid="binary-output-media-type-unusable"
+    >
+      {{
+        t('pipeline.builder.binaryOutputMediaTypeUnusable', {
+          entries: unusableMediaTypes.join(', '),
+        })
+      }}
+    </p>
   </div>
 </template>

package/app/utils/binaryOutput.spec.ts

@@ -311,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 = [
@@ -368,6 +428,51 @@ describe('binaryOutputPickIssues, generative half', () => {
     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

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 —
@@ -168,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
@@ -180,6 +203,8 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
       unknownDeclaredServices: [],
       generators,
       modalities,
+      mediaTypes,
+      undeliveredMediaTypes: [],
       unknownDeclaredGenerators: [],
       generatorsUnverified: false,
       invalidEntries: 0,
@@ -208,6 +233,8 @@ 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,
@@ -216,6 +243,30 @@ export function binaryOutputView(step: PipelineStep | null | undefined): BinaryO
   }
 }
 
+/**
+ * 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
@@ -298,6 +349,7 @@ export function binaryOutputHasWarnings(view: BinaryOutputView): boolean {
     view.unknownDeclaredServices.length > 0 ||
     view.unknownDeclaredGenerators.length > 0 ||
     view.generatorsUnverified ||
+    view.undeliveredMediaTypes.length > 0 ||
     view.invalidEntries > 0 ||
     view.omitted > 0 ||
     view.misdirected > 0
@@ -345,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 {
@@ -355,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[]
 }
 
 /**
@@ -374,24 +445,72 @@ export interface BinaryOutputPickState {
  */
 function generatorPickIssues(
   config: BinaryOutputConfig | undefined,
-  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities'>[],
+  generators: readonly Pick<RegisteredBinaryGenerator, 'id' | 'modalities' | 'mediaTypes'>[],
   unavailable: boolean,
-): { issues: BinaryOutputPickIssue[]; unknownGeneratorIds: string[]; uncovered: BinaryModality[] } {
-  if (unavailable) {
-    return { issues: ['generators_unavailable'], unknownGeneratorIds: [], uncovered: [] }
+): {
+  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 }
 }
 
 /**
@@ -425,7 +544,7 @@ 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.
@@ -451,6 +570,8 @@ export function binaryOutputPickIssues(
       unknownContextIds: [],
       unknownGeneratorIds: generative.unknownGeneratorIds,
       uncoveredModalities: generative.uncovered,
+      uncoveredMediaTypes: generative.uncoveredMediaTypes,
+      unverifiableMediaTypes: generative.unverifiableMediaTypes,
     }
   }
 
@@ -472,5 +593,7 @@ export function binaryOutputPickIssues(
     unknownContextIds,
     unknownGeneratorIds: generative.unknownGeneratorIds,
     uncoveredModalities: generative.uncovered,
+    uncoveredMediaTypes: generative.uncoveredMediaTypes,
+    unverifiableMediaTypes: generative.unverifiableMediaTypes,
   }
 }

package/i18n/locales/de.json

@@ -3748,13 +3748,21 @@
       "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"
       }
     },
@@ -4412,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",
@@ -4443,6 +4452,7 @@
     "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.",

package/i18n/locales/en.json

@@ -4233,13 +4233,22 @@
       "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"
       }
     },
@@ -5630,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",
@@ -5661,6 +5671,7 @@
     "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.",

package/i18n/locales/es.json

@@ -4106,13 +4106,21 @@
       "binaryOutputGeneratorsPlaceholder": "Ninguna integración seleccionada",
       "binaryOutputModalities": "Debe entregar",
       "binaryOutputModalitiesPlaceholder": "Sin requisito",
+      "binaryOutputMediaTypes": "Formatos exactos",
+      "binaryOutputMediaTypesPlaceholder": "Sin requisito de formato",
+      "binaryOutputDeclaredFormats": "Las integraciones seleccionadas declaran: {formats}",
+      "binaryOutputMediaTypeUncovered": "Ninguna integración seleccionada emite {formats}, que este paso debe entregar. Elige una que lo haga o quita el requisito.",
+      "binaryOutputMediaTypeUnverifiable": "Ninguna integración seleccionada declara {formats}, pero una de ellas no declara ningún formato, así que no se pudo comprobar. El paso se inicia igualmente; confirma en la API de la integración que puede emitirlo.",
+      "binaryOutputMediaTypeUnusable": "No se guardó, porque esto no son tipos de medio: {entries}. Escribe cada uno como type/subtype.",
       "binaryOutputGeneratorMissing": "Esta instalación no registra estas integraciones generativas: {ids}. Se registran en el código de la instalación, no en este espacio de trabajo.",
       "binaryOutputModalityUncovered": "Ninguna integración seleccionada produce {modalities}, que este paso debe entregar.",
+      "binaryOutputModalityRetired": "{modality} (ya no disponible: vuelve a elegir los tipos de contenido de este paso)",
       "binaryOutputModality": {
         "image": "Imágenes",
         "audio": "Audio",
         "video": "Vídeo",
-        "3d": "Modelos 3D",
+        "3d-model": "Modelos 3D",
+        "3d-scene": "Escenas 3D",
         "document": "Documentos"
       }
     },
@@ -5381,6 +5389,7 @@
     "target": "Servicio de almacenamiento",
     "targetNone": "No registrado en este paso",
     "contextServices": "Contexto de generación",
+    "mediaTypes": "Formatos requeridos",
     "misdirectedBadge": "Otro servicio",
     "unknownBadge": "Fuera del catálogo",
     "storedCount": "{outcome}, 1 artefacto | {outcome}, {count} artefactos",
@@ -5412,6 +5421,7 @@
     "warning": {
       "unknownServices": "Nombró un servicio que el catálogo no contiene: {ids}. La entrada se conserva tal como se declaró; comprueba el identificador con el catálogo del tablero. | Nombró servicios que el catálogo no contiene: {ids}. Sus entradas se conservan tal como se declararon; comprueba los identificadores con el catálogo del tablero.",
       "targetUnknown": "El catálogo ya no contiene el servicio de almacenamiento de este paso ({id}), así que nada de lo de abajo pudo comprobarse contra él. Vuelve a registrarlo, o apunta el paso a otro servicio.",
+      "undeliveredMediaTypes": "Este paso debía entregar {formats} y ningún artefacto de abajo informa ese formato. | Este paso debía entregar {formats} y ningún artefacto de abajo informa esos formatos.",
       "misdirected": "1 artefacto fue a un servicio distinto de {target}. | {count} artefactos fueron a un servicio distinto de {target}.",
       "invalidEntries": "Se descartó 1 entrada declarada: no nombraba servicio ni ubicación. | Se descartaron {count} entradas declaradas: no nombraban servicio ni ubicación.",
       "omitted": "Se declaró 1 artefacto más por encima del límite del informe y no aparece en la lista. | Se declararon {count} artefactos más por encima del límite del informe y no aparecen en la lista.",

package/i18n/locales/fr.json

@@ -4106,13 +4106,21 @@
       "binaryOutputGeneratorsPlaceholder": "Aucune intégration sélectionnée",
       "binaryOutputModalities": "Doit livrer",
       "binaryOutputModalitiesPlaceholder": "Aucune exigence",
+      "binaryOutputMediaTypes": "Formats exacts",
+      "binaryOutputMediaTypesPlaceholder": "Aucune exigence de format",
+      "binaryOutputDeclaredFormats": "Les intégrations sélectionnées déclarent : {formats}",
+      "binaryOutputMediaTypeUncovered": "Aucune intégration sélectionnée n’émet {formats}, que cette étape doit livrer. Choisissez-en une qui le fait, ou retirez l’exigence.",
+      "binaryOutputMediaTypeUnverifiable": "Aucune intégration sélectionnée ne déclare {formats}, mais l’une d’elles ne déclare aucun format, cela n’a donc pas pu être vérifié. L’étape démarre quand même ; confirmez dans l’API de l’intégration qu’elle peut l’émettre.",
+      "binaryOutputMediaTypeUnusable": "Non enregistré, car ce ne sont pas des types de média : {entries}. Écrivez chacun sous la forme type/subtype.",
       "binaryOutputGeneratorMissing": "Ce déploiement n'enregistre pas ces intégrations génératives : {ids}. Elles s'enregistrent dans le code du déploiement, pas dans cet espace de travail.",
       "binaryOutputModalityUncovered": "Aucune intégration sélectionnée ne produit {modalities}, que cette étape doit livrer.",
+      "binaryOutputModalityRetired": "{modality} (n'est plus proposé — resélectionnez les types de contenu de cette étape)",
       "binaryOutputModality": {
         "image": "Images",
         "audio": "Audio",
         "video": "Vidéo",
-        "3d": "Modèles 3D",
+        "3d-model": "Modèles 3D",
+        "3d-scene": "Scènes 3D",
         "document": "Documents"
       }
     },
@@ -5381,6 +5389,7 @@
     "target": "Service de stockage",
     "targetNone": "Non enregistré pour cette étape",
     "contextServices": "Contexte de génération",
+    "mediaTypes": "Formats exigés",
     "misdirectedBadge": "Autre service",
     "unknownBadge": "Hors catalogue",
     "storedCount": "{outcome}, 1 artefact | {outcome}, {count} artefacts",
@@ -5412,6 +5421,7 @@
     "warning": {
       "unknownServices": "A nommé un service absent du catalogue : {ids}. L'entrée est conservée telle que déclarée ; vérifiez l'identifiant dans le catalogue du tableau. | A nommé des services absents du catalogue : {ids}. Leurs entrées sont conservées telles que déclarées ; vérifiez les identifiants dans le catalogue du tableau.",
       "targetUnknown": "Le catalogue ne contient plus le service de stockage propre à cette étape ({id}), donc rien ci-dessous n'a pu être vérifié par rapport à lui. Enregistrez-le de nouveau, ou orientez l'étape vers un autre service.",
+      "undeliveredMediaTypes": "Cette étape devait livrer {formats}, et aucun artefact ci-dessous ne signale ce format. | Cette étape devait livrer {formats}, et aucun artefact ci-dessous ne signale ces formats.",
       "misdirected": "1 artefact est allé vers un service autre que {target}. | {count} artefacts sont allés vers un service autre que {target}.",
       "invalidEntries": "1 entrée déclarée a été écartée : elle ne nommait ni service ni emplacement. | {count} entrées déclarées ont été écartées : elles ne nommaient ni service ni emplacement.",
       "omitted": "1 artefact supplémentaire a été déclaré au-delà de la limite du rapport et n'est pas listé. | {count} artefacts supplémentaires ont été déclarés au-delà de la limite du rapport et ne sont pas listés.",

package/i18n/locales/he.json

@@ -4117,13 +4117,21 @@
       "binaryOutputGeneratorsPlaceholder": "לא נבחרה אינטגרציה",
       "binaryOutputModalities": "חייב לספק",
       "binaryOutputModalitiesPlaceholder": "ללא דרישה",
+      "binaryOutputMediaTypes": "פורמטים מדויקים",
+      "binaryOutputMediaTypesPlaceholder": "ללא דרישת פורמט",
+      "binaryOutputDeclaredFormats": "האינטגרציות שנבחרו מצהירות על: {formats}",
+      "binaryOutputMediaTypeUncovered": "אף אינטגרציה שנבחרה אינה מפיקה {formats}, שהשלב הזה אמור לספק. בחרו אחת שמפיקה, או הסירו את הדרישה.",
+      "binaryOutputMediaTypeUnverifiable": "אף אינטגרציה שנבחרה אינה מצהירה על {formats}, אבל אחת מהן אינה מצהירה על פורמטים כלל, ולכן לא ניתן היה לבדוק זאת. השלב יתחיל בכל מקרה; ודאו ב-API של האינטגרציה שהיא יכולה להפיק את זה.",
+      "binaryOutputMediaTypeUnusable": "לא נשמר, כי אלה אינם סוגי מדיה: {entries}. כתבו כל אחד בצורה type/subtype.",
       "binaryOutputGeneratorMissing": "ההתקנה הזו אינה רושמת את האינטגרציות הגנרטיביות האלה: {ids}. הן נרשמות בקוד ההתקנה, לא במרחב העבודה הזה.",
       "binaryOutputModalityUncovered": "אף אינטגרציה שנבחרה אינה מייצרת {modalities}, שהשלב הזה אמור לספק.",
+      "binaryOutputModalityRetired": "{modality} (כבר לא נתמך — בחרו מחדש את סוגי התוכן של השלב)",
       "binaryOutputModality": {
         "image": "תמונות",
         "audio": "אודיו",
         "video": "וידאו",
-        "3d": "מודלים תלת-ממדיים",
+        "3d-model": "מודלים תלת-ממדיים",
+        "3d-scene": "סצנות תלת-ממדיות",
         "document": "מסמכים"
       }
     },
@@ -5392,6 +5400,7 @@
     "target": "שירות אחסון",
     "targetNone": "לא נרשם בשלב זה",
     "contextServices": "הקשר ליצירה",
+    "mediaTypes": "פורמטים נדרשים",
     "misdirectedBadge": "שירות אחר",
     "unknownBadge": "לא בקטלוג",
     "storedCount": "{outcome}, פריט אחד | {outcome}, {count} פריטים",
@@ -5423,6 +5432,7 @@
     "warning": {
       "unknownServices": "צוין שירות שאינו בקטלוג: {ids}. הרשומה נשמרת כפי שהוצהרה; בדוק את המזהה מול קטלוג הלוח. | צוינו שירותים שאינם בקטלוג: {ids}. הרשומות נשמרות כפי שהוצהרו; בדוק את המזהים מול קטלוג הלוח.",
       "targetUnknown": "הקטלוג כבר אינו מכיל את שירות האחסון של השלב הזה ({id}), ולכן לא ניתן היה להשוות מולו דבר ממה שלהלן. רשום אותו מחדש, או הפנה את השלב לשירות אחר.",
+      "undeliveredMediaTypes": "השלב הזה אמור היה לספק {formats}, ואף פריט למטה אינו מדווח על הפורמט הזה. | השלב הזה אמור היה לספק {formats}, ואף פריט למטה אינו מדווח על הפורמטים האלה.",
       "misdirected": "פריט אחד הגיע לשירות אחר מ- {target}. | {count} פריטים הגיעו לשירות אחר מ- {target}.",
       "invalidEntries": "רשומה מוצהרת אחת נדחתה: לא צוינו בה שירות ומיקום. | {count} רשומות מוצהרות נדחו: לא צוינו בהן שירות ומיקום.",
       "omitted": "פריט נוסף אחד הוצהר מעבר למגבלת הדוח ואינו מופיע ברשימה. | {count} פריטים נוספים הוצהרו מעבר למגבלת הדוח ואינם מופיעים ברשימה.",

package/i18n/locales/it.json

@@ -3748,13 +3748,21 @@
       "binaryOutputGeneratorsPlaceholder": "Nessuna integrazione selezionata",
       "binaryOutputModalities": "Deve fornire",
       "binaryOutputModalitiesPlaceholder": "Nessun requisito",
+      "binaryOutputMediaTypes": "Formati esatti",
+      "binaryOutputMediaTypesPlaceholder": "Nessun requisito di formato",
+      "binaryOutputDeclaredFormats": "Le integrazioni selezionate dichiarano: {formats}",
+      "binaryOutputMediaTypeUncovered": "Nessuna integrazione selezionata emette {formats}, che questo passaggio deve fornire. Scegline una che lo faccia oppure rimuovi il requisito.",
+      "binaryOutputMediaTypeUnverifiable": "Nessuna integrazione selezionata dichiara {formats}, ma una di esse non dichiara alcun formato, quindi non è stato possibile verificarlo. Il passaggio parte comunque; verifica nell’API dell’integrazione che possa emetterlo.",
+      "binaryOutputMediaTypeUnusable": "Non salvato, perché questi non sono tipi di media: {entries}. Scrivi ciascuno come type/subtype.",
       "binaryOutputGeneratorMissing": "Questa installazione non registra queste integrazioni generative: {ids}. Si registrano nel codice dell'installazione, non in questo spazio di lavoro.",
       "binaryOutputModalityUncovered": "Nessuna integrazione selezionata produce {modalities}, che questo passaggio deve fornire.",
+      "binaryOutputModalityRetired": "{modality} (non più disponibile: riseleziona i tipi di contenuto di questo passaggio)",
       "binaryOutputModality": {
         "image": "Immagini",
         "audio": "Audio",
         "video": "Video",
-        "3d": "Modelli 3D",
+        "3d-model": "Modelli 3D",
+        "3d-scene": "Scene 3D",
         "document": "Documenti"
       }
     },
@@ -4412,6 +4420,7 @@
     "target": "Servizio di archiviazione",
     "targetNone": "Non registrato per questo passo",
     "contextServices": "Contesto della generazione",
+    "mediaTypes": "Formati richiesti",
     "misdirectedBadge": "Altro servizio",
     "unknownBadge": "Fuori catalogo",
     "storedCount": "{outcome}, 1 artefatto | {outcome}, {count} artefatti",
@@ -4443,6 +4452,7 @@
     "warning": {
       "unknownServices": "Ha indicato un servizio che il catalogo non contiene: {ids}. La voce viene conservata come dichiarata; verifica l'identificativo nel catalogo della board. | Ha indicato servizi che il catalogo non contiene: {ids}. Le voci vengono conservate come dichiarate; verifica gli identificativi nel catalogo della board.",
       "targetUnknown": "Il catalogo non contiene più il servizio di archiviazione di questo passo ({id}), quindi nulla di quanto segue ha potuto essere verificato rispetto ad esso. Registralo di nuovo, oppure indirizza il passo a un altro servizio.",
+      "undeliveredMediaTypes": "Questo passaggio doveva fornire {formats} e nessun artefatto qui sotto riporta quel formato. | Questo passaggio doveva fornire {formats} e nessun artefatto qui sotto riporta quei formati.",
       "misdirected": "1 artefatto è finito su un servizio diverso da {target}. | {count} artefatti sono finiti su un servizio diverso da {target}.",
       "invalidEntries": "1 voce dichiarata è stata scartata: non indicava né servizio né posizione. | {count} voci dichiarate sono state scartate: non indicavano né servizio né posizione.",
       "omitted": "È stato dichiarato 1 altro artefatto oltre il limite del rapporto e non compare nell'elenco. | Sono stati dichiarati altri {count} artefatti oltre il limite del rapporto e non compaiono nell'elenco.",

package/i18n/locales/ja.json

@@ -4118,13 +4118,21 @@
       "binaryOutputGeneratorsPlaceholder": "統合が未選択",
       "binaryOutputModalities": "提供が必要",
       "binaryOutputModalitiesPlaceholder": "要件なし",
+      "binaryOutputMediaTypes": "厳密な形式",
+      "binaryOutputMediaTypesPlaceholder": "形式の要件なし",
+      "binaryOutputDeclaredFormats": "選択した統合が宣言している形式: {formats}",
+      "binaryOutputMediaTypeUncovered": "このステップが提供することになっている {formats} を、選択されたどの統合も出力できません。出力できる統合を選ぶか、要件を外してください。",
+      "binaryOutputMediaTypeUnverifiable": "選択されたどの統合も {formats} を宣言していませんが、うち一つは形式をまったく宣言していないため、確認できませんでした。ステップはそのまま開始されます。その統合の API で出力できるか確認してください。",
+      "binaryOutputMediaTypeUnusable": "メディアタイプではないため保存されませんでした: {entries}。それぞれ type/subtype の形で入力してください。",
       "binaryOutputGeneratorMissing": "このデプロイメントは次の生成統合を登録していません: {ids}。これらはこのワークスペースではなくデプロイメントのコードで登録します。",
       "binaryOutputModalityUncovered": "このステップが提供することになっている {modalities} を、選択されたどの統合も生成できません。",
+      "binaryOutputModalityRetired": "{modality}（現在は提供されていません。このステップのコンテンツ種別を選び直してください）",
       "binaryOutputModality": {
         "image": "画像",
         "audio": "音声",
         "video": "動画",
-        "3d": "3D モデル",
+        "3d-model": "3D モデル",
+        "3d-scene": "3D シーン",
         "document": "ドキュメント"
       }
     },
@@ -5393,6 +5401,7 @@
     "target": "保存サービス",
     "targetNone": "このステップには記録なし",
     "contextServices": "生成のコンテキスト",
+    "mediaTypes": "必要な形式",
     "misdirectedBadge": "別のサービス",
     "unknownBadge": "カタログ外",
     "storedCount": "{outcome}、{count} 件",
@@ -5424,6 +5433,7 @@
     "warning": {
       "unknownServices": "カタログにないサービスが指定されています: {ids}。宣言のまま保持されます。ボードのカタログで ID を確認してください。",
       "targetUnknown": "このステップ自身の保存サービス ({id}) がカタログにもうありません。このため下のどれも照合できませんでした。再登録するか、別のサービスを指定してください。",
+      "undeliveredMediaTypes": "このステップは {formats} を提供するはずでしたが、下のどの成果物もそれを報告していません。",
       "misdirected": "{count} 件の成果物が {target} 以外のサービスに保存されました。",
       "invalidEntries": "サービスと場所のどちらも示さない宣言項目 {count} 件を破棄しました。",
       "omitted": "レポートの上限を超えてさらに {count} 件が宣言されており、一覧には含まれていません。",

package/i18n/locales/pl.json

@@ -4106,13 +4106,21 @@
       "binaryOutputGeneratorsPlaceholder": "Nie wybrano integracji",
       "binaryOutputModalities": "Musi dostarczyć",
       "binaryOutputModalitiesPlaceholder": "Brak wymagania",
+      "binaryOutputMediaTypes": "Dokładne formaty",
+      "binaryOutputMediaTypesPlaceholder": "Brak wymagania formatu",
+      "binaryOutputDeclaredFormats": "Wybrane integracje deklarują: {formats}",
+      "binaryOutputMediaTypeUncovered": "Żadna wybrana integracja nie tworzy {formats}, które ten krok ma dostarczyć. Wybierz taką, która to potrafi, albo usuń wymaganie.",
+      "binaryOutputMediaTypeUnverifiable": "Żadna wybrana integracja nie deklaruje {formats}, ale jedna z nich nie deklaruje żadnych formatów, więc nie dało się tego sprawdzić. Krok i tak wystartuje; potwierdź w API integracji, że potrafi to wytworzyć.",
+      "binaryOutputMediaTypeUnusable": "Nie zapisano, bo to nie są typy mediów: {entries}. Zapisz każdy jako type/subtype.",
       "binaryOutputGeneratorMissing": "Ta instalacja nie rejestruje tych integracji generatywnych: {ids}. Rejestruje się je w kodzie instalacji, a nie w tym obszarze roboczym.",
       "binaryOutputModalityUncovered": "Żadna wybrana integracja nie tworzy {modalities}, które ten krok ma dostarczyć.",
+      "binaryOutputModalityRetired": "{modality} (już niedostępne — wybierz ponownie typy treści tego kroku)",
       "binaryOutputModality": {
         "image": "Obrazy",
         "audio": "Dźwięk",
         "video": "Wideo",
-        "3d": "Modele 3D",
+        "3d-model": "Modele 3D",
+        "3d-scene": "Sceny 3D",
         "document": "Dokumenty"
       }
     },
@@ -5381,6 +5389,7 @@
     "target": "Usługa przechowywania",
     "targetNone": "Nie zapisano dla tego kroku",
     "contextServices": "Kontekst generowania",
+    "mediaTypes": "Wymagane formaty",
     "misdirectedBadge": "Inna usługa",
     "unknownBadge": "Spoza katalogu",
     "storedCount": "{outcome}, 1 artefakt | {outcome}, {count} artefakty | {outcome}, {count} artefaktów",
@@ -5412,6 +5421,7 @@
     "warning": {
       "unknownServices": "Wskazał usługę, której nie ma w katalogu: {ids}. Wpis zachowano w zadeklarowanej postaci; sprawdź identyfikator w katalogu tablicy. | Wskazał usługi, których nie ma w katalogu: {ids}. Wpisy zachowano w zadeklarowanej postaci; sprawdź identyfikatory w katalogu tablicy. | Wskazał usługi, których nie ma w katalogu: {ids}. Wpisy zachowano w zadeklarowanej postaci; sprawdź identyfikatory w katalogu tablicy.",
       "targetUnknown": "Katalog nie zawiera już własnej usługi przechowywania tego kroku ({id}), więc niczego poniżej nie dało się z nią porównać. Zarejestruj ją ponownie albo wskaż krokowi inną usługę.",
+      "undeliveredMediaTypes": "Ten krok miał dostarczyć {formats}, a żaden artefakt poniżej nie zgłasza tego formatu. | Ten krok miał dostarczyć {formats}, a żaden artefakt poniżej nie zgłasza tych formatów. | Ten krok miał dostarczyć {formats}, a żaden artefakt poniżej nie zgłasza tych formatów.",
       "misdirected": "1 artefakt trafił do usługi innej niż {target}. | {count} artefakty trafiły do usługi innej niż {target}. | {count} artefaktów trafiło do usługi innej niż {target}.",
       "invalidEntries": "Odrzucono 1 zadeklarowany wpis: nie wskazywał usługi ani lokalizacji. | Odrzucono {count} zadeklarowane wpisy: nie wskazywały usługi ani lokalizacji. | Odrzucono {count} zadeklarowanych wpisów: nie wskazywały usługi ani lokalizacji.",
       "omitted": "Zadeklarowano jeszcze 1 artefakt ponad limit raportu i nie ma go na liście. | Zadeklarowano jeszcze {count} artefakty ponad limit raportu i nie ma ich na liście. | Zadeklarowano jeszcze {count} artefaktów ponad limit raportu i nie ma ich na liście.",

package/i18n/locales/tr.json

@@ -4118,13 +4118,21 @@
       "binaryOutputGeneratorsPlaceholder": "Entegrasyon seçilmedi",
       "binaryOutputModalities": "Teslim etmeli",
       "binaryOutputModalitiesPlaceholder": "Gereksinim yok",
+      "binaryOutputMediaTypes": "Kesin biçimler",
+      "binaryOutputMediaTypesPlaceholder": "Biçim gereksinimi yok",
+      "binaryOutputDeclaredFormats": "Seçili entegrasyonların bildirdiği biçimler: {formats}",
+      "binaryOutputMediaTypeUncovered": "Seçili entegrasyonların hiçbiri, bu adımın teslim etmesi gereken {formats} biçimini üretmiyor. Üretebilen birini seçin ya da gereksinimi kaldırın.",
+      "binaryOutputMediaTypeUnverifiable": "Seçili entegrasyonların hiçbiri {formats} bildirmiyor, ancak içlerinden biri hiç biçim bildirmiyor; bu yüzden denetlenemedi. Adım yine de başlar; entegrasyonun API’sinden bunu üretebildiğini doğrulayın.",
+      "binaryOutputMediaTypeUnusable": "Kaydedilmedi, çünkü bunlar ortam türü değil: {entries}. Her birini type/subtype olarak yazın.",
       "binaryOutputGeneratorMissing": "Bu kurulum şu üretken entegrasyonları kaydetmiyor: {ids}. Bunlar bu çalışma alanında değil, kurulumun kodunda kaydedilir.",
       "binaryOutputModalityUncovered": "Seçili entegrasyonların hiçbiri, bu adımın teslim etmesi gereken {modalities} içeriğini üretmiyor.",
+      "binaryOutputModalityRetired": "{modality} (artık sunulmuyor — bu adımın içerik türlerini yeniden seçin)",
       "binaryOutputModality": {
         "image": "Görseller",
         "audio": "Ses",
         "video": "Video",
-        "3d": "3B modeller",
+        "3d-model": "3B modeller",
+        "3d-scene": "3B sahneler",
         "document": "Belgeler"
       }
     },
@@ -5393,6 +5401,7 @@
     "target": "Depolama hizmeti",
     "targetNone": "Bu adım için kaydedilmedi",
     "contextServices": "Üretim bağlamı",
+    "mediaTypes": "Gerekli biçimler",
     "misdirectedBadge": "Başka hizmet",
     "unknownBadge": "Katalogda yok",
     "storedCount": "{outcome}, 1 ürün | {outcome}, {count} ürün",
@@ -5424,6 +5433,7 @@
     "warning": {
       "unknownServices": "Katalogda bulunmayan bir hizmet adı verdi: {ids}. Kayıt bildirildiği gibi saklanır; kimliği pano kataloguyla karşılaştır. | Katalogda bulunmayan hizmet adları verdi: {ids}. Kayıtları bildirildiği gibi saklanır; kimlikleri pano kataloguyla karşılaştır.",
       "targetUnknown": "Katalog artık bu adımın kendi depolama hizmetini ({id}) içermiyor, bu yüzden aşağıdakilerin hiçbiri onunla karşılaştırılamadı. Hizmeti yeniden kaydet ya da adımı başka bir hizmete yönlendir.",
+      "undeliveredMediaTypes": "Bu adım {formats} teslim etmeliydi ve aşağıdaki hiçbir ürün bu biçimi bildirmiyor. | Bu adım {formats} teslim etmeliydi ve aşağıdaki hiçbir ürün bu biçimleri bildirmiyor.",
       "misdirected": "1 ürün {target} dışında bir hizmete gitti. | {count} ürün {target} dışında bir hizmete gitti.",
       "invalidEntries": "Bildirilen 1 kayıt düşürüldü: ne hizmet ne de konum belirtiyordu. | Bildirilen {count} kayıt düşürüldü: ne hizmet ne de konum belirtiyorlardı.",
       "omitted": "Raporun sınırının ötesinde 1 ürün daha bildirildi ve listede yer almıyor. | Raporun sınırının ötesinde {count} ürün daha bildirildi ve listede yer almıyor.",

package/i18n/locales/uk.json

@@ -4106,13 +4106,21 @@
       "binaryOutputGeneratorsPlaceholder": "Інтеграцію не вибрано",
       "binaryOutputModalities": "Має надати",
       "binaryOutputModalitiesPlaceholder": "Без вимоги",
+      "binaryOutputMediaTypes": "Точні формати",
+      "binaryOutputMediaTypesPlaceholder": "Без вимоги до формату",
+      "binaryOutputDeclaredFormats": "Вибрані інтеграції заявляють: {formats}",
+      "binaryOutputMediaTypeUncovered": "Жодна вибрана інтеграція не створює {formats}, які має надати цей крок. Виберіть таку, яка це вміє, або зніміть вимогу.",
+      "binaryOutputMediaTypeUnverifiable": "Жодна вибрана інтеграція не заявляє {formats}, але одна з них взагалі не заявляє форматів, тому перевірити це не вдалося. Крок все одно запуститься; перевірте в API інтеграції, чи може вона це створити.",
+      "binaryOutputMediaTypeUnusable": "Не збережено, бо це не типи медіа: {entries}. Запишіть кожен як type/subtype.",
       "binaryOutputGeneratorMissing": "Ця інсталяція не реєструє ці генеративні інтеграції: {ids}. Їх реєструють у коді інсталяції, а не в цьому робочому просторі.",
       "binaryOutputModalityUncovered": "Жодна вибрана інтеграція не створює {modalities}, які має надати цей крок.",
+      "binaryOutputModalityRetired": "{modality} (більше не пропонується — виберіть типи вмісту цього кроку заново)",
       "binaryOutputModality": {
         "image": "Зображення",
         "audio": "Аудіо",
         "video": "Відео",
-        "3d": "3D-моделі",
+        "3d-model": "3D-моделі",
+        "3d-scene": "3D-сцени",
         "document": "Документи"
       }
     },
@@ -5381,6 +5389,7 @@
     "target": "Служба зберігання",
     "targetNone": "Для цього кроку не записано",
     "contextServices": "Контекст генерації",
+    "mediaTypes": "Потрібні формати",
     "misdirectedBadge": "Інша служба",
     "unknownBadge": "Поза каталогом",
     "storedCount": "{outcome}, 1 артефакт | {outcome}, {count} артефакти | {outcome}, {count} артефактів",
@@ -5412,6 +5421,7 @@
     "warning": {
       "unknownServices": "Названо службу, якої немає в каталозі: {ids}. Запис збережено так, як його заявлено; перевірте ідентифікатор у каталозі дошки. | Названо служби, яких немає в каталозі: {ids}. Записи збережено так, як їх заявлено; перевірте ідентифікатори у каталозі дошки. | Названо служби, яких немає в каталозі: {ids}. Записи збережено так, як їх заявлено; перевірте ідентифікатори у каталозі дошки.",
       "targetUnknown": "Каталог більше не містить власної служби зберігання цього кроку ({id}), тому нічого нижче не вдалося з нею зіставити. Зареєструйте її знову або вкажіть кроку іншу службу.",
+      "undeliveredMediaTypes": "Цей крок мав надати {formats}, а жоден артефакт нижче не заявляє цього формату. | Цей крок мав надати {formats}, а жоден артефакт нижче не заявляє цих форматів. | Цей крок мав надати {formats}, а жоден артефакт нижче не заявляє цих форматів.",
       "misdirected": "1 артефакт потрапив до служби, відмінної від {target}. | {count} артефакти потрапили до служби, відмінної від {target}. | {count} артефактів потрапило до служби, відмінної від {target}.",
       "invalidEntries": "Відкинуто 1 заявлений запис: у ньому не було ні служби, ні розташування. | Відкинуто {count} заявлені записи: у них не було ні служби, ні розташування. | Відкинуто {count} заявлених записів: у них не було ні служби, ні розташування.",
       "omitted": "Ще 1 артефакт заявлено понад межу звіту, і його немає в списку. | Ще {count} артефакти заявлено понад межу звіту, і їх немає в списку. | Ще {count} артефактів заявлено понад межу звіту, і їх немає в списку.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.206.0",
+  "version": "0.207.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.213.0"
+    "@cat-factory/contracts": "0.214.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",