@softize/opus 12.5.3 → 12.5.5

package/CHANGELOG.md

@@ -7,6 +7,25 @@ Depois de qualquer bump, rode os gates (`typecheck` · `test` · `opus check` ·
 `opus copy --check` · `base copy check` · `manifest:check`) — eles apontam o que a
 mudança cobra do seu código.
 
+## 12.5.5 — 2026-08-25
+
+Só documentação: leva ao pacote a correção de nota que a 12.5.4 recebeu no repositório depois de
+publicada. A nota descrevia os três testes novos da `Dock` como discriminantes; só o do foco que
+sai da barra distingue o código corrigido do anterior — os outros dois guardam propriedades da
+barra, não regressões. Nenhuma mudança de comportamento.
+
+## 12.5.4 — 2026-08-25
+
+A `Dock` lembra por onde o Tab entra depois que o foco sai dela: quem andou até a quinta ação e
+voltou para a tela reentra na quinta, não no começo da barra. É essa a correção, e é ela que o
+teste novo cobra — o teste da 12.5.3 remontava a barra em vez de re-renderizá-la, então passava
+igual contra o código bugado.
+
+Duas correções de nota, para quem for ler o histórico: a da 12.5.3 dizia que todo re-render
+devolvia a entrada ao primeiro ícone, o que não acontecia (o efeito já rodava a cada render); e
+dos três casos que a 12.5.4 acrescentou, só o do foco que sai da barra distingue o código corrigido
+do anterior — os outros dois guardam propriedades da barra, não regressões.
+
 ## 12.5.3 — 2026-08-24
 
 O roving tabindex da `Dock` sobrevive ao re-render do consumidor. Antes o efeito devolvia o ponto

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softize/opus",
-  "version": "12.5.3",
+  "version": "12.5.5",
   "description": "End-to-end action protocol for TypeScript. Single package with subpath exports (core + adapters).",
   "license": "MIT",
   "type": "module",

package/src/ui/components/patterns/dock.tsx

@@ -35,20 +35,29 @@ export interface DockProps {
 /** Barra flutuante ancorada à superfície. O contêiner precisa ser `relative`. */
 export function Dock({ position = 'bottom', label, className, children }: DockProps): React.ReactElement {
   const ref = React.useRef<HTMLDivElement>(null)
+  // Onde o Tab entra na barra. Fica num ref porque precisa sobreviver ao foco SAIR dela: quem
+  // andou até o quinto ícone e voltou pra tela espera reentrar no quinto, não no primeiro.
+  const entrada = React.useRef<HTMLButtonElement | null>(null)
 
   // Roving tabindex: uma toolbar tem UM ponto de entrada no Tab; dentro dela, as setas andam.
   // Sem isto as setas seriam um caminho a mais, e a barra continuaria cobrando um Tab por ícone.
-  const roving = React.useCallback((focado?: HTMLElement) => {
+  const roving = React.useCallback((focado?: HTMLElement | null) => {
     const items = Array.from(ref.current?.querySelectorAll<HTMLButtonElement>('button') ?? [])
-    const entrada = items.find((item) => item === focado) ?? items.find((item) => !item.disabled)
-    for (const item of items) item.tabIndex = item === entrada ? 0 : -1
+    // Foco fora da barra não move a entrada — só confirma a que já estava valendo.
+    if (focado instanceof HTMLButtonElement && items.includes(focado)) entrada.current = focado
+    const lembrada = entrada.current
+    const alvo =
+      (lembrada !== null && items.includes(lembrada) && !lembrada.disabled ? lembrada : undefined) ??
+      items.find((item) => !item.disabled)
+    entrada.current = alvo ?? null
+    for (const item of items) item.tabIndex = item === alvo ? 0 : -1
   }, [])
 
   React.useEffect(() => {
-    // Passa o foco corrente: sem isto, todo re-render do consumidor devolvia o ponto de entrada
-    // ao primeiro ícone e tirava do Tab quem estava focado.
-    const ativo = document.activeElement
-    roving(ativo instanceof HTMLElement ? ativo : undefined)
+    // Roda a cada render porque as ações da barra mudam com o estado da tela: sem recalcular, um
+    // ícone recém-montado entraria no Tab por conta própria, e sumir com o ícone que era a
+    // entrada deixaria a barra inteira fora do Tab.
+    roving(document.activeElement as HTMLElement | null)
   })
 
   // Navegação de toolbar: as setas andam entre as ações, e Home/End vão às pontas. Sem isso