@cat-factory/app 0.256.3 → 0.257.0

package/app/components/binaryCandidates/BinaryCandidatesWindow.vue

@@ -0,0 +1,284 @@
+<script setup lang="ts">
+// Generated-candidate comparison window: the dedicated surface for a binary-output step that
+// generated several candidates rather than committing to one producer unobserved
+// (docs/initiatives/binary-output-foundational-storage.md).
+//
+// It reads the live state straight off the run's step (`step.binaryCandidates`, kept fresh by the
+// execution stream) and lets a human KEEP one candidate, or several under distinct ids. Keeping
+// re-runs the same step to deliver exactly what survived and clear the rest.
+//
+// Two properties the surface has to hold on to, both of which are the reason this feature exists:
+//
+//  - A candidate WITHOUT a preview is still a candidate. An org's asset store may issue no public
+//    link, and the platform will not invent one, so such a row renders its details and says the
+//    preview is unavailable rather than disappearing or showing a broken image.
+//  - It doubles as the RECORD. Once the choice is made the window keeps rendering, marking what
+//    was kept and under which id, because the decision is the only place the run's own rationale
+//    lives. An AUTOMATIC keep says so: nobody looked at it.
+import { computed, ref, watch } from 'vue'
+import { useResultView } from '~/composables/useResultView'
+import { useExecutionStore } from '~/stores/execution'
+import { useBoardStore } from '~/stores/board'
+import { useBinaryCandidatesStore } from '~/stores/binaryCandidates'
+import {
+  BINARY_CANDIDATE_NO_CHOICE_KEYS,
+  binaryCandidateHasWarnings,
+  binaryCandidateView,
+} from '~/utils/binaryCandidates'
+import ResultWindowShell from '~/components/panels/ResultWindowShell.vue'
+
+const execution = useExecutionStore()
+const board = useBoardStore()
+const candidates = useBinaryCandidatesStore()
+const access = useWorkspaceAccess()
+const { t } = useI18n()
+
+// The warm-up read is keyed by the RUN, not the block: `load` calls
+// `GET /workspaces/:ws/executions/:executionId/binary-candidates`, and a block id put in that
+// position resolves to no run at all, so the fetch quietly returns nothing and the window shows
+// whatever the stream happened to deliver. `instanceId` is nullable (a view can be opened without
+// a resolved run), so the guard is the same one `PrReviewWindow` makes.
+const { open, blockId, instanceId, stepIndex, close } = useResultView('binary-candidates', {
+  onOpen: ({ instanceId }) => {
+    if (instanceId) void candidates.load(instanceId)
+  },
+})
+
+const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))
+const headerTitle = computed(() =>
+  block.value
+    ? t('binaryCandidates.titleWithBlock', { title: block.value.title })
+    : t('binaryCandidates.title'),
+)
+const instance = computed(() =>
+  instanceId.value === null ? null : (execution.getInstance(instanceId.value) ?? null),
+)
+const step = computed(() => {
+  if (instance.value === null || stepIndex.value === null) return null
+  return instance.value.steps[stepIndex.value] ?? null
+})
+const view = computed(() => binaryCandidateView(step.value))
+const warnings = computed(() => (view.value ? binaryCandidateHasWarnings(view.value) : false))
+const noChoiceKey = computed(() => {
+  const reason = view.value?.state.noChoiceReason
+  return reason ? BINARY_CANDIDATE_NO_CHOICE_KEYS[reason] : null
+})
+
+/** The ids the human has ticked, and the id each is to be stored under. */
+const selected = ref<string[]>([])
+const aliases = ref<Record<string, string>>({})
+const note = ref('')
+
+// Default the selection to the first candidate of the first subject whenever the candidate set
+// changes. Something ticked is the honest default for a single-select comparison (the person is
+// choosing between options, not deciding whether to have one) and it keeps the primary button
+// meaningful from the first render.
+watch(
+  () => view.value?.state.candidates.map((c) => c.id).join(','),
+  () => {
+    const first = view.value?.groups[0]?.rows[0]?.id
+    if (selected.value.some((id) => view.value?.state.candidates.some((c) => c.id === id))) return
+    selected.value = first ? [first] : []
+  },
+  { immediate: true },
+)
+
+function toggle(id: string): void {
+  if (!view.value?.awaiting) return
+  if (view.value.multiSelect) {
+    selected.value = selected.value.includes(id)
+      ? selected.value.filter((existing) => existing !== id)
+      : [...selected.value, id]
+    return
+  }
+  selected.value = [id]
+}
+
+/**
+ * Whether the request would be accepted. Mirrors the backend's own refusals rather than only
+ * disabling on emptiness: keeping several candidates under one name would store one artifact and
+ * report several, so the alias requirement is stated here, where it can be fixed, instead of
+ * arriving as a 422.
+ */
+const missingAliases = computed(() =>
+  selected.value.length > 1 ? selected.value.filter((id) => !(aliases.value[id] ?? '').trim()) : [],
+)
+const duplicateAliases = computed(() => {
+  const used = selected.value.map((id) => (aliases.value[id] ?? '').trim()).filter(Boolean)
+  return new Set(used).size !== used.length
+})
+const canKeep = computed(
+  () =>
+    view.value?.awaiting === true &&
+    !candidates.keeping &&
+    selected.value.length > 0 &&
+    missingAliases.value.length === 0 &&
+    !duplicateAliases.value,
+)
+
+async function onKeep() {
+  const id = instanceId.value
+  if (!id || !canKeep.value) return
+  const keep = selected.value.map((candidateId) => {
+    const alias = (aliases.value[candidateId] ?? '').trim()
+    return alias ? { candidateId, storeAs: alias } : { candidateId }
+  })
+  const text = note.value.trim()
+  await candidates.keep(id, { keep, ...(text ? { note: text } : {}) }).catch(() => {})
+}
+</script>
+
+<template>
+  <ResultWindowShell
+    :open="open"
+    icon="i-lucide-images"
+    icon-class="bg-sky-500/15 text-sky-300"
+    :title="headerTitle"
+    :subtitle="t('binaryCandidates.subtitle')"
+    width="5xl"
+    testid="binary-candidates-window"
+    @close="close"
+  >
+    <div v-if="view" class="min-h-0 flex-1 overflow-y-auto px-5 py-4">
+      <!-- Why there was nothing to choose between. Its own line per reason: a model that never
+           declared its candidates and one whose block was unreadable need different fixes. -->
+      <p
+        v-if="noChoiceKey"
+        class="mb-3 rounded border border-amber-500/30 bg-amber-500/5 px-3 py-2 text-xs text-amber-200"
+        data-testid="binary-candidates-no-choice"
+      >
+        {{ t(noChoiceKey) }}
+      </p>
+
+      <!-- An automatic keep is NOT a review, and must never render as one. -->
+      <p
+        v-if="view.automatic"
+        class="mb-3 rounded border border-slate-600/40 bg-slate-800/40 px-3 py-2 text-xs text-slate-300"
+        data-testid="binary-candidates-automatic"
+      >
+        {{ t('binaryCandidates.automatic') }}
+      </p>
+
+      <!-- Every loss the parse counted, so a comparison over three of five cannot read as one
+           over all five. -->
+      <p
+        v-if="warnings"
+        class="mb-3 text-xs text-amber-300"
+        data-testid="binary-candidates-warnings"
+      >
+        <span v-if="view.state.omitted">{{
+          t('binaryCandidates.warning.omitted', { count: view.state.omitted })
+        }}</span>
+        <span v-if="view.state.invalidEntries">
+          {{ t('binaryCandidates.warning.invalid', { count: view.state.invalidEntries }) }}</span
+        >
+        <span v-if="view.state.unusablePreviews">
+          {{ t('binaryCandidates.warning.previews', { count: view.state.unusablePreviews }) }}</span
+        >
+      </p>
+
+      <div v-for="group in view.groups" :key="group.subject ?? '·'" class="mb-6">
+        <h3 class="mb-2 text-xs font-medium text-slate-400">
+          {{ group.subject ?? t('binaryCandidates.unlabelledSubject') }}
+        </h3>
+        <div class="grid grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-3">
+          <div
+            v-for="row in group.rows"
+            :key="row.id"
+            class="rounded border p-2 transition"
+            :class="
+              selected.includes(row.id) || row.kept
+                ? 'border-sky-400/60 bg-sky-500/5'
+                : 'border-slate-700/60'
+            "
+            data-testid="binary-candidate-card"
+            @click="toggle(row.id)"
+          >
+            <img
+              v-if="row.previewUrl"
+              :src="row.previewUrl"
+              :alt="row.label ?? row.id"
+              class="mb-2 max-h-56 w-full rounded object-contain"
+              data-testid="binary-candidate-preview"
+            />
+            <!-- No preview is ORDINARY (a private asset store issues no link), so it is stated
+                 rather than left as an empty frame the reader reads as a failed generation. -->
+            <p
+              v-else
+              class="mb-2 flex h-24 items-center justify-center rounded bg-slate-800/60 px-2 text-center text-[10px] text-slate-400"
+              data-testid="binary-candidate-no-preview"
+            >
+              {{ t('binaryCandidates.noPreview') }}
+            </p>
+            <p class="text-xs text-slate-200">
+              {{
+                row.generator
+                  ? t('binaryCandidates.fromGenerator', { generator: row.generator })
+                  : t('binaryCandidates.unattributed')
+              }}
+            </p>
+            <p v-if="row.note" class="mt-1 text-[11px] text-slate-400">{{ row.note }}</p>
+            <p class="mt-1 break-all text-[10px] text-slate-500">{{ row.location }}</p>
+            <p v-if="row.contentType" class="text-[10px] text-slate-500">{{ row.contentType }}</p>
+            <p v-if="row.kept" class="mt-1 text-[11px] text-emerald-300">
+              {{
+                row.storeAs
+                  ? t('binaryCandidates.keptAs', { id: row.storeAs })
+                  : t('binaryCandidates.kept')
+              }}
+            </p>
+            <!-- The ALTERNATE ID, shown only where it is load-bearing: keeping two candidates
+                 under one name stores one artifact and reports two. -->
+            <UInput
+              v-if="view.awaiting && view.multiSelect && selected.includes(row.id)"
+              class="mt-2"
+              size="xs"
+              :model-value="aliases[row.id] ?? ''"
+              :placeholder="t('binaryCandidates.storeAsPlaceholder')"
+              data-testid="binary-candidate-store-as"
+              @click.stop
+              @update:model-value="aliases[row.id] = String($event)"
+            />
+          </div>
+        </div>
+      </div>
+
+      <div v-if="view.awaiting" class="mt-2">
+        <UTextarea
+          v-model="note"
+          :rows="2"
+          size="xs"
+          :placeholder="t('binaryCandidates.notePlaceholder')"
+          data-testid="binary-candidates-note"
+        />
+        <p
+          v-if="missingAliases.length"
+          class="mt-1 text-[11px] text-amber-300"
+          data-testid="binary-candidates-missing-alias"
+        >
+          {{ t('binaryCandidates.missingAlias') }}
+        </p>
+        <p
+          v-else-if="duplicateAliases"
+          class="mt-1 text-[11px] text-amber-300"
+          data-testid="binary-candidates-duplicate-alias"
+        >
+          {{ t('binaryCandidates.duplicateAlias') }}
+        </p>
+        <p v-if="candidates.error" class="mt-1 text-[11px] text-red-300">{{ candidates.error }}</p>
+        <div class="mt-2 flex justify-end">
+          <UButton
+            size="xs"
+            :disabled="!canKeep || !access.canExecuteRuns.value"
+            :title="access.canExecuteRuns.value ? undefined : t('access.noRunExecute')"
+            :loading="candidates.keeping"
+            data-testid="binary-candidates-keep"
+            @click="onKeep"
+          >
+            {{ t('binaryCandidates.keepAction', { count: selected.length }) }}
+          </UButton>
+        </div>
+      </div>
+    </div>
+  </ResultWindowShell>
+</template>

