@cat-factory/app 0.145.2 → 0.146.0

package/app/components/environments/EnvSetupStepper.vue

@@ -0,0 +1,70 @@
+<script setup lang="ts">
+// The environment-setup wizard's stepper header, driven entirely by
+// `useJourneyProgress` (modular-react#83, production-feedback item 4). The ordered
+// steps, the live position, and the "Step X of N" total all come from
+// `resolveStepSequence` walking the journey's transition graph — there is no
+// hand-maintained step-order array to keep in sync (the old `ENV_STEP_ORDER` +
+// `crumbState` is gone). Rendered inside `<JourneyHost>`, which hands it the live
+// `instanceId`; each step's label is the i18n key carried in the journey's `steps`
+// metadata.
+import type { InstanceId } from '@modular-vue/journeys'
+import { useJourneyProgress } from '@modular-vue/journeys'
+import { environmentSetupJourney } from '~/modular/journeys/environmentSetup'
+import type { EnvSetupInput } from '~/modular/journeys/environmentSetup.logic'
+
+const props = defineProps<{
+  /** The live journey instance from `<JourneyHost>`, or null before it starts. */
+  instanceId: InstanceId | null
+  /** The launch input; frozen for the host's lifetime, so the resolved spine is
+   *  stable (`useJourneyProgress` reads `sequence.input` once at setup). */
+  input: EnvSetupInput
+}>()
+
+const { t, te } = useI18n()
+
+const { index, total, steps } = useJourneyProgress(
+  () => props.instanceId,
+  environmentSetupJourney,
+  { sequence: { input: props.input } },
+)
+
+/** Resolve a step's progress-label key (from the journey's `steps` metadata)
+ *  through i18n, tolerating a locale that omits it rather than leaking the key. */
+function stepLabel(key: string | undefined): string {
+  return key && te(key) ? t(key) : ''
+}
+</script>
+
+<template>
+  <div class="space-y-2" data-testid="env-setup-stepper">
+    <p v-if="total" class="text-[11px] font-medium text-slate-400" data-testid="env-setup-progress">
+      {{ t('environmentWizard.progress', { index: index + 1, total }) }}
+    </p>
+    <ol class="flex items-center gap-2 text-[11px]">
+      <li
+        v-for="(step, i) in steps"
+        :key="step.entry"
+        class="flex items-center gap-2"
+        :data-testid="`env-setup-crumb-${step.entry}`"
+      >
+        <span
+          class="flex h-5 w-5 items-center justify-center rounded-full text-[10px] font-semibold"
+          :class="{
+            'bg-primary-500 text-white': i === index,
+            'bg-emerald-600/70 text-white': i < index,
+            'bg-slate-700 text-slate-300': i > index,
+          }"
+          >{{ i + 1 }}</span
+        >
+        <span :class="i === index ? 'text-slate-100' : 'text-slate-500'">
+          {{ stepLabel(step.progressLabel) }}
+        </span>
+        <UIcon
+          v-if="i < steps.length - 1"
+          name="i-lucide-chevron-right"
+          class="h-3 w-3 text-slate-600"
+        />
+      </li>
+    </ol>
+  </div>
+</template>

package/app/components/environments/EnvironmentSetupWizard.vue

@@ -8,14 +8,15 @@
 // journey (`~/modular/journeys/environmentSetup`), hosted here by `<JourneyHost>`:
 // it starts the journey on open (RESUMING the in-flight instance for the same
 // frame when one was left mid-flow, via the Pinia persistence adapter), renders
-// the current step through `<JourneyOutlet>`, and abandons it on close. Each step
-// component drives the `environmentWizard` store for its data/actions and fires
-// the journey's exits to advance. On `complete` (the save step's Done) the journey
-// clears its persisted blob and we close the modal.
+// the current step through `<JourneyOutlet>`, and abandons it on close. The
+// stepper header + "Step X of N" are derived from the journey's transition graph
+// by `<EnvSetupStepper>` (via `useJourneyProgress`), not a hand-maintained step
+// list. Each step component drives the `environmentWizard` store for its
+// data/actions and fires the journey's exits to advance. On `complete` (the save
+// step's Done) the journey clears its persisted blob and we close the modal.
 import { computed } from 'vue'
 import { JourneyHost, JourneyOutlet } from '@modular-vue/journeys'
 import { environmentSetupHandle } from '~/modular/journeys/environmentSetup'
