@softize/opus 25.0.0 → 25.2.0

package/src/core/runtime.ts

@@ -25,6 +25,17 @@ import { createPurgeHandler, entityTableName, type PurgeHandler } from './retent
 import type { DataProductConfig } from './data-product.ts'
 import { AuditEmitter } from './audit.ts'
 import { countReturnedRecords, hasInvalidEffect, resolveActionEffect } from './action-nature.ts'
+import {
+  assertAssistantDeclaration,
+  projectAssistantContext,
+  publicAssistant,
+  resolveAssistantTitle,
+  type AssistantOmission,
+  type ReadResourceOptions,
+  type ResourceContext,
+  type RegisteredAssistant,
+  type ResourceReadResult,
+} from './assistant.ts'
 import { error, isActionError, normalizeError } from './errors.ts'
 import { normalizeTraceContext } from './trace.ts'
 import { isSystemActor, markSystemActor } from './system-actor.ts'
@@ -78,6 +89,7 @@ import type {
   BoundAi,
   AiTool,
   AIConfig,
+  ActionAssistant,
   User,
   TraceContext,
 } from './types.ts'
@@ -321,6 +333,8 @@ export class Runtime {
   private aiToolsCache: AiTool[] | null = null
 
   private readonly actions = new Map<string, ActionDef>()
+  /** A action dona de cada tipo de recurso com assistente (ADR 0053). */
+  private readonly assistantOwners = new Map<string, ActionDef & { assistant: ActionAssistant }>()
   private readonly reactions = new Map<string, ReactionDef<any>>()
   private readonly schedules = new Map<string, ScheduleDef>()
   private readonly dataProducts = new Map<string, DataProductConfig>()
@@ -532,11 +546,33 @@ export class Runtime {
             'Use simple ou form para escrever (ADR 0041).',
         })
       }
+      this.claimAssistant(action)
       this.actions.set(action.name, action)
       if (this.config.dev) this.warnIgnoredExecutionFields(action)
     }
   }
 