package/app/components/binaryOutput/BinaryOutputReport.vue

@@ -14,6 +14,7 @@
 import { computed } from 'vue'
 import type { PipelineStep } from '~/types/execution'
 import { BINARY_OUTPUT_STATE_KEYS, binaryOutputView } from '~/utils/binaryOutput'
+import { binaryCandidateView } from '~/utils/binaryCandidates'
 import CopyButton from '~/components/common/CopyButton.vue'
 
 // Two callers, one renderer — the same split `StepEffortReport` makes: the generic step-detail
@@ -27,6 +28,16 @@ const { t } = useI18n()
 
 const view = computed(() => binaryOutputView(props.step))
 
+/**
+ * The CANDIDATE decision, when this step compared before delivering.
+ *
+ * Rendered here rather than left to the comparison window, because that window is reachable only
+ * while the run is PARKED on it: once the choice is made, a step click routes to the kind's own
+ * result view and the record of what was compared, and by whom, would have nowhere to live. This
+ * is the same placement rule the artifacts above it follow, one decision earlier.
+ */
+const candidates = computed(() => binaryCandidateView(props.step))
+
 /**
  * The outcome's own copy, from the shared exhaustive map — shared so the collapsed section row
  * above this panel and the sentence inside it can never claim different outcomes. `stored`
@@ -55,6 +66,28 @@ const state = computed(() => {
       <span>{{ t('binaryOutput.heading') }}</span>
     </div>
 
+    <!-- The CANDIDATE decision, when this step compared before delivering. It sits ABOVE the
+         delivery outcome because it happened first, and because "which of four was this" is the
+         question the artifacts below cannot answer. An AUTOMATIC keep says so: nobody looked. -->
+    <p
+      v-if="candidates && candidates.state.candidates.length > 0"
+      class="text-[12px] leading-relaxed text-slate-300"
+      data-testid="binary-output-candidate-decision"
+    >
+      {{
+        candidates.automatic
+          ? t('binaryOutput.candidates.automatic', { total: candidates.state.candidates.length })
+          : candidates.state.choice
+            ? t('binaryOutput.candidates.chosen', {
+                kept: candidates.state.choice.kept.length,
+                total: candidates.state.candidates.length,
+              })
+            : t('binaryOutput.candidates.awaiting', {
+                total: candidates.state.candidates.length,
+              })
+      }}
+    </p>
+
     <!-- What happened, in one sentence, before any list. Four of the five states have no list
          at all, and the fifth still needs its qualifications read alongside it. -->
     <p

package/app/components/forkDecision/ForkDecisionWindow.vue

@@ -26,7 +26,9 @@ const { t } = useI18n()
 // Hybrid: state rides the coder step (like follow-ups), but warm it from the GET on open too.
 // No `stepRef`: this is a pre-run decision, so there's no "restart from here".
 const { open, blockId, instanceId, stepIndex, close } = useResultView('fork-decision', {
-  onOpen: ({ blockId }) => void forkDecision.load(blockId),
+  onOpen: ({ instanceId }) => {
+    if (instanceId) void forkDecision.load(instanceId)
+  },
 })
 
 const block = computed(() => (blockId.value ? board.getBlock(blockId.value) : undefined))

package/app/components/panels/AgentStepDetail.vue

@@ -21,7 +21,11 @@ import StepExecutionHistory from '~/components/board/StepExecutionHistory.vue'
 import { useStepTimer } from '~/composables/useStepTimer'
 import { useStepProse } from '~/composables/useStepProse'
 import { useStepApproval } from '~/composables/useStepApproval'
-import { dedicatedParkView } from '~/utils/pipelineRender'
+import {
+  REDIRECT_PARK_PRESENTATION,
+  type RedirectParkView,
+  dedicatedParkView,
+} from '~/utils/pipelineRender'
 import InputGateNotice from '~/components/inputGate/InputGateNotice.vue'
 
 // Detail overlay for a single pipeline step. Opened by clicking an agent in the
@@ -191,14 +195,37 @@ const genericApprovalPending = computed(
   () => approvalPending.value && !companionExceeded.value && !dedicatedPark.value,
 )
 
-/** Jump from this overlay to the window that can actually resolve the dedicated park. */
+/**
+ * How the park that holds this step presents itself (prose, icon, action label), or null when no
+ * window owns it. Read from the shared table rather than branched on here, so this overlay cannot
+ * go on naming the fork decision for a park that is not one.
+ */
+const parkPresentation = computed(() =>
+  dedicatedPark.value && dedicatedPark.value !== 'input-gate'
+    ? REDIRECT_PARK_PRESENTATION[dedicatedPark.value]
+    : null,
+)
+
+/**
+ * Jump from this overlay to the window that can actually resolve the dedicated park.
+ *
+ * A `Record` over the vocabulary rather than an `if` chain, for the reason the presentation table
+ * gives: an unhandled member falls out of a chain as a button that closes this overlay and opens
+ * NOTHING, which is indistinguishable from a misclick. Here a new park fails to compile until it
+ * names its opener.
+ */
+const PARK_OPENERS: Record<RedirectParkView, (instanceId: string, stepIndex: number) => void> = {
+  'follow-ups': (id, idx) => ui.openFollowUps(id, idx),
+  'fork-decision': (id, idx) => ui.openForkDecision(id, idx),
+  'binary-candidates': (id, idx) => ui.openBinaryCandidates(id, idx),
+}
+
 function openDedicatedWindow() {
   const c = ctx.value
   const park = dedicatedPark.value
-  if (!c || !park) return
+  if (!c || !park || park === 'input-gate') return
   close()
-  if (park === 'follow-ups') ui.openFollowUps(c.instanceId, c.stepIndex)
-  else if (park === 'fork-decision') ui.openForkDecision(c.instanceId, c.stepIndex)
+  PARK_OPENERS[park](c.instanceId, c.stepIndex)
 }
 
 // The GitHub-style approval/review state machine for a pending gate step. A park a