-import { ENV_STEP_ORDER, type EnvStep } from '~/modular/journeys/environmentSetup.logic'
 
 const ui = useUiStore()
 const { t } = useI18n()
@@ -30,23 +31,6 @@ const open = computed({
 // Read once at journey start; keyed for resume. Frozen for the host's lifetime,
 // so the modal remounts the host per open (it renders under `v-if` upstream).
 const input = computed(() => ({ frameId: ui.environmentWizardFrameId }))
-
-const STEP_LABEL = computed<Record<EnvStep, string>>(() => ({
-  pick: t('environmentWizard.steps.pick'),
-  review: t('environmentWizard.steps.review'),
-  preflight: t('environmentWizard.steps.preflight'),
-  save: t('environmentWizard.steps.save'),
-}))
-
-/** The crumb index of a step, relative to the current journey step. */
-function crumbState(
-  entry: EnvStep,
-  currentEntry: EnvStep | undefined,
-): 'current' | 'done' | 'todo' {
-  if (!currentEntry) return 'todo'
-  if (entry === currentEntry) return 'current'
-  return ENV_STEP_ORDER.indexOf(entry) < ENV_STEP_ORDER.indexOf(currentEntry) ? 'done' : 'todo'
-}
 </script>
 
 <template>
@@ -63,43 +47,9 @@ function crumbState(
           :input="input"
           @finished="ui.closeEnvironmentSetup()"
         >
-          <template #default="{ instanceId, instance }">
-            <!-- stepper header, driven by the journey's current step -->
-            <ol class="flex items-center gap-2 text-[11px]">
-              <li
-                v-for="(s, i) in ENV_STEP_ORDER"
-                :key="s"
-                class="flex items-center gap-2"
-                :data-testid="`env-setup-crumb-${s}`"
-              >
-                <span
-                  class="flex h-5 w-5 items-center justify-center rounded-full text-[10px] font-semibold"
-                  :class="{
-                    'bg-primary-500 text-white':
-                      crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'current',
-                    'bg-emerald-600/70 text-white':
-                      crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'done',
-                    'bg-slate-700 text-slate-300':
-                      crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'todo',
-                  }"
-                  >{{ i + 1 }}</span
-                >
-                <span
-                  :class="
-                    crumbState(s, (instance?.step?.entry as EnvStep) ?? undefined) === 'current'
-                      ? 'text-slate-100'
-                      : 'text-slate-500'
-                  "
-                >
-                  {{ STEP_LABEL[s] }}
-                </span>
-                <UIcon
-                  v-if="i < ENV_STEP_ORDER.length - 1"
-                  name="i-lucide-chevron-right"
-                  class="h-3 w-3 text-slate-600"
-                />
-              </li>
-            </ol>
+          <template #default="{ instanceId }">
+            <!-- stepper header, derived from the journey graph -->
+            <EnvSetupStepper :instance-id="instanceId" :input="input" />
 
             <!-- the current step (pick / review / preflight / save) -->
             <div class="mt-4">

package/app/modular/journeys/environmentSetup.logic.spec.ts

@@ -1,20 +1,28 @@
 import { describe, expect, it } from 'vitest'
+import { resolveStepSequence } from '@modular-vue/journeys'
 import {
-  ENV_STEP_ORDER,
+  ENV_MODULE_ID,
+  environmentSetupJourney,
   envInitialState,
-  envNextAfter,
   envStartStep,
 } from './environmentSetup.logic'
+import en from '../../../i18n/locales/en.json'
 
-// Pure navigation graph for the environment-setup journey (slice 3). `envNextAfter`
-// is the source of truth the journey's `advance` transitions derive their target
-// entries from (see `environmentSetup.ts`), so pinning the order, start branch, and
-// forward edges here means a wiring regression can't silently reorder or drop a step.
-describe('environment-setup journey logic', () => {
-  it('orders the steps pick → review → preflight → save', () => {
-    expect(ENV_STEP_ORDER).toEqual(['pick', 'review', 'preflight', 'save'])
-  })
+/** Dot-path lookup into the real `en.json`, mirroring which keys actually ship. */
+function hasKey(path: string): boolean {
+  return (
+    path.split('.').reduce<unknown>((node, seg) => {
+      return node && typeof node === 'object' ? (node as Record<string, unknown>)[seg] : undefined
+    }, en) !== undefined
+  )
+}
 
+// Pure navigation graph for the environment-setup journey (slice 3). The step
+// order is derived from the annotated transition graph (production-feedback item
+// 4), so `resolveStepSequenceResult` walking the real journey definition is the
+// guard against a silent reorder or dropped step — no hand-maintained order array
+// to pin separately.
+describe('environment-setup journey logic', () => {
   it('seeds state from the launch input', () => {
     expect(envInitialState({ frameId: 'blk_1' })).toEqual({ frameId: 'blk_1' })
     expect(envInitialState({ frameId: null })).toEqual({ frameId: null })
@@ -25,10 +33,33 @@ describe('environment-setup journey logic', () => {
     expect(envStartStep({ frameId: null }, { frameId: null })).toBe('pick')
   })
 
-  it('advances linearly and terminates after save', () => {
-    expect(envNextAfter('pick')).toBe('review')
-    expect(envNextAfter('review')).toBe('preflight')
-    expect(envNextAfter('preflight')).toBe('save')
-    expect(envNextAfter('save')).toBe('done')
+  it('derives the pick → review → preflight → save order from the transition graph', () => {
+    const steps = resolveStepSequence(environmentSetupJourney, { input: { frameId: null } })
+    expect(steps.map((s) => s.entry)).toEqual(['pick', 'review', 'preflight', 'save'])
+    expect(steps.every((s) => s.module === ENV_MODULE_ID)).toBe(true)
+    expect(steps.map((s) => s.progressLabel)).toEqual([
+      'environmentWizard.steps.pick',
+      'environmentWizard.steps.review',
+      'environmentWizard.steps.preflight',
+      'environmentWizard.steps.save',
+    ])
+  })
+
+  it('starts the derived sequence at review when a frame is preselected', () => {
+    const steps = resolveStepSequence(environmentSetupJourney, { input: { frameId: 'blk_1' } })
+    expect(steps.map((s) => s.entry)).toEqual(['review', 'preflight', 'save'])
+  })
+
+  // The stepper resolves each label through a VARIABLE key (`t(step.progressLabel)`), so
+  // the tier-1 typed-message-keys check + `vue-i18n-extract` can no longer see these keys
+  // as used and can't catch a typo or a dropped key. Pin the missing-key guard here instead:
+  // every `progressLabel` the real definition emits must resolve to a shipping `en.json` key.
+  it('carries a shipping en.json label key for every derived step', () => {
+    const steps = resolveStepSequence(environmentSetupJourney, { input: { frameId: null } })
+    for (const step of steps) {
+      const key = step.progressLabel
+      expect(key, `missing i18n key for step "${step.entry}"`).toBeTruthy()
+      expect(hasKey(key ?? ''), `key "${key}" not in en.json`).toBe(true)
+    }
   })
 })

package/app/modular/journeys/environmentSetup.logic.ts

@@ -10,15 +10,26 @@
  * trial) stay in that Pinia store, which the step components still drive; the
  * journey just decides WHICH step shows and threads the target frame id.
  *
- * This file is deliberately free of Vue/`.vue`/`defineModule` imports so the
- * transition graph is unit-tested directly (`environmentSetup.spec.ts`); the
- * component wiring lives in `environmentSetup.ts`, which feeds these helpers into
- * `defineJourney`'s `transitions` map.
+ * The step ORDER is no longer spelled out a second time as an ordered array: it
+ * is DERIVED from the annotated transition graph below (production-feedback item
+ * 4 in modular-react#83). Each transition wraps its handler with
+ * `defineTransition({ targets, handle })` so the static `targets` declare where
+ * the flow can go; `resolveStepSequence` / `useJourneyProgress` walk that graph
+ * to produce the ordered step list and the wizard's "Step X of N" progress from
+ * the one place the flow is encoded. `steps` carries each step's progress-label
+ * key beside the transitions.
+ *
+ * This definition lives in the logic file (not the SFC-importing
+ * `environmentSetup.ts`) so the graph stays free of `.vue` imports and is
+ * unit-tested directly (`environmentSetup.logic.spec.ts`). It references the step
+ * module only as a TYPE (`import type`), which is erased at runtime, so importing
+ * this file pulls no components. `environmentSetup.ts` supplies the module (with
+ * its step components) and re-exports the journey + the launch handle + the
+ * persistence adapter.
  */
-
-/** The journey's ordered step entries (also the module's `entryPoints` keys). */
-export const ENV_STEP_ORDER = ['pick', 'review', 'preflight', 'save'] as const
-export type EnvStep = (typeof ENV_STEP_ORDER)[number]
+import type { ExitCtx } from '@modular-vue/journeys'
+import { defineJourney, defineTransition } from '@modular-vue/journeys'
+import type { environmentSetupModule } from '~/modular/journeys/environmentSetup'
 
 /** The single module id every step entry lives under. */
 export const ENV_MODULE_ID = 'cat-factory:environment-setup' as const
@@ -52,35 +63,91 @@ export function envInitialState(input: EnvSetupInput): EnvSetupState {
 }
 
 /** First step: skip the picker when the launcher already chose a frame. */
-export function envStartStep(_state: EnvSetupState, input: EnvSetupInput): EnvStep {
+export function envStartStep(_state: EnvSetupState, input: EnvSetupInput): 'pick' | 'review' {
   return input.frameId ? 'review' : 'pick'
 }
 
 /**
- * The step reached by advancing from `from` via its forward exit, or `'done'`
- * when the flow completes. The pick step advances via `select` (a distinct
- * exit); the rest via `advance`. Pure and total over `EnvStep`.
- *
- * This is the SINGLE SOURCE OF TRUTH for the linear forward chain: the journey
- * definition (`environmentSetup.ts`) derives its `advance` transitions' target
- * entries from it, so pinning this function in `environmentSetup.logic.spec.ts`
- * genuinely guards the wired graph against a silent reorder/drop. The overloads
- * narrow the return to a concrete entry (or `'done'`) so a transition handler can
- * feed the result straight into a `StepSpec` without a widened `EnvStep | 'done'`.
+ * The journey's module type map — one module, referenced by its `typeof` so the
+ * transition + step maps resolve its literal entry/exit vocabulary with no casts.
+ * This is the case production-feedback item 3 (modular-react#83) fixed: before it,
+ * `defineModule` widened the descriptor, so `typeof environmentSetupModule` could
+ * not stand in as a `TModules` member without re-declaring the entry names by hand.
  */
-export function envNextAfter(from: 'pick'): 'review'
-export function envNextAfter(from: 'review'): 'preflight'
-export function envNextAfter(from: 'preflight'): 'save'
-export function envNextAfter(from: 'save'): 'done'
-export function envNextAfter(from: EnvStep): EnvStep | 'done' {
-  switch (from) {
-    case 'pick':
-      return 'review'
-    case 'review':
-      return 'preflight'
-    case 'preflight':
-      return 'save'
-    case 'save':
-      return 'done'
-  }
-}
+export type EnvModules = { [ENV_MODULE_ID]: typeof environmentSetupModule }
+
+/** Binder threading the journey generics into each annotated transition handler. */
+const transition = defineTransition<EnvModules, EnvSetupState>()
+
+/**
+ * The journey definition. `start` skips the picker when a frame was preselected.
+ * The forward chain is the annotated transitions' `targets`: pick →(select)→
+ * review →(advance)→ preflight →(advance)→ save →(advance)→ complete. Back
+ * navigation is handled by the entries' `allowBack` (declared on the module in
+ * `environmentSetup.ts`), not explicit transitions.
+ */
+export const environmentSetupJourney = defineJourney<EnvModules, EnvSetupState>()({
+  id: 'environment-setup',
+  version: '1.0.0',
+  initialState: (input: EnvSetupInput) => envInitialState(input),
+  start: (state, input: EnvSetupInput) =>
+    envStartStep(state, input) === 'review'
+      ? { module: ENV_MODULE_ID, entry: 'review', input: { frameId: state.frameId } }
+      : { module: ENV_MODULE_ID, entry: 'pick', input: { frameId: state.frameId } },
+  steps: {
+    [ENV_MODULE_ID]: {
+      pick: { progressLabel: 'environmentWizard.steps.pick' },
+      review: { progressLabel: 'environmentWizard.steps.review' },
+      preflight: { progressLabel: 'environmentWizard.steps.preflight' },
+      save: { progressLabel: 'environmentWizard.steps.save' },
+    },
+  },
+  transitions: {
+    [ENV_MODULE_ID]: {
+      pick: {
+        [ENV_SELECT_EXIT]: transition({
+          targets: [{ module: ENV_MODULE_ID, entry: 'review' }],
+          handle: (ctx: ExitCtx<EnvSetupState, EnvSelectOutput, unknown>) => ({
+            next: {
+              module: ENV_MODULE_ID,
+              entry: 'review',
+              input: { frameId: ctx.output.frameId },
+            },
+            state: { frameId: ctx.output.frameId },
+          }),
+        }),
+      },
+      review: {
+        [ENV_ADVANCE_EXIT]: transition({
+          targets: [{ module: ENV_MODULE_ID, entry: 'preflight' }],
+          handle: (ctx) => ({
+            next: {
+              module: ENV_MODULE_ID,
+              entry: 'preflight',
+              input: { frameId: ctx.state.frameId },
+            },
+          }),
+        }),
+      },
+      preflight: {
+        [ENV_ADVANCE_EXIT]: transition({
+          targets: [{ module: ENV_MODULE_ID, entry: 'save' }],
+          handle: (ctx) => ({
+            next: {
+              module: ENV_MODULE_ID,
+              entry: 'save',
+              input: { frameId: ctx.state.frameId },
+            },
+          }),
+        }),
+      },
+      // `save` advances to journey completion.
+      save: {
+        [ENV_ADVANCE_EXIT]: transition({
+          targets: ['complete'],
+          handle: () => ({ complete: undefined }),
+        }),
+      },
+    },
+  },
+})

package/app/modular/journeys/environmentSetup.ts

@@ -1,6 +1,6 @@
 import { defineModule } from '@modular-vue/core'
 import { defineExit } from '@modular-frontend/core'
-import { defineJourney, defineJourneyHandle } from '@modular-vue/journeys'
+import { defineJourneyHandle } from '@modular-vue/journeys'
 import EnvPickStep from '~/components/environments/steps/EnvPickStep.vue'
 import EnvReviewStep from '~/components/environments/steps/EnvReviewStep.vue'
 import EnvPreflightStep from '~/components/environments/steps/EnvPreflightStep.vue'
@@ -13,9 +13,7 @@ import {
   type EnvSelectOutput,
   type EnvSetupInput,
   type EnvSetupState,
-  envInitialState,
-  envNextAfter,
-  envStartStep,
+  environmentSetupJourney,
 } from '~/modular/journeys/environmentSetup.logic'
 
 /**
@@ -25,6 +23,13 @@ import {
  * with a typed, back/rewind-capable, resumable journey; the per-step data + async
  * actions stay in that Pinia store, driven by the step components below.
  *
+ * This file supplies the step MODULE (it imports the step `.vue` components, so —
+ * like `result-views.ts` — it's registered from the client plugin, keeping the
+ * unit-tested `registry.ts` / `*.logic.ts` import graph free of SFCs) and re-exports
+ * the JOURNEY, whose transition graph + step metadata live in the SFC-free
+ * `environmentSetup.logic.ts` (so `resolveStepSequence` / `useJourneyProgress` and
+ * the ordering test have no `.vue` dependency).
+ *
  * Authoring notes (co-evolution): `defineModule` comes from the `@modular-vue/core`
  * binding, but the exit helper `defineExit` is only exported from the neutral
  * `@modular-frontend/core` engine (a direct dep) — the Vue binding doesn't re-export
@@ -36,10 +41,6 @@ import {
  * pick step and never changes mid-flow, so the snapshot input a transition places is
  * always current — even on `preserve-state` back-navigation — which keeps the module
  * type simple (no `buildInput`-optionality quirk) and the flow fully explicit.
- *
- * This file imports the step `.vue` components, so — like `result-views.ts` — it's
- * registered from the client plugin, keeping the unit-tested `registry.ts` /
- * `*.logic.ts` import graph free of SFCs.
  */
 
 /**
@@ -52,20 +53,20 @@ export const environmentSetupModule = defineModule({
   id: ENV_MODULE_ID,
   version: '1.0.0',
   entryPoints: {
-    pick: { mountKinds: ['journey'] as const, component: EnvPickStep },
+    pick: { mountKinds: ['journey'], component: EnvPickStep },
     review: {
-      mountKinds: ['journey'] as const,
-      allowBack: 'preserve-state' as const,
+      mountKinds: ['journey'],
+      allowBack: 'preserve-state',
       component: EnvReviewStep,
     },
     preflight: {
-      mountKinds: ['journey'] as const,
-      allowBack: 'preserve-state' as const,
+      mountKinds: ['journey'],
+      allowBack: 'preserve-state',
       component: EnvPreflightStep,
     },
     save: {
-      mountKinds: ['journey'] as const,
-      allowBack: 'preserve-state' as const,
+      mountKinds: ['journey'],
+      allowBack: 'preserve-state',
       component: EnvSaveStep,
     },
   },
@@ -75,59 +76,7 @@ export const environmentSetupModule = defineModule({
   },
 })
 
-type EnvModules = { [ENV_MODULE_ID]: typeof environmentSetupModule }
-
-/**
- * The journey definition. `start` skips the picker when a frame was preselected;
- * transitions are the linear pick → review → preflight → save chain, terminating
- * with `complete` off the save step's `advance`. Back-navigation is handled by the
- * entries' `allowBack`, not explicit transitions.
- */
-export const environmentSetupJourney = defineJourney<EnvModules, EnvSetupState>()({
-  id: 'environment-setup',
-  version: '1.0.0',
-  initialState: (input: EnvSetupInput) => envInitialState(input),
-  start: (state, input: EnvSetupInput) =>
-    envStartStep(state, input) === 'review'
-      ? ({ module: ENV_MODULE_ID, entry: 'review', input: { frameId: state.frameId } } as const)
-      : ({ module: ENV_MODULE_ID, entry: 'pick', input: { frameId: state.frameId } } as const),
-  transitions: {
-    [ENV_MODULE_ID]: {
-      pick: {
-        [ENV_SELECT_EXIT]: (ctx) => ({
-          next: {
-            module: ENV_MODULE_ID,
-            entry: 'review',
-            input: { frameId: ctx.output.frameId },
-          } as const,
-          state: { frameId: ctx.output.frameId },
-        }),
-      },
-      review: {
-        [ENV_ADVANCE_EXIT]: (ctx) => ({
-          next: {
-            module: ENV_MODULE_ID,
-            entry: envNextAfter('review'),
-            input: { frameId: ctx.state.frameId },
-          } as const,
-        }),
-      },
-      preflight: {
-        [ENV_ADVANCE_EXIT]: (ctx) => ({
-          next: {
-            module: ENV_MODULE_ID,
-            entry: envNextAfter('preflight'),
-            input: { frameId: ctx.state.frameId },
-          } as const,
-        }),
-      },
-      // `save` advances to `envNextAfter('save') === 'done'`, i.e. journey completion.
-      save: {
-        [ENV_ADVANCE_EXIT]: () => ({ complete: undefined }),
-      },
-    },
-  },
-})
+export { environmentSetupJourney }
 
 /** Typed launch handle — callers `runtime.start(handle, { frameId })`. */
 export const environmentSetupHandle = defineJourneyHandle(environmentSetupJourney)

package/i18n/locales/de.json

@@ -4808,6 +4808,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Schritt {index} von {total}",
     "title": "Eine Testumgebung einrichten",
     "subtitle": "Erkenne, prüfe und speichere ein Docker-Compose-Rezept, damit der Deployer es bereitstellt.",
     "recommended": "empfohlen",

package/i18n/locales/en.json

@@ -4941,6 +4941,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Step {index} of {total}",
     "title": "Set up a test environment",
     "subtitle": "Detect, review, and save a Docker Compose recipe so the Deployer provisions it.",
     "recommended": "recommended",

package/i18n/locales/es.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Paso {index} de {total}",
     "title": "Configurar un entorno de pruebas",
     "subtitle": "Detecta, revisa y guarda una receta de Docker Compose para que el Deployer la aprovisione.",
     "recommended": "recomendado",

package/i18n/locales/fr.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Étape {index} sur {total}",
     "title": "Configurer un environnement de test",
     "subtitle": "Détectez, vérifiez et enregistrez une recette Docker Compose pour que le Deployer la provisionne.",
     "recommended": "recommandé",

package/i18n/locales/he.json

@@ -4811,6 +4811,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "שלב {index} מתוך {total}",
     "title": "הגדרת סביבת בדיקות",
     "subtitle": "זהו, סקרו ושמרו מתכון Docker Compose כדי שה-Deployer יקצה אותו.",
     "recommended": "מומלץ",

package/i18n/locales/it.json

@@ -4808,6 +4808,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Passaggio {index} di {total}",
     "title": "Configura un ambiente di test",
     "subtitle": "Rileva, rivedi e salva una ricetta Docker Compose in modo che il Deployer la esegua.",
     "recommended": "consigliato",

package/i18n/locales/ja.json

@@ -4812,6 +4812,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "ステップ {index} / {total}",
     "title": "テスト環境をセットアップ",
     "subtitle": "Docker Compose レシピを検出・確認・保存して、Deployer がプロビジョニングできるようにします。",
     "recommended": "推奨",

package/i18n/locales/pl.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Krok {index} z {total}",
     "title": "Skonfiguruj środowisko testowe",
     "subtitle": "Wykryj, przejrzyj i zapisz przepis Docker Compose, aby Deployer go udostępnił.",
     "recommended": "zalecane",

package/i18n/locales/tr.json

@@ -4812,6 +4812,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Adım {index} / {total}",
     "title": "Bir test ortamı kur",
     "subtitle": "Deployer sağlasın diye bir Docker Compose tarifini algıla, gözden geçir ve kaydet.",
     "recommended": "önerilen",

package/i18n/locales/uk.json

@@ -4800,6 +4800,7 @@
     }
   },
   "environmentWizard": {
+    "progress": "Крок {index} з {total}",
     "title": "Налаштувати тестове середовище",
     "subtitle": "Виявіть, перегляньте та збережіть рецепт Docker Compose, щоб Deployer його забезпечив.",
     "recommended": "рекомендовано",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.145.2",
+  "version": "0.146.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",
@@ -18,9 +18,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@modular-frontend/core": "^0.5.0",
-    "@modular-vue/core": "^1.4.0",
-    "@modular-vue/journeys": "^1.3.0",
+    "@modular-frontend/core": "^0.6.0",
+    "@modular-vue/core": "^1.5.0",
+    "@modular-vue/journeys": "^1.4.0",
     "@modular-vue/nuxt": "^0.4.0",
     "@modular-vue/runtime": "^1.4.1",
     "@modular-vue/vue": "^1.4.0",