+  /**
+   * Valida a declaração do assistente e reserva o tipo de recurso para a action (ADR 0053). Duas
+   * actions donas do mesmo recurso são recusadas com `runtime.assistant_duplicate_resource`.
+   */
+  private claimAssistant(action: ActionDef): void {
+    assertAssistantDeclaration(action)
+    const assistant = (action as { assistant?: ActionAssistant }).assistant
+    if (assistant === undefined) return
+    const owner = this.assistantOwners.get(assistant.resource)
+    if (owner !== undefined) {
+      throw error({
+        code: 'runtime.assistant_duplicate_resource',
+        category: 'internal',
+        message:
+          `O recurso "${assistant.resource}" já tem a action dona "${owner.name}"; ` +
+          `"${action.name}" não pode declarar o mesmo resource (ADR 0053).`,
+      })
+    }
+    this.assistantOwners.set(assistant.resource, action as ActionDef & { assistant: ActionAssistant })
+  }
+
   /**
    * `emits` e `background` pertencem ao binding de qualquer kind pelo tipo, mas o runtime e o
    * manifest só os aplicam em `simple` e `form`. Restringir o tipo quebraria bindings
@@ -726,6 +762,103 @@ export class Runtime {
     return this.executeAction(action, input, ctxBase, 'request')
   }
 
+  /**
+   * Lê um recurso pela action dona do tipo (ADR 0053). Executa a action com `{ id }` pelo mesmo
+   * `execute` de qualquer chamada: autorização, loaders, auditoria, marca de dado pessoal e span são
+   * os da action. Em caso de sucesso, devolve o descritor e, com `{ context: true }`, a projeção
+   * limitada que o host pode entregar ao modelo. Em caso de falha, devolve o erro da action. Um tipo
+   * sem action dona devolve `runtime.assistant_resource_unknown`, sem executar nada.
+   */
+  async readResource(
+    resource: string,
+    id: string,
+    ctxBase: ContextBase,
+    options: ReadResourceOptions = {},
+  ): Promise<ResourceReadResult> {
+    const owner = this.assistantOwners.get(resource)
+    if (owner === undefined) {
+      return {
+        ok: false,
+        error: error({
+          code: 'runtime.assistant_resource_unknown',
+          category: 'validation',
+          // O tipo veio de fora: a mensagem é fixa, e o valor recebido fica em `meta`.
+          message: 'O tipo de recurso informado não tem action dona.',
+          meta: { resource },
+        }),
+      }
+    }
+    const result = await this.execute(owner.name, { id }, ctxBase)
+    if (!result.ok) return { ok: false, error: result.error, meta: result.meta }
+
+    const { assistant } = owner
+    let title: string | null
+    let omitted: AssistantOmission[]
+    let context: ResourceContext | undefined
+    try {
+      if (options.context === true) {
+        // A projeção já resolve o título; sem contexto pedido, basta o título, sem pagar o corte.
+        const projection = projectAssistantContext(assistant, result.data)
+        title = projection.title
+        omitted = projection.omitted
+        context = {
+          data: projection.data,
+          truncated: projection.truncated,
+          omitted: projection.omitted,
+          personalData: owner.personalData === true,
+        }
+      } else {
+        ;({ title, omitted } = resolveAssistantTitle(assistant, result.data))
+      }
+    } catch (thrown) {
+      // A action executou e foi auditada; o que falhou foi transformar a saída em dado ao modelo
+      // (por exemplo, `BigInt` ou referência circular, que o JSON não representa).
+      this.log.error('A saída da action dona não pôde ser projetada para o assistente.', {
+        code: 'runtime.assistant_projection_failed',
+        action: owner.name,
+        resource,
+        error: thrown instanceof Error ? thrown.message : String(thrown),
+      })
+      return {
+        ok: false,
+        error: error({
+          code: 'runtime.assistant_projection_failed',
+          category: 'internal',
+          message: 'Não foi possível preparar os dados deste recurso para o assistente.',
+          cause: thrown,
+        }),
+        meta: result.meta,
+      }
+    }
+    const missing = omitted.filter((entry) => entry.reason === 'missing').map((entry) => entry.path)
+    if (missing.length > 0) {
+      this.log.warn(
+        `A saída de "${owner.name}" não trouxe ${missing.map((path) => `\`${path}\``).join(', ')}, ` +
+          'declarado no assistente, como texto ou valor esperado; o recurso foi lido sem esses campos.',
+        { code: 'runtime.assistant_path_missing', action: owner.name, resource, paths: missing },
+      )
+    }
+    return {
+      ok: true,
+      resource: { kind: resource, id, title, label: assistant.label, skill: assistant.skill },
+      ...(context !== undefined ? { context } : {}),
+      meta: result.meta,
+    }
+  }
+
+  /**
+   * As declarações de assistente registradas, com a action dona de cada uma (ADR 0053). Serve ao
+   * consumidor para montar rotas e telas a partir da declaração e para conferir as chaves de
+   * procedimento contra o registro que ele mantém.
+   */
+  assistants(): RegisteredAssistant[] {
+    return [...this.assistantOwners.values()].map((owner) => ({
+      action: owner.name,
+      ...publicAssistant(owner.assistant),
+      personalData: owner.personalData === true,
+    }))
+  }
+
   /**
    * Executa no worker um envelope criado por `execute()`. O consumer fornece
    * auth/can reidratados; identidade, provenance e trace vêm do envelope.
@@ -1026,6 +1159,9 @@ export class Runtime {
         metadata: {
           ...(effect !== undefined ? { effect } : {}),
           ...(action.personalData !== undefined ? { personalData: action.personalData } : {}),
+          ...(action.kind === 'view' && action.assistant !== undefined
+            ? { assistant: publicAssistant(action.assistant) }
+            : {}),
           dataProducts,
           dataProductLabels: Object.fromEntries(
             dataProducts.map((id) => [id, this.dataProducts.get(id)?.label ?? id]),

package/src/core/types.ts

@@ -21,6 +21,7 @@
  *  13. RuntimeConfig (§14)
  */
 
+import type { AssistantDeclaration } from './assistant.ts'
 import type { SoftDeleteEntity } from './retention.ts'
 
 // =============================================================================
@@ -548,6 +549,30 @@ export interface AIConfig {
   requiresConfirmation?: boolean
 }
 
+/**
+ * O assistente do recurso que uma action `view` lê (ADR 0053). A action que o declara é a action
+ * dona do tipo de recurso: é por ela que o recurso é lido e que o acesso a ele é conferido. A
+ * declaração é serializável e não carrega função, consulta nem regra de acesso.
+ */
+export interface ActionAssistant {
+  /** O tipo de recurso de que a action é dona, em camelCase e único no runtime (`customer`). */
+  resource: string
+  /** A chave do procedimento que a IA segue ao tratar do recurso, em minúsculas com hífen. */
+  skill: string
+  /** O nome do assistente para pessoas (`Assistente do cliente`). */
+  label: string
+  /** O caminho, na saída, do campo que nomeia o recurso para pessoas (`name`). */
+  title: string
+  /**
+   * Os caminhos, na saída, dos campos que o host pode entregar ao modelo como dado do recurso. O
+   * ponto desce em objetos (`leads.totalCount`); um caminho que passa por uma lista se aplica a cada
+   * item.
+   */
+  context: readonly string[]
+  /** Teto, em caracteres, do JSON de `context`. Padrão de 4.000, mínimo de 1.000, máximo de 16.000. */
+  maxContextChars?: number
+}
+
 export interface Example {
   name: string
   description?: string
@@ -943,6 +968,12 @@ export interface ViewAction<In, Out, ParsedIn = In> extends ActionBase<In, Out,
   /** Entidades relacionadas projetáveis. View simples não projeta nada — omita. */
   projection?: string[]
   expand?: Record<string, ExpandSpec>
+  /**
+   * Torna esta action a dona de um tipo de recurso e declara o assistente dele (ADR 0053). Exige
+   * `ai` habilitado, `personalData` declarado e uma entrada em que `id`, do tipo texto, é o único
+   * campo obrigatório. O runtime lê o recurso por `runtime.readResource`.
+   */
+  assistant?: ActionAssistant
 }
 
 /**
@@ -1341,6 +1372,9 @@ export interface AiTool {
     effect?: ActionEffect
     /** A action declara devolver dado pessoal; ausente quando não declarou. */
     personalData?: boolean
+    /** O assistente do recurso de que a action é dona (ADR 0053), com o teto resolvido; ausente
+     *  quando não declara. */
+    assistant?: AssistantDeclaration
   }
 }
 

package/src/mcp/index.ts

@@ -58,6 +58,9 @@ export function createOpusMcpServer(runtime: Runtime, opts: OpusMcpOptions = {})
         ...(t.metadata?.personalData !== undefined
           ? { 'com.softize.opus/personal-data': t.metadata.personalData }
           : {}),
+        // O assistente do recurso de que a action é dona (ADR 0053): o host conhece o assistente
+        // pelo catálogo que já consulta.
+        ...(t.metadata?.assistant !== undefined ? { 'com.softize.opus/assistant': t.metadata.assistant } : {}),
       },
     })),
   }))

package/src/ui/components/primitives/dialog.tsx

@@ -19,16 +19,34 @@ import {
   type StructuralMediaProps,
 } from "../patterns/structural-media.tsx";
 import { CloseButton, type CloseButtonSize } from "./close-button.tsx";
+import {
+  ANSWER_BAND_CLASS,
+  LAYER_MODAL_ATTRIBUTE,
+  LayerPortalProvider,
+  exemptLayerFirst,
+  focusIsInLayer,
+  handleModalTabKey,
+  isLayerInteraction,
+  routeEscapeToLayer,
+  useLayerPortal,
+  useModalLayerEntry,
+  type ModalMark,
+} from "../../lib/modal-layers.ts";
 
 export type DialogMode = "default" | "alert";
 
 interface DialogContextValue {
   mode: DialogMode;
   onResult?: (result: string) => void;
+  /** Estado de aberto, que a pilha de modais da camada flutuante acompanha (ADR 0052). */
+  open: boolean;
+  modal: boolean;
 }
 
 const DialogContext = React.createContext<DialogContextValue>({
   mode: "default",
+  open: false,
+  modal: true,
 });
 
 interface DialogContentContextValue {
@@ -67,6 +85,139 @@ function useDialogContext(): DialogContextValue {
   return React.useContext(DialogContext);
 }
 
+/**
+ * Estado de aberto controlado ou não, como o do Radix, mas visível ao Opus: a pilha de modais da
+ * camada flutuante precisa saber quando o modal fecha, e não só quando desmonta (ADR 0052).
+ */
+export function useModalOpenState({
+  open: openProp,
+  defaultOpen,
+  onOpenChange,
+}: {
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+}): [boolean, (open: boolean) => void] {
+  const [uncontrolled, setUncontrolled] = React.useState(defaultOpen ?? false);
+  const controlled = openProp !== undefined;
+  const open = controlled ? openProp : uncontrolled;
+  const onOpenChangeRef = React.useRef(onOpenChange);
+  onOpenChangeRef.current = onOpenChange;
+  const setOpen = React.useCallback(
+    (next: boolean) => {
+      if (!controlled) setUncontrolled(next);
+      onOpenChangeRef.current?.(next);
+    },
+    [controlled],
+  );
+  return [open, setOpen];
+}
+
+interface OutsideEvent {
+  defaultPrevented: boolean;
+  preventDefault(): void;
+  detail: { originalEvent: Event };
+}
+
+/**
+ * Isenções da camada flutuante compostas antes dos handlers de dispensa do consumidor e do
+ * `closeDisabled`, para Dialog e Drawer (seção 8 da ADR 0052). Fora de um modal de trabalho,
+ * devolve só a composição de sempre.
+ */
+export function composeModalDismissHandlers<
+  Escape extends KeyboardEvent,
+  Pointer extends OutsideEvent,
+  Interact extends OutsideEvent,
+  CloseFocus extends Event,
+>({
+  mark,
+  closeDisabled,
+  onEscapeKeyDown,
+  onPointerDownOutside,
+  onInteractOutside,
+  onCloseAutoFocus,
+}: {
+  mark: ModalMark;
+  closeDisabled: boolean;
+  onEscapeKeyDown: ((event: Escape) => void) | undefined;
+  onPointerDownOutside: ((event: Pointer) => void) | undefined;
+  onInteractOutside: ((event: Interact) => void) | undefined;
+  onCloseAutoFocus: ((event: CloseFocus) => void) | undefined;
+}): {
+  onEscapeKeyDown: ((event: Escape) => void) | undefined;
+  onPointerDownOutside: ((event: Pointer) => void) | undefined;
+  onInteractOutside: ((event: Interact) => void) | undefined;
+  onCloseAutoFocus: (event: CloseFocus) => void;
+} {
+  const escape = preventDismissWhen(closeDisabled, onEscapeKeyDown);
+  const interact = preventDismissWhen(closeDisabled, onInteractOutside);
+  // O modal que fecha com a pessoa na camada não leva o foco ao gatilho dele: o foco fica onde
+  // ela está digitando. O handler do consumidor roda antes e pode decidir outra coisa.
+  const closeAutoFocus = (event: CloseFocus): void => {
+    onCloseAutoFocus?.(event);
+    if (!event.defaultPrevented && focusIsInLayer()) event.preventDefault();
+  };
+  if (mark !== "work") {
+    return {
+      onEscapeKeyDown: escape,
+      onPointerDownOutside,
+      onInteractOutside: interact,
+      onCloseAutoFocus: closeAutoFocus,
+    };
+  }
+  return {
+    onEscapeKeyDown: exemptLayerFirst(routeEscapeToLayer, escape),
+    onPointerDownOutside: exemptLayerFirst(
+      isLayerInteraction,
+      onPointerDownOutside,
+    ),
+    onInteractOutside: exemptLayerFirst(isLayerInteraction, interact),
+    onCloseAutoFocus: closeAutoFocus,
+  };
+}
+
+type RefCleanup = () => void;
+
+function setRef<T>(
+  ref: React.Ref<T> | undefined,
+  value: T | null,
+): RefCleanup | void {
+  if (typeof ref === "function") {
+    const cleanup = ref(value);
+    return typeof cleanup === "function" ? cleanup : undefined;
+  }
+  if (ref !== null && ref !== undefined) {
+    (ref as React.RefObject<T | null>).current = value;
+  }
+}
+
+/**
+ * Compõe a ref do consumidor com a do Opus sem perder nenhuma das duas, como o `composeRefs` do
+ * Radix: quando alguma callback ref devolve limpeza (React 19), a composição também devolve, e o
+ * React passa a chamá-la em vez de chamar as refs com `null`. As refs sem limpeza recebem `null`
+ * nesse momento.
+ */
+export function useComposedRef<T>(
+  ...refs: Array<React.Ref<T> | undefined>
+): (node: T | null) => RefCleanup | undefined {
+  return React.useCallback(
+    (node: T | null) => {
+      const cleanups = refs.map((ref) => setRef(ref, node));
+      if (!cleanups.some((cleanup) => typeof cleanup === "function")) {
+        return undefined;
+      }
+      return () => {
+        cleanups.forEach((cleanup, index) => {
+          if (typeof cleanup === "function") cleanup();
+          else setRef(refs[index], null);
+        });
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    refs,
+  );
+}
+
 export interface DialogProps extends React.ComponentProps<
   typeof DialogPrimitive.Root
 > {
@@ -80,16 +231,40 @@ export function Dialog({
   mode = "default",
   onResult,
   modal,
+  open: openProp,
+  defaultOpen,
+  onOpenChange,
   ...props
 }: DialogProps) {
-  const context = React.useMemo(() => ({ mode, onResult }), [mode, onResult]);
+  const [open, setOpen] = useModalOpenState({
+    open: openProp,
+    defaultOpen,
+    onOpenChange,
+  });
+  // O `AlertDialog` do Radix força o modo modal e ignora `modal`.
+  const isModal = mode === "alert" || modal !== false;
+  const context = React.useMemo(
+    () => ({ mode, onResult, open, modal: isModal }),
+    [mode, onResult, open, isModal],
+  );
 
   return (
     <DialogContext.Provider value={context}>
       {mode === "alert" ? (
-        <AlertDialogPrimitive.Root data-slot="dialog" {...props} />
+        <AlertDialogPrimitive.Root
+          data-slot="dialog"
+          open={open}
+          onOpenChange={setOpen}
+          {...props}
+        />
       ) : (
-        <DialogPrimitive.Root data-slot="dialog" modal={modal} {...props} />
+        <DialogPrimitive.Root
+          data-slot="dialog"
+          modal={modal}
+          open={open}
+          onOpenChange={setOpen}
+          {...props}
+        />
       )}
     </DialogContext.Provider>
   );
@@ -107,13 +282,25 @@ export function DialogTrigger({
 }
 
 export function DialogPortal({
+  container,
   ...props
 }: React.ComponentProps<typeof DialogPrimitive.Portal>) {
   const { mode } = useDialogContext();
+  // Aberto de dentro de uma camada flutuante, o modal vai para o hospedeiro dela (ADR 0052).
+  const layer = useLayerPortal();
+  const target = container ?? layer.container;
   return mode === "alert" ? (
-    <AlertDialogPrimitive.Portal data-slot="dialog-portal" {...props} />
+    <AlertDialogPrimitive.Portal
+      data-slot="dialog-portal"
+      container={target}
+      {...props}
+    />
   ) : (
-    <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />
+    <DialogPrimitive.Portal
+      data-slot="dialog-portal"
+      container={target}
+      {...props}
+    />
   );
 }
 
@@ -163,6 +350,13 @@ export function DialogClose({
   );
 }
 
+/**
+ * Alerta em animação de saída deixa de receber clique: o Dialog que a resposta abre em seguida fica
+ * na faixa de baixo e seria coberto pelo véu do alerta até a animação terminar. O `!` vence o
+ * `pointer-events` que o Radix grava no estilo do véu e do conteúdo.
+ */
+const answerClosingClasses = "data-[state=closed]:pointer-events-none!";
+
 /** Véu compartilhado por Dialog e Drawer: mesmo escurecimento e animação. */
 export const overlayClasses =
   "fixed inset-0 z-50 bg-black/30 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0";
@@ -172,17 +366,25 @@ export function DialogOverlay({
   ...props
 }: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
   const { mode } = useDialogContext();
-  const overlay = cn(overlayClasses, className);
+  const layer = useLayerPortal();
+  const internal = layer.container !== undefined || undefined;
   return mode === "alert" ? (
     <AlertDialogPrimitive.Overlay
       data-slot="dialog-overlay"
-      className={overlay}
+      {...{ [LAYER_MODAL_ATTRIBUTE]: internal }}
+      className={cn(
+        overlayClasses,
+        ANSWER_BAND_CLASS,
+        answerClosingClasses,
+        className,
+      )}
       {...props}
     />
   ) : (
     <DialogPrimitive.Overlay
       data-slot="dialog-overlay"
-      className={overlay}
+      {...{ [LAYER_MODAL_ATTRIBUTE]: internal }}
+      className={cn(overlayClasses, layer.zIndexClass, className)}
       {...props}
     />
   );
@@ -211,7 +413,11 @@ export function DialogContent({
   layout = "sectioned",
   "aria-describedby": ariaDescribedBy,
   onEscapeKeyDown,
+  onPointerDownOutside,
   onInteractOutside,
+  onCloseAutoFocus,
+  onKeyDown,
+  ref,
   ...props
 }: React.ComponentProps<typeof DialogPrimitive.Content> & {
   /** Mostra a ação “Fechar” no modo padrão. O modo `alert` exige uma resposta identificável. */
@@ -226,7 +432,32 @@ export function DialogContent({
   /** Anatomia da superfície: `sectioned` (default) ou `continuous` — ADR 0023. */
   layout?: SurfaceLayout;
 }) {
-  const { mode } = useDialogContext();
+  const { mode, open, modal } = useDialogContext();
+  const layer = useLayerPortal();
+  const internal = layer.container !== undefined;
+  // Seção 6 da ADR 0052: o alerta é resposta obrigatória; o modal portado para uma camada é
+  // interno a ela; os demais são de trabalho e convivem com a camada.
+  const mark: ModalMark =
+    mode === "alert" ? "answer" : internal ? "internal" : "work";
+  const entryRef = useModalLayerEntry({ open, modal, mark, surface: "dialog" });
+  const composedRef = useComposedRef(ref, entryRef);
+  const dismiss = composeModalDismissHandlers({
+    mark,
+    closeDisabled,
+    onEscapeKeyDown,
+    onPointerDownOutside,
+    onInteractOutside,
+    onCloseAutoFocus,
+  });
+  const handleKeyDown = (event: React.KeyboardEvent<HTMLDivElement>): void => {
+    onKeyDown?.(event);
+    handleModalTabKey(event);
+  };
+  // Os portais abertos daqui herdam a marca de modal quando este Dialog mora numa camada.
+  const nestedPortal = React.useMemo(
+    () => ({ ...layer, modalSubtree: layer.modalSubtree || internal }),
+    [layer, internal],
+  );
   const showClose = showCloseButton ?? mode !== "alert";
   const contentClasses =
     "fixed left-[50%] top-[50%] z-50 w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] overflow-clip rounded-xl border border-transparent bg-background text-foreground shadow-xl duration-200 outline-none [--surface-background:var(--background)] data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95 dark:border-border/70";
@@ -236,25 +467,45 @@ export function DialogContent({
       <DialogPortal>
         <DialogOverlay />
         <AlertDialogPrimitive.Content
+          ref={composedRef}
           data-slot="dialog-content"
           data-mode="alert"
-          className={cn(contentClasses, "grid max-w-xs gap-4 p-6", className)}
+          {...{ [LAYER_MODAL_ATTRIBUTE]: internal || undefined }}
+          className={cn(
+            contentClasses,
+            ANSWER_BAND_CLASS,
+            answerClosingClasses,
+            "grid max-w-xs gap-4 p-6",
+            className,
+          )}
           aria-describedby={ariaDescribedBy}
-          onEscapeKeyDown={preventDismissWhen(closeDisabled, onEscapeKeyDown)}
+          // O `AlertDialog` do Radix cancela sozinho o clique fora; só o Esc é composto.
+          onEscapeKeyDown={dismiss.onEscapeKeyDown}
+          onCloseAutoFocus={dismiss.onCloseAutoFocus}
+          onKeyDown={onKeyDown}
           {...props}
         >
           {/* Sem anatomia seccionada (exceção da ADR 0023), mas a altura continua sendo
               decisão do diálogo: a cadeia `fill` da página não atravessa o portal. */}
           <FillBoundary>
-            <DialogContentContext.Provider
+            {/* Popover, Menu e Tooltip abertos daqui sobem para a faixa do alerta. */}
+            <LayerPortalProvider
               value={{
-                showCloseButton: false,
-                closeDisabled: true,
-                closeSize,
+                container: layer.container,
+                zIndexClass: ANSWER_BAND_CLASS,
+                modalSubtree: internal,
               }}
             >
-              {children}
-            </DialogContentContext.Provider>
+              <DialogContentContext.Provider
+                value={{
+                  showCloseButton: false,
+                  closeDisabled: true,
+                  closeSize,
+                }}
+              >
+                {children}
+              </DialogContentContext.Provider>
+            </LayerPortalProvider>
           </FillBoundary>
         </AlertDialogPrimitive.Content>
       </DialogPortal>
@@ -265,26 +516,34 @@ export function DialogContent({
     <DialogPortal>
       <DialogOverlay />
       <DialogPrimitive.Content
+        ref={composedRef}
         data-slot="dialog-content"
         data-mode="default"
         data-layout={layout}
+        {...{ [LAYER_MODAL_ATTRIBUTE]: internal || undefined }}
         className={cn(
           contentClasses,
           "flex max-h-[85vh] max-w-lg flex-col",
+          layer.zIndexClass,
           className,
         )}
         aria-describedby={ariaDescribedBy}
-        onEscapeKeyDown={preventDismissWhen(closeDisabled, onEscapeKeyDown)}
-        onInteractOutside={preventDismissWhen(closeDisabled, onInteractOutside)}
+        onEscapeKeyDown={dismiss.onEscapeKeyDown}
+        onPointerDownOutside={dismiss.onPointerDownOutside}
+        onInteractOutside={dismiss.onInteractOutside}
+        onCloseAutoFocus={dismiss.onCloseAutoFocus}
+        onKeyDown={handleKeyDown}
         {...props}
       >
-        <SurfaceLayoutProvider value={layout}>
-          <DialogContentContext.Provider
-            value={{ showCloseButton: showClose, closeDisabled, closeSize }}
-          >
-            {children}
-          </DialogContentContext.Provider>
-        </SurfaceLayoutProvider>
+        <LayerPortalProvider value={nestedPortal}>
+          <SurfaceLayoutProvider value={layout}>
+            <DialogContentContext.Provider
+              value={{ showCloseButton: showClose, closeDisabled, closeSize }}
+            >
+              {children}
+            </DialogContentContext.Provider>
+          </SurfaceLayoutProvider>
+        </LayerPortalProvider>
       </DialogPrimitive.Content>
     </DialogPortal>
   );