@@ -476,9 +503,11 @@ async function copyOutput() {
                 @resolve="resolveCompanionCap"
               />
 
-              <!-- a park a dedicated window owns (fork choice / follow-up triage): the
-                   generic approval rail can't resolve it (the server refuses), so point
-                   the human at the window that can -->
+              <!-- a park a dedicated window owns (fork choice / follow-up triage / candidate
+                   comparison): the generic approval rail can't resolve it (the server refuses),
+                   so point the human at the window that can. Copy and icon come from the shared
+                   per-park table, so a park added to the vocabulary can never inherit another
+                   one's wording here. -->
               <!-- the pre-dispatch input gate holds this step: answered here, in place -->
               <InputGateNotice
                 v-if="inputGateVerdict && instance"
@@ -489,30 +518,23 @@ async function copyOutput() {
               />
 
               <div
-                v-if="dedicatedPark && dedicatedPark !== 'input-gate'"
+                v-if="parkPresentation"
                 class="rounded-xl border border-amber-500/30 bg-amber-500/5 p-4"
                 data-testid="dedicated-park-redirect"
+                :data-park="dedicatedPark"
               >
                 <p class="text-[13px] leading-relaxed text-amber-200/90">
-                  {{
-                    dedicatedPark === 'follow-ups'
-                      ? t('panels.stepDetail.followUpsParked')
-                      : t('panels.stepDetail.forkParked')
-                  }}
+                  {{ t(parkPresentation.noticeKey) }}
                 </p>
                 <UButton
                   class="mt-3"
                   color="primary"
                   size="sm"
-                  :icon="dedicatedPark === 'follow-ups' ? 'i-lucide-compass' : 'i-lucide-git-fork'"
+                  :icon="parkPresentation.icon"
                   data-testid="dedicated-park-open"
                   @click="openDedicatedWindow"
                 >
-                  {{
-                    dedicatedPark === 'follow-ups'
-                      ? t('panels.stepDetail.openFollowUps')
-                      : t('panels.stepDetail.chooseApproach')
-                  }}
+                  {{ t(parkPresentation.actionKey) }}
                 </UButton>
               </div>
 

package/app/components/panels/ResultWindowShell.logic.spec.ts

@@ -27,6 +27,10 @@ const SHELL_DEFAULT_WIDTH: ResultWindowWidth = '3xl'
  * not made the decision.
  */
 const WINDOWS: Record<string, { width: ResultWindowWidth; why: string }> = {
+  'binaryCandidates/BinaryCandidatesWindow.vue': {
+    width: '5xl',
+    why: 'a preview grid of generated candidates grouped by subject, read side by side to be compared, with no rail beside it',
+  },
   'brainstorm/BrainstormWindow.vue': {
     width: 'full',
     why: 'options column + the choose/dismiss action rail',

package/app/components/panels/inspector/TaskExecution.vue

@@ -8,6 +8,8 @@ import {
   isCompanionKind,
   containerPhaseLabel,
   dedicatedParkView,
+  REDIRECT_PARK_PRESENTATION,
+  type RedirectParkView,
 } from '~/utils/pipelineRender'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentFailureHistory from '~/components/board/AgentFailureHistory.vue'
@@ -184,15 +186,28 @@ function openStep(i: number) {
   if (instance.value) ui.openStepDetail(instance.value.id, i)
 }
 
-// Open the implementation-fork decision window for a coder step parked awaiting a choice.
-function openForkFor(i: number) {
-  if (instance.value) ui.openForkDecision(instance.value.id, i)
+/**
+ * The window-owned park holding a step, or null. `input-gate` is filtered out because it has no
+ * window: it is answered by the inline notice this list renders above itself, so offering a
+ * button here would send a human to an overlay that does not exist.
+ */
+function redirectPark(step: PipelineStep): RedirectParkView | null {
+  const park = dedicatedParkView(step, instance.value)
+  return park && park !== 'input-gate' ? park : null
+}
+
+/**
+ * Open the window that resolves a park. A `Record` over the vocabulary, so a park added to it
+ * fails to compile until it names its opener rather than rendering a button that does nothing.
+ */
+const PARK_OPENERS: Record<RedirectParkView, (instanceId: string, stepIndex: number) => void> = {
+  'follow-ups': (id, idx) => ui.openFollowUps(id, idx),
+  'fork-decision': (id, idx) => ui.openForkDecision(id, idx),
+  'binary-candidates': (id, idx) => ui.openBinaryCandidates(id, idx),
 }
 
-// Open the follow-up triage window for a coder step parked on undecided follow-up items
-// (its dedicated chip — the generic approve resolver refuses this park server-side).
-function openFollowUpsFor(i: number) {
-  if (instance.value) ui.openFollowUps(instance.value.id, i)
+function openParkFor(park: RedirectParkView, i: number) {
+  if (instance.value) PARK_OPENERS[park](instance.value.id, i)
 }
 
 // Open the PR deep-review findings-selection window for a pr-reviewer step parked awaiting
@@ -471,38 +486,23 @@ async function mergePr() {
             >
               {{ t('inspector.execution.decide') }}
             </UButton>
-            <!-- A coder step parked on the implementation-fork decision: pick an approach
-                 (or enter a custom one) in the dedicated window, not a plain approval. -->
-            <UButton
-              v-else-if="
-                s.approval &&
-                s.approval.status === 'pending' &&
-                dedicatedParkView(s, instance) === 'fork-decision'
-              "
-              color="primary"
-              variant="soft"
-              size="xs"
-              icon="i-lucide-git-fork"
-              @click="openForkFor(i)"
-            >
-              {{ t('inspector.execution.chooseApproach') }}
-            </UButton>
-            <!-- A coder step parked on undecided follow-up items: triage them (file /
-                 send back / answer / dismiss) in the dedicated window, not a plain
-                 approval — the generic approve resolver refuses this park. -->
+            <!-- A step parked on something a dedicated WINDOW answers: the implementation-fork
+                 choice, undecided follow-up items, or a candidate comparison. None of them is a
+                 plain approval (the generic resolver refuses all three server-side), and all
+                 three present the same way here: one button into the window that can resolve
+                 it. Driven by the shared per-park table rather than a branch each, because a
+                 branch each is how the candidate park shipped with no button at all. -->
             <UButton
-              v-else-if="
-                s.approval &&
-                s.approval.status === 'pending' &&
-                dedicatedParkView(s, instance) === 'follow-ups'
-              "
+              v-else-if="s.approval && s.approval.status === 'pending' && redirectPark(s)"
               color="primary"
               variant="soft"
               size="xs"
-              icon="i-lucide-compass"
-              @click="openFollowUpsFor(i)"
+              :icon="REDIRECT_PARK_PRESENTATION[redirectPark(s)!].icon"
+              :data-park="redirectPark(s)"
+              data-testid="dedicated-park-open"
+              @click="openParkFor(redirectPark(s)!, i)"
             >
-              {{ t('inspector.execution.triageFollowUps') }}
+              {{ t(REDIRECT_PARK_PRESENTATION[redirectPark(s)!].railActionKey) }}
             </UButton>
             <!-- A pr-reviewer step parked awaiting a finding selection: open the dedicated
                  findings-selection window, not the generic approval gate. -->

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

@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { parseMediaTypeRequirement, sameFormats } from './BinaryOutputStepPicker.logic'
+import {
+  formatReferenceImages,
+  generationControlOffer,
+  parseMediaTypeRequirement,
+  parseReferenceImages,
+  sameFormats,
+} from './BinaryOutputStepPicker.logic'
 
 describe('parseMediaTypeRequirement', () => {
   it('stores the reduction the backend compares against, not what was typed', () => {
@@ -56,3 +62,86 @@ describe('sameFormats', () => {
     expect(sameFormats(['a/b', 'c/d'], ['a/b', 'c/d'])).toBe(true)
   })
 })
+
+describe('parseReferenceImages', () => {
+  it('reads the role, the location and the optional service off each line', () => {
+    const { usable, unusable } = parseReferenceImages(
+      ['subject|assets/hero.png|asset-store', 'style|https://cdn.example/palette.png'].join('\n'),
+    )
+    expect(usable).toEqual([
+      { role: 'subject', location: 'assets/hero.png', service: 'asset-store' },
+      { role: 'style', location: 'https://cdn.example/palette.png' },
+    ])
+    expect(unusable).toEqual([])
+  })
+
+  // A reference someone typed and the step does not carry is a generation that silently ignores
+  // it, which is the "absent reads as fine" failure the rest of this surface exists to avoid.
+  it('reports a refused line rather than dropping it', () => {
+    const { usable, unusable } = parseReferenceImages(
+      ['mood|assets/hero.png', 'subject|', 'subject|assets/ok.png'].join('\n'),
+    )
+    expect(usable.map((ref) => ref.location)).toEqual(['assets/ok.png'])
+    expect(unusable).toEqual(['mood|assets/hero.png', 'subject|'])
+  })
+
+  it('round-trips through the text the field shows', () => {
+    const text = 'base|assets/hero.png|asset-store'
+    expect(formatReferenceImages(parseReferenceImages(text).usable)).toBe(text)
+  })
+})
+
+describe('generationControlOffer', () => {
+  const declaring = (...capabilities: string[]) => ({ capabilities }) as never
+
+  it('offers everything while a selected integration has declared nothing', () => {
+    // An integration that pinned nothing down is not a denial: hiding a control would be a claim
+    // about a vendor's API that nobody established. The advisory line says it is unconfirmed.
+    const offers = generationControlOffer([declaring('seed'), declaring()], undefined)
+    expect(offers('seed')).toBe(true)
+    expect(offers('tileable')).toBe(true)
+  })
+
+  it('offers everything when nothing is selected yet', () => {
+    expect(generationControlOffer([], undefined)('upscale')).toBe(true)
+  })
+
+  it('hides a control once every selection has declared and none has the capability', () => {
+    const offers = generationControlOffer([declaring('seed'), declaring('aspect-ratio')], undefined)
+    expect(offers('seed')).toBe(true)
+    expect(offers('aspect-ratio')).toBe(true)
+    expect(offers('tileable')).toBe(false)
+  })
+
+  // The regression this pins. Changing the selection does not clear options authored against the
+  // old one, so a stored option whose capability nothing declares still REFUSES the run at
+  // admission. Hiding its control leaves the reader an error saying to remove an option and no
+  // control that removes it: a step that cannot be run and cannot be fixed from the surface that
+  // configures it.
+  it('keeps offering a control whose option is already SET, whatever the selection declares', () => {
+    const selection = [declaring('seed')]
+    expect(generationControlOffer(selection, {})('tileable')).toBe(false)
+    expect(generationControlOffer(selection, { tileable: true })('tileable')).toBe(true)
+  })
+
+  it('keeps the control for every option shape that carries a requirement', () => {
+    const selection = [declaring('seed')]
+    // Each of these is stored differently (a flag, a number that may be zero, a list, a mode), and
+    // the requirement is derived from the same helper admission uses rather than re-read here.
+    const offers = generationControlOffer(selection, {
+      seed: 0,
+      aspectRatio: '16:9',
+      negativePrompt: 'blurry',
+      edit: { mode: 'mask' },
+      referenceImages: [{ role: 'subject', location: 'assets/hero.png' }],
+    } as never)
+    for (const capability of [
+      'aspect-ratio',
+      'negative-prompt',
+      'mask-edit',
+      'reference-image',
+    ] as const) {
+      expect(offers(capability)).toBe(true)
+    }
+  })
+})