@softize/opus 30.0.0 → 31.1.0

package/src/core/presentation.ts

@@ -29,7 +29,12 @@ export const presentationSurfaceSchema = z.enum(["page", "dialog", "drawer"]);
 export type PresentationSurface = z.infer<typeof presentationSurfaceSchema>;
 
 export const presentationBindingSchema = z.discriminatedUnion("source", [
-  z.object({ source: z.literal("route"), param: identifierSchema }).strict(),
+  z
+    .object({
+      source: z.literal("route"),
+      param: z.string().regex(/^[a-z][a-zA-Z0-9]*$/),
+    })
+    .strict(),
   z.object({ source: z.literal("record"), field: z.string().min(1) }).strict(),
   z.object({ source: z.literal("item"), field: z.string().min(1) }).strict(),
   z.object({ source: z.literal("selection") }).strict(),
@@ -71,10 +76,139 @@ const presentationTargetSchema = z
   })
   .strict();
 
+const presentationConditionSchema = z.discriminatedUnion("op", [
+  z
+    .object({
+      field: z.string().min(1),
+      op: z.enum(["eq", "neq"]),
+      value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+    })
+    .strict(),
+  z
+    .object({
+      field: z.string().min(1),
+      op: z.enum(["in", "notIn"]),
+      values: z
+        .array(z.union([z.string(), z.number(), z.boolean(), z.null()]))
+        .min(1),
+    })
+    .strict(),
+]);
+export type PresentationCondition = z.infer<typeof presentationConditionSchema>;
+export function matchesPresentationConditions(
+  conditions: readonly PresentationCondition[] | undefined,
+  item: Record<string, unknown>,
+): boolean {
+  return (conditions ?? []).every((condition) => {
+    const value = item[condition.field];
+    if (value === undefined) return false;
+    if (condition.op === "eq") return value === condition.value;
+    if (condition.op === "neq") return value !== condition.value;
+    const matches = ("values" in condition ? condition.values : []).some(
+      (candidate) => candidate === value,
+    );
+    return condition.op === "in" ? matches : !matches;
+  });
+}
+const presentationRequirementSchema = z.union([
+  z.string().min(1),
+  z.array(z.string().min(1)).min(1),
+]);
+
+/** Permissões alternativas seguem a semântica de requires dos contratos (qualquer uma). */
+export function meetsPresentationRequirement(
+  requires: string | readonly string[] | undefined,
+  can?: (permission: string) => boolean,
+): boolean {
+  if (requires === undefined) return true;
+  return (typeof requires === "string" ? [requires] : requires).some(
+    (permission) => can?.(permission) === true,
+  );
+}
+
+/** Visibilidade não substitui authorize: requisitos da página e da action são cumulativos. */
+export function canAccessPresentation(
+  definition: PresentationDefinition,
+  actions: PresentationActionRegistry,
+  can?: (permission: string) => boolean,
+): boolean {
+  if (!meetsPresentationRequirement(definition.requires, can)) return false;
+  if (definition.source !== undefined) {
+    const source = actions[definition.source.action];
+    if (!source || !meetsPresentationRequirement(source.requires, can))
+      return false;
+  }
+  if (
+    isPresentationComponentBody(definition.body) &&
+    definition.body.contract
+  ) {
+    const contract = actions[definition.body.contract];
+    return (
+      contract !== undefined &&
+      meetsPresentationRequirement(contract.requires, can)
+    );
+  }
+  if (!isPresentationActionBody(definition.body)) return true;
+  const action = actions[definition.body.action];
+  return (
+    action !== undefined && meetsPresentationRequirement(action.requires, can)
+  );
+}
+
+const presentationOpenSchema = z
+  .object({
+    presentation: identifierSchema,
+    surface: presentationSurfaceSchema.optional(),
+    input: z.record(presentationBindingSchema).default({}),
+    requires: presentationRequirementSchema.optional(),
+    when: z.array(presentationConditionSchema).optional(),
+  })
+  .strict();
+const presentationColumnSchema = z.discriminatedUnion("kind", [
+  z
+    .object({
+      kind: z.literal("text"),
+      prefix: z.string().optional(),
+      empty: z.string().optional(),
+      icon: identifierSchema.optional(),
+      labels: z.record(z.string()).optional(),
+      fallback: z.string().optional(),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("switch"),
+      action: z.string().min(1),
+      input: z.record(presentationBindingSchema),
+      valueField: z.string().min(1),
+      label: z.string().min(1),
+      itemLabel: z.string().min(1),
+      requires: presentationRequirementSchema.optional(),
+    })
+    .strict(),
+]);
+export type PresentationColumn = z.infer<typeof presentationColumnSchema>;
+
 const presentationCommandSchema = z
   .object({
     action: z.string().min(1),
-    placement: z.enum(["header", "footer"]),
+    id: identifierSchema.optional(),
+    accessibleLabel: z.string().min(1).optional(),
+    successMessage: z.string().min(1).optional(),
+    requires: presentationRequirementSchema.optional(),
+    when: z.array(presentationConditionSchema).optional(),
+    confirm: z
+      .object({
+        title: z.string().min(1),
+        body: z.string().min(1).optional(),
+        actionLabel: z.string().min(1).optional(),
+      })
+      .strict()
+      .optional(),
+    placement: z.enum(["header", "toolbar", "footer", "row", "section"]),
+    icon: identifierSchema.optional(),
+    itemLabel: z.string().min(1).optional(),
+    label: z.string().min(1).optional(),
     input: z.record(presentationBindingSchema).default({}),
     target: presentationTargetSchema.optional(),
     blocking: z.enum(["action", "group", "surface"]).default("action"),
@@ -87,6 +221,7 @@ const presentationFieldSchema = z
     key: z.string().min(1),
     label: z.string().min(1),
     empty: z.string().min(1).optional(),
+    format: z.enum(["text", "pre", "html"]).optional(),
   })
   .strict();
 
@@ -97,14 +232,60 @@ const presentationActionBodySchema = z
     onSuccess: z.array(presentationEffectSchema).default([]),
     submitLabel: z.string().min(1).optional(),
     fields: z.array(presentationFieldSchema).min(1).optional(),
-    open: z
+    cells: identifierSchema.optional(),
+    rowKey: z.string().min(1).optional(),
+    beforeContent: identifierSchema.optional(),
+    rowContent: identifierSchema.optional(),
+    collection: identifierSchema.optional(),
+    toolbarContent: identifierSchema.optional(),
+    filterDefaults: z.record(z.string()).optional(),
+    columns: z.record(presentationColumnSchema).optional(),
+    intro: z.string().min(1).optional(),
+    defaultsFromRecord: z.boolean().optional(),
+    initialValues: z.record(presentationJsonValueSchema).optional(),
+    formFields: z.array(z.string().min(1)).min(1).optional(),
+    formGroups: z
+      .array(
+        z
+          .object({
+            title: z.string().min(1),
+            fields: z.array(z.string().min(1)).min(1),
+          })
+          .strict(),
+      )
+      .min(1)
+      .optional(),
+    fieldComponents: z.record(identifierSchema).optional(),
+    lookups: z
+      .record(
+        z
+          .object({
+            action: z.string().min(1),
+            label: z.string().min(1),
+            value: z.string().min(1),
+            format: identifierSchema.optional(),
+            prepend: z
+              .array(
+                z
+                  .object({ value: z.string(), label: z.string().min(1) })
+                  .strict(),
+              )
+              .optional(),
+          })
+          .strict(),
+      )
+      .optional(),
+    inspect: z
       .object({
-        presentation: identifierSchema,
-        surface: presentationSurfaceSchema.optional(),
-        input: z.record(presentationBindingSchema).default({}),
+        component: identifierSchema,
+        requires: presentationRequirementSchema.optional(),
+        when: z.array(presentationConditionSchema).optional(),
       })
       .strict()
       .optional(),
+    opens: z.array(presentationOpenSchema).min(1).optional(),
+    emptyMessage: z.string().min(1).optional(),
+    open: presentationOpenSchema.optional(),
   })
   .strict();
 
@@ -112,14 +293,203 @@ const presentationComponentBodySchema = z
   .object({
     /** Boundary estático do conteúdo React fornecido pelo consumidor. */
     component: identifierSchema,
+    contract: z.string().min(1).optional(),
+    footer: z.boolean().optional(),
+    input: z.record(presentationBindingSchema).optional(),
     /** Define se o heading principal nasce na casca ou no conteúdo React. */
     heading: z.enum(["shell", "content"]).default("shell"),
   })
   .strict();
 
+const presentationSectionBase = {
+  id: identifierSchema,
+  title: z.string().min(1).optional(),
+  feedback: identifierSchema.optional(),
+  notices: z
+    .array(
+      z
+        .object({
+          text: z.string().min(1),
+          when: z.array(presentationConditionSchema).optional(),
+        })
+        .strict(),
+    )
+    .optional(),
+};
+
+export const presentationSectionSchema = z.discriminatedUnion("kind", [
+  z
+    .object({
+      ...presentationSectionBase,
+      kind: z.literal("content"),
+      layout: z.enum(["flow", "fill"]).optional(),
+      content: identifierSchema,
+      actions: identifierSchema.optional(),
+    })
+    .strict(),
+  z
+    .object({
+      ...presentationSectionBase,
+      kind: z.literal("items"),
+      intro: identifierSchema.optional(),
+      actions: identifierSchema.optional(),
+      items: z
+        .array(
+          z
+            .object({
+              id: identifierSchema,
+              title: z.string().min(1),
+              description: z.string().min(1).optional(),
+              content: identifierSchema.optional(),
+              value: z
+                .object({
+                  field: z.string().min(1),
+                  empty: z.string().optional(),
+                  suffix: z.string().optional(),
+                })
+                .strict()
+                .optional(),
+              labelId: z.string().min(1).optional(),
+              placement: z.enum(["body", "actions", "below"]).optional(),
+            })
+            .strict(),
+        )
+        .min(1),
+    })
+    .strict(),
+  z
+    .object({
+      ...presentationSectionBase,
+      kind: z.literal("list"),
+      source: identifierSchema,
+      item: z
+        .object({
+          title: z.string().min(1),
+          description: z.string().min(1).optional(),
+        })
+        .strict()
+        .optional(),
+      emptyMessage: z.string().min(1).optional(),
+      errorMessage: z.string().min(1).optional(),
+    })
+    .strict(),
+]);
+export type PresentationSection = z.infer<typeof presentationSectionSchema>;
+export type PresentationListSection = Extract<
+  PresentationSection,
+  { kind: "list" }
+>;
+
+const presentationSectionsBodySchema = z
+  .object({
+    sections: z.array(presentationSectionSchema).min(1),
+    aside: z
+      .object({
+        content: identifierSchema,
+        label: z.string().min(1),
+        width: z.enum(["narrow", "default", "wide"]).optional(),
+      })
+      .strict()
+      .optional(),
+    overlays: z.array(identifierSchema).optional(),
+  })
+  .strict()
+  .superRefine((body, context) => {
+    const seen = new Set<string>();
+    body.sections.forEach((section, index) => {
+      if (seen.has(section.id))
+        context.addIssue({
+          code: "custom",
+          message: "Id de seção duplicado.",
+          path: ["sections", index, "id"],
+        });
+      seen.add(section.id);
+      if (section.kind === "items") {
+        const items = new Set<string>();
+        section.items.forEach((item, itemIndex) => {
+          if (items.has(item.id))
+            context.addIssue({
+              code: "custom",
+              message: "Id de item duplicado.",
+              path: ["sections", index, "items", itemIndex, "id"],
+            });
+          items.add(item.id);
+        });
+      }
+    });
+  });
+export type PresentationSectionsBody = z.infer<
+  typeof presentationSectionsBodySchema
+>;
+
+const presentationTabsBodySchema = z
+  .object({
+    tabLabel: z.string().min(1),
+    framed: z.boolean().optional(),
+    distribution: z.enum(["content", "equal"]).optional(),
+    defaultTab: identifierSchema,
+    tabs: z
+      .array(
+        z
+          .object({
+            id: identifierSchema,
+            label: z.string().min(1),
+            icon: identifierSchema.optional(),
+            content: identifierSchema.optional(),
+            presentation: identifierSchema.optional(),
+            route: z
+              .string()
+              .regex(
+                /^\/(?:[a-z0-9-]+|:[a-z][a-zA-Z0-9]*)(?:\/(?:[a-z0-9-]+|:[a-z][a-zA-Z0-9]*))*$/,
+              )
+              .optional(),
+          })
+          .strict(),
+      )
+      .min(1),
+  })
+  .strict()
+  .superRefine((body, context) => {
+    const seen = new Set<string>();
+    const routes = new Set<string>();
+    body.tabs.forEach((tab, index) => {
+      if ((tab.content === undefined) === (tab.presentation === undefined))
+        context.addIssue({
+          code: "custom",
+          message: "A aba exige content ou presentation, exclusivamente.",
+          path: ["tabs", index],
+        });
+      if (seen.has(tab.id))
+        context.addIssue({
+          code: "custom",
+          message: "Id de aba duplicado.",
+          path: ["tabs", index, "id"],
+        });
+      seen.add(tab.id);
+      if (tab.route !== undefined) {
+        if (routes.has(tab.route))
+          context.addIssue({
+            code: "custom",
+            message: "Rota de aba duplicada.",
+            path: ["tabs", index, "route"],
+          });
+        routes.add(tab.route);
+      }
+    });
+    if (!seen.has(body.defaultTab))
+      context.addIssue({
+        code: "custom",
+        message: "A aba inicial precisa existir na composição.",
+        path: ["defaultTab"],
+      });
+  });
+export type PresentationTabsBody = z.infer<typeof presentationTabsBodySchema>;
+
 const presentationBodySchema = z.union([
   presentationActionBodySchema,
   presentationComponentBodySchema,
+  presentationSectionsBodySchema,
+  presentationTabsBodySchema,
 ]);
 
 const presentationAssistantSchema = z
@@ -132,31 +502,115 @@ const presentationAssistantSchema = z
 const presentationRouteRecordSchema = z
   .object({
     presentation: identifierSchema,
-    param: identifierSchema,
+    fallbackFields: z.array(z.string().min(1)).min(1).optional(),
+    param: z.string().regex(/^[a-z][a-zA-Z0-9]*$/),
     field: z.string().min(1),
   })
   .strict();
 
+const presentationRouteQuerySchema = z
+  .object({
+    param: z.string().regex(/^[a-z][a-zA-Z0-9]*$/),
+    input: z.string().regex(/^[a-z][a-zA-Z0-9]*$/),
+  })
+  .strict();
 export const presentationRouteSchema = z
   .object({
+    parent: identifierSchema.optional(),
+    params: z.record(z.array(z.string().min(1)).min(1)).optional(),
+    query: z
+      .union([
+        presentationRouteQuerySchema,
+        z.array(presentationRouteQuerySchema).min(1),
+      ])
+      .optional(),
     path: z
       .string()
       .regex(
-        /^\/(?:[a-z0-9-]+|:[a-z][a-z0-9]*)(?:\/(?:[a-z0-9-]+|:[a-z][a-z0-9]*))*$/,
+        /^\/(?:[a-z0-9-]+|:[a-z][a-zA-Z0-9]*)(?:\/(?:[a-z0-9-]+|:[a-z][a-zA-Z0-9]*))*$/,
       ),
     surface: presentationSurfaceSchema,
     record: presentationRouteRecordSchema.optional(),
+    alternatives: z
+      .array(
+        z
+          .object({
+            when: z.array(presentationConditionSchema).min(1),
+            presentation: identifierSchema,
+          })
+          .strict(),
+      )
+      .optional(),
   })
   .strict();
 export type PresentationRoute = z.infer<typeof presentationRouteSchema>;
 
+/** Parâmetros necessários para selecionar esta rota; filtros livres não participam. */
+export function presentationRouteQueries(
+  route: PresentationRoute | undefined,
+): Array<z.infer<typeof presentationRouteQuerySchema>> {
+  return route?.query
+    ? Array.isArray(route.query)
+      ? route.query
+      : [route.query]
+    : [];
+}
+
 export const presentationSchema = z
   .object({
     schemaVersion: z.literal(1),
     id: identifierSchema,
     title: z.string().min(1),
+    requires: presentationRequirementSchema.optional(),
+    width: z.enum(["default", "wide"]).optional(),
     route: presentationRouteSchema.optional(),
     body: presentationBodySchema,
+    source: z
+      .object({
+        action: z.string().min(1),
+        retainOnError: z.boolean().optional(),
+        errorMessage: z.string().min(1).optional(),
+        input: z.record(presentationBindingSchema).default({}),
+        record: z
+          .object({ field: z.string().min(1), param: z.string().min(1) })
+          .strict()
+          .optional(),
+      })
+      .strict()
+      .optional(),
+    externalSource: identifierSchema.optional(),
+    links: z
+      .array(
+        z
+          .object({
+            id: identifierSchema,
+            label: z.string().min(1),
+            presentation: identifierSchema,
+            icon: identifierSchema.optional(),
+            showLabel: z.boolean().optional(),
+            placement: z.enum(["header", "section"]),
+            input: z.record(presentationBindingSchema).default({}),
+          })
+          .strict(),
+      )
+      .default([]),
+    header: z
+      .object({
+        title: identifierSchema.optional(),
+        description: identifierSchema.optional(),
+        meta: identifierSchema.optional(),
+        actions: identifierSchema.optional(),
+      })
+      .strict()
+      .optional(),
+    page: z
+      .object({
+        width: z.enum(["narrow", "default", "wide"]).optional(),
+        layout: z.enum(["flow", "fill"]).optional(),
+        flush: z.boolean().optional(),
+      })
+      .strict()
+      .optional(),
     assistant: presentationAssistantSchema.optional(),
     actions: z.array(presentationCommandSchema).default([]),
   })
@@ -243,7 +697,11 @@ type DefinedPresentationComponentBody<Body> =
 type DefinedPresentationBody<Body extends PresentationDefinitionInput["body"]> =
   Body extends { component: string }
     ? DefinedPresentationComponentBody<Body>
-    : DefinedPresentationActionBody<Body>;
+    : Body extends { sections: unknown }
+      ? PresentationSectionsBody
+      : Body extends { tabs: unknown }
+        ? PresentationTabsBody
+        : DefinedPresentationActionBody<Body>;
 type DefinedPresentationCommand<Command> = Command extends object
   ? Omit<Command, "input" | "blocking" | "onSuccess"> &
       Omit<PresentationCommand, "input" | "blocking" | "onSuccess"> & {
@@ -333,6 +791,18 @@ export function isPresentationComponentBody(
   return "component" in body;
 }
 
+export function isPresentationSectionsBody(
+  body: PresentationDefinition["body"],
+): body is PresentationSectionsBody {
+  return "sections" in body;
+}
+
+export function isPresentationTabsBody(
+  body: PresentationDefinition["body"],
+): body is PresentationTabsBody {
+  return "tabs" in body;
+}
+
 export interface PresentationRouteMatch {
   definition: PresentationDefinition;
   input: Record<string, string>;
@@ -359,8 +829,10 @@ function decodeRouteSegment(segment: string): string | null {
 export function matchPresentationRoute(
   definitions: readonly PresentationDefinition[],
   pathname: string,
+  search: string | URLSearchParams = "",
 ): PresentationRouteMatch | null {
   const actual = routeSegments(pathname);
+  const params = new URLSearchParams(search);
   const matches = definitions.flatMap((definition) => {
     if (definition.route === undefined) return [];
     const pattern = routeSegments(definition.route.path);
@@ -375,6 +847,17 @@ export function matchPresentationRoute(
         input[expected.slice(1)] = decoded;
       } else if (expected !== received) return [];
     }
+    if (
+      Object.entries(definition.route.params ?? {}).some(
+        ([key, values]) => !values.includes(input[key]!),
+      )
+    )
+      return [];
+    for (const query of presentationRouteQueries(definition.route)) {
+      const value = params.get(query.param);
+      if (!value) return [];
+      input[query.input] = value;
+    }
     return [{ definition, input }];
   });
   matches.sort((left, right) => {
@@ -382,7 +865,13 @@ export function matchPresentationRoute(
       routeSegments(entry.definition.route!.path).filter(
         (segment) => !segment.startsWith(":"),
       ).length;
-    return staticCount(right) - staticCount(left);
+    return (
+      staticCount(right) - staticCount(left) ||
+      presentationRouteQueries(right.definition.route).length -
+        presentationRouteQueries(left.definition.route).length ||
+      Object.keys(right.definition.route?.params ?? {}).length -
+        Object.keys(left.definition.route?.params ?? {}).length
+    );
   });
   return matches[0] ?? null;
 }
@@ -399,15 +888,30 @@ export function pathForPresentationInvocation(
       `Presentation “${invocation.presentationId}” não declara route.`,
     );
   }
-  return definition.route.path.replace(/:([a-z][a-z0-9]*)/g, (_, param) => {
-    const value = invocation.input[param];
-    if (typeof value !== "string" || value.length === 0) {
-      throw new Error(
-        `A rota de “${invocation.presentationId}” exige o parâmetro “${param}”.`,
-      );
-    }
-    return encodeURIComponent(value);
-  });
+  const path = definition.route.path.replace(
+    /:([a-z][a-zA-Z0-9]*)/g,
+    (_, param) => {
+      const value = invocation.input[param];
+      if (typeof value !== "string" || value.length === 0) {
+        throw new Error(
+          `A rota de “${invocation.presentationId}” exige o parâmetro “${param}”.`,
+        );
+      }
+      const allowed = definition.route!.params?.[param];
+      if (allowed && !allowed.includes(value)) {
+        throw new Error(`Valor inválido para o parâmetro “${param}” da rota.`);
+      }
+      return encodeURIComponent(value);
+    },
+  );
+  const search = new URLSearchParams();
+  for (const query of presentationRouteQueries(definition.route)) {
+    const value = invocation.input[query.input];
+    if (typeof value !== "string" || !value)
+      throw new Error(`A rota exige o parâmetro “${query.input}”.`);
+    search.set(query.param, value);
+  }
+  return `${path}${search.size ? `?${search}` : ""}`;
 }
 
 export interface PresentationBindingContext {
@@ -580,16 +1084,90 @@ export function validatePresentations(
   const parsed = z.array(presentationSchema).parse(input);
   const byId = new Map<string, PresentationDefinition>();
   const problems: string[] = [];
-  const routePatterns = new Set<string>();
+  const routePatterns = new Map<string, PresentationDefinition[]>();
 
   for (const presentation of parsed) {
     if (byId.has(presentation.id))
       problems.push(`Presentation “${presentation.id}” duplicada.`);
     byId.set(presentation.id, presentation);
+    if (presentation.source && presentation.externalSource)
+      problems.push("Declare apenas uma fonte de registro.");
+    if (presentation.source) {
+      const source = actions[presentation.source.action];
+      if (source?.kind !== "view" && source?.kind !== "list")
+        problems.push(
+          `Fonte de registro exige action view ou list: ${presentation.source.action}.`,
+        );
+      else if ((source.kind === "list") !== Boolean(presentation.source.record))
+        problems.push(
+          "Fonte list exige seleção de registro; fonte view não aceita seleção.",
+        );
+      else {
+        validateActionBindings(
+          presentation.source.input,
+          source,
+          `${presentation.id}.source.input`,
+          problems,
+        );
+        if (presentation.source.record) {
+          const { field, param } = presentation.source.record;
+          const output = unwrapObjectSchema(source.output)?.shape;
+          if (!output || !(field in output))
+            problems.push(`Campo de seleção inexistente: ${field}.`);
+          if (
+            presentation.route &&
+            !presentation.route.path.includes(`:${param}`) &&
+            !presentationRouteQueries(presentation.route).some(
+              (query) => query.input === param,
+            )
+          )
+            problems.push(
+              `Parâmetro da fonte não declarado na rota: ${param}.`,
+            );
+        }
+      }
+    }
+    if (isPresentationSectionsBody(presentation.body)) {
+      const output = presentation.source
+        ? unwrapObjectSchema(actions[presentation.source.action]?.output)?.shape
+        : undefined;
+      for (const section of presentation.body.sections) {
+        if (section.kind !== "items") continue;
+        for (const item of section.items) {
+          if (item.content && item.value)
+            problems.push(
+              `Item ${item.id} não pode declarar content e value juntos.`,
+            );
+          if (
+            item.value &&
+            !presentation.externalSource &&
+            (!output || !(item.value.field in output))
+          )
+            problems.push(
+              `Campo de registro inexistente: ${item.value.field}.`,
+            );
+        }
+      }
+    }
 
-    if (isPresentationComponentBody(presentation.body)) {
-      // O conteúdo interno permanece uma fronteira React opaca para a spec da casca.
-    } else {
+    if (
+      isPresentationComponentBody(presentation.body) &&
+      presentation.body.contract
+    ) {
+      const contract = actions[presentation.body.contract];
+      if (!contract)
+        problems.push(
+          `Contrato de componente inexistente: ${presentation.body.contract}.`,
+        );
+      else
+        validateActionBindings(
+          presentation.body.input ?? {},
+          contract,
+          `${presentation.id}.body.input`,
+          problems,
+        );
+    }
+    if (isPresentationActionBody(presentation.body)) {
       const bodyAction = actions[presentation.body.action];
       if (bodyAction === undefined) {
         problems.push(
@@ -614,6 +1192,13 @@ export function validatePresentations(
             `A Presentation “${presentation.id}” precisa declarar fields para a view.`,
           );
         }
+        if (
+          bodyAction.kind !== "list" &&
+          (presentation.body.cells !== undefined ||
+            presentation.body.emptyMessage !== undefined)
+        ) {
+          problems.push(`Cells e emptyMessage exigem uma action list no body.`);
+        }
         if (
           bodyAction.kind !== "view" &&
           presentation.body.fields !== undefined
@@ -637,7 +1222,68 @@ export function validatePresentations(
       }
     }
 
+    for (const entry of [...presentation.actions, ...presentation.links]) {
+      if (
+        entry.placement === "section" &&
+        !isPresentationSectionsBody(presentation.body)
+      )
+        problems.push(
+          `O placement section de “${presentation.id}” exige sections no body.`,
+        );
+    }
+    const sectionSlots = [
+      ...presentation.actions
+        .filter((command) => command.placement === "section")
+        .map((command) => command.id ?? command.action),
+      ...presentation.links
+        .filter((link) => link.placement === "section")
+        .map((link) => link.id),
+    ];
+    if (new Set(sectionSlots).size !== sectionSlots.length)
+      problems.push(
+        `Slots de ações e links de seção devem ser únicos em “${presentation.id}”.`,
+      );
     for (const command of presentation.actions) {
+      if (command.target !== undefined && command.successMessage !== undefined)
+        problems.push(
+          `SuccessMessage só pode ser declarado em comando de execução direta.`,
+        );
+      if (
+        (command.placement === "toolbar" || command.placement === "row") &&
+        (!isPresentationActionBody(presentation.body) ||
+          actions[presentation.body.action]?.kind !== "list")
+      ) {
+        problems.push(
+          `O placement ${command.placement} de “${presentation.id}” exige uma action list no body.`,
+        );
+      }
+      if (command.placement !== "row" && command.itemLabel !== undefined) {
+        problems.push(`ItemLabel só está disponível para comandos de linha.`);
+      }
+      if (command.placement === "row") {
+        if (command.blocking !== "action")
+          problems.push(`Comandos de linha usam blocking action.`);
+        const list = isPresentationActionBody(presentation.body)
+          ? actions[presentation.body.action]
+          : undefined;
+        const output =
+          list?.kind === "list" ? unwrapObjectSchema(list.output) : null;
+        if (output !== null) {
+          const fields = [
+            command.itemLabel,
+            ...(command.when ?? []).map((condition) => condition.field),
+            ...Object.values(command.input).flatMap((binding) =>
+              binding.source === "item" ? [binding.field] : [],
+            ),
+          ];
+          for (const field of fields) {
+            if (field !== undefined && !Object.hasOwn(output.shape, field))
+              problems.push(
+                `O campo “${field}” do comando de linha não existe na saída de “${list!.name}”.`,
+              );
+          }
+        }
+      }
       const action = actions[command.action];
       if (action === undefined) {
         problems.push(`A action “${command.action}” não está disponível.`);
@@ -648,7 +1294,11 @@ export function validatePresentations(
           `${presentation.id}.actions.${command.action}.input`,
           problems,
         );
-        if (action.kind === "simple" && command.target !== undefined) {
+        if (
+          action.kind === "simple" &&
+          action.effect !== "read" &&
+          command.target !== undefined
+        ) {
           problems.push(
             `A action simple “${command.action}” executa diretamente e não aceita target.`,
           );
@@ -663,16 +1313,73 @@ export function validatePresentations(
 
   for (const presentation of parsed) {
     if (presentation.route !== undefined) {
-      const pattern = routePattern(presentation.route.path);
-      if (routePatterns.has(pattern)) {
+      for (const alternative of presentation.route.alternatives ?? []) {
+        const target = byId.get(alternative.presentation);
+        if (
+          !presentation.route.record ||
+          !target ||
+          target.route?.surface !== presentation.route.surface ||
+          target.route?.alternatives
+        )
+          problems.push(
+            "Alternativa de rota exige registro e destino da mesma superfície, sem alternativas encadeadas.",
+          );
+      }
+      const queries = presentationRouteQueries(presentation.route);
+      const pathParams = routeSegments(presentation.route.path)
+        .filter((part) => part.startsWith(":"))
+        .map((part) => part.slice(1));
+      if (
+        new Set(queries.map((query) => query.param)).size !== queries.length ||
+        new Set([...pathParams, ...queries.map((query) => query.input)])
+          .size !==
+          pathParams.length + queries.length
+      ) {
         problems.push(
-          `A route “${presentation.route.path}” conflita com outra route declarada.`,
+          "Os parâmetros e bindings de busca da rota precisam ser distintos.",
         );
       }
-      routePatterns.add(pattern);
+      const pattern = `${routePattern(presentation.route.path)}?${presentationRouteQueries(
+        presentation.route,
+      )
+        .map((query) => query.param)
+        .sort()
+        .join("&")}`;
+      const siblings = routePatterns.get(pattern) ?? [];
+      for (const key of Object.keys(presentation.route.params ?? {}))
+        if (!routeSegments(presentation.route.path).includes(`:${key}`))
+          problems.push(`Restrição de parâmetro inexistente na rota: ${key}.`);
+      for (const sibling of siblings) {
+        const current = presentation.route.params ?? {};
+        const previous = sibling.route!.params ?? {};
+        const constrained = Object.keys(current).length > 0;
+        const siblingConstrained = Object.keys(previous).length > 0;
+        const disjoint = routeSegments(presentation.route.path).some(
+          (segment, index) => {
+            const values = current[segment.slice(1)];
+            const siblingKey = routeSegments(sibling.route!.path)[index]!.slice(
+              1,
+            );
+            const other = previous[siblingKey];
+            return (
+              values && other && values.every((value) => !other.includes(value))
+            );
+          },
+        );
+        if (constrained === siblingConstrained && !disjoint)
+          problems.push(
+            `A route “${presentation.route.path}” conflita com outra route declarada.`,
+          );
+      }
+      routePatterns.set(pattern, [...siblings, presentation]);
       const record = presentation.route.record;
       if (record !== undefined) {
-        if (!presentation.route.path.includes(`:${record.param}`)) {
+        if (
+          !presentation.route.path.includes(`:${record.param}`) &&
+          !presentationRouteQueries(presentation.route).some(
+            (query) => query.input === record.param,
+          )
+        ) {
           problems.push(
             `A route de “${presentation.id}” não declara o parâmetro “${record.param}” usado por record.`,
           );
@@ -703,6 +1410,180 @@ export function validatePresentations(
         }
       }
     }
+    if (
+      presentation.route?.parent !== undefined &&
+      !byId.has(presentation.route.parent)
+    )
+      problems.push(`Pai de rota inexistente: ${presentation.route.parent}.`);
+    if (isPresentationTabsBody(presentation.body)) {
+      for (const tab of presentation.body.tabs) {
+        if (tab.presentation !== undefined) {
+          const target = byId.get(tab.presentation);
+          if (
+            target === undefined ||
+            (!isPresentationActionBody(target.body) &&
+              !isPresentationSectionsBody(target.body))
+          )
+            problems.push(
+              `A aba ${tab.id} precisa referenciar uma Presentation de action ou seções.`,
+            );
+        }
+      }
+    }
+    if (isPresentationActionBody(presentation.body)) {
+      const body = presentation.body;
+      const owner = actions[body.action];
+      const shape = unwrapObjectSchema(owner?.input)?.shape;
+      if (
+        body.rowKey &&
+        !Object.hasOwn(
+          unwrapObjectSchema(owner?.output)?.shape ?? {},
+          body.rowKey,
+        )
+      )
+        problems.push(`Chave de linha inexistente: ${body.rowKey}.`);
+      if (
+        (body.lookups ||
+          body.formFields ||
+          body.formGroups ||
+          body.fieldComponents ||
+          body.defaultsFromRecord ||
+          body.initialValues) &&
+        owner?.kind !== "form"
+      )
+        problems.push("Lookups e campos de formulário exigem form.");
+      if (
+        (body.rowKey ||
+          body.columns ||
+          body.opens ||
+          body.inspect ||
+          body.filterDefaults ||
+          body.beforeContent ||
+          body.rowContent ||
+          body.collection ||
+          body.toolbarContent) &&
+        owner?.kind !== "list"
+      )
+        problems.push("Colunas e destinos de linha exigem list.");
+      for (const field of [
+        ...Object.keys(body.initialValues ?? {}),
+        ...Object.keys(body.lookups ?? {}),
+        ...(body.formFields ?? []),
+        ...(body.formGroups?.flatMap((group) => group.fields) ?? []),
+        ...Object.keys(body.fieldComponents ?? {}),
+      ])
+        if (!shape || !(field in shape))
+          problems.push(`Campo de formulário inexistente: ${field}.`);
+      for (const field of Object.keys(body.fieldComponents ?? {})) {
+        if (body.lookups?.[field])
+          problems.push(
+            `Campo não pode declarar lookup e componente: ${field}.`,
+          );
+        if (body.formFields && !body.formFields.includes(field))
+          problems.push(`Componente fora dos campos do formulário: ${field}.`);
+      }
+      for (const lookup of Object.values(body.lookups ?? {})) {
+        const action = actions[lookup.action];
+        const output = unwrapObjectSchema(action?.output)?.shape;
+        if (
+          action?.kind !== "list" ||
+          !output ||
+          !(lookup.label in output) ||
+          !(lookup.value in output)
+        )
+          problems.push(`Lookup inválido: ${lookup.action}.`);
+        if (action?.kind === "list" && action.paginate !== false)
+          problems.push(
+            `Lookup “${lookup.action}” exige paginate false para apresentar todas as opções.`,
+          );
+      }
+      const output = unwrapObjectSchema(owner?.output)?.shape;
+      if (body.open !== undefined && body.opens !== undefined)
+        problems.push("Declare open ou opens, sem destinos concorrentes.");
+      if (body.inspect && (body.open || body.opens))
+        problems.push("Inspect não pode coexistir com open ou opens.");
+      for (const condition of body.inspect?.when ?? [])
+        if (!output || !(condition.field in output))
+          problems.push(`Campo de inspeção inexistente: ${condition.field}.`);
+      for (const opening of [
+        ...(body.opens ?? []),
+        ...(body.open ? [body.open] : []),
+      ]) {
+        const fields = [
+          ...(opening.when ?? []).map((condition) => condition.field),
+          ...Object.values(opening.input).flatMap((binding) =>
+            binding.source === "item" ? [binding.field] : [],
+          ),
+        ];
+        for (const field of fields)
+          if (!output || !(field in output))
+            problems.push(`Campo de destino de linha inexistente: ${field}.`);
+        const target = byId.get(opening.presentation);
+        if (
+          opening.surface &&
+          target?.route &&
+          opening.surface !== target.route.surface
+        )
+          problems.push(
+            `Superfície incompatível no destino de linha: ${opening.presentation}.`,
+          );
+      }
+      for (const [field, column] of Object.entries(body.columns ?? {})) {
+        if (!output || !(field in output))
+          problems.push(`Coluna inexistente: ${field}.`);
+        if (column.kind === "switch") {
+          const action = actions[column.action];
+          const input = unwrapObjectSchema(action?.input)?.shape;
+          for (const source of [
+            column.itemLabel,
+            ...Object.values(column.input).flatMap((binding) =>
+              binding.source === "item" ? [binding.field] : [],
+            ),
+          ])
+            if (!output || !(source in output))
+              problems.push(`Campo de switch inexistente: ${source}.`);
+          if (output?.[field] && !output[field].safeParse(false).success)
+            problems.push(`Coluna de switch precisa ser booleana: ${field}.`);
+          if (
+            !action ||
+            !["form", "simple"].includes(action.kind) ||
+            !input ||
+            !(column.valueField in input) ||
+            !input[column.valueField].safeParse(false).success
+          )
+            problems.push(`Action de switch inválida: ${column.action}.`);
+          else
+            validateActionBindings(
+              {
+                ...column.input,
+                [column.valueField]: { source: "fixed", value: false },
+              },
+              action,
+              `${presentation.id}.columns.${field}`,
+              problems,
+            );
+        }
+      }
+      for (const open of body.opens ?? []) {
+        const target = byId.get(open.presentation);
+        if (
+          !target ||
+          (!isPresentationActionBody(target.body) &&
+            !isPresentationComponentBody(target.body))
+        )
+          problems.push(`Destino de linha inexistente: ${open.presentation}.`);
+        else if (
+          isPresentationActionBody(target.body) &&
+          actions[target.body.action]
+        )
+          validateActionBindings(
+            open.input,
+            actions[target.body.action]!,
+            `${presentation.id}.opens`,
+            problems,
+          );
+      }
+    }
     const open = isPresentationActionBody(presentation.body)
       ? presentation.body.open
       : undefined;
@@ -805,11 +1686,21 @@ export function validatePresentations(
         problems.push(
           `A action “${command.action}” abre a Presentation inexistente “${command.target.presentation}”.`,
         );
-      } else if (!isPresentationActionBody(target.body)) {
+      } else if (
+        !isPresentationActionBody(target.body) &&
+        !target.source &&
+        !(
+          isPresentationComponentBody(target.body) &&
+          target.body.contract === command.action
+        )
+      ) {
         problems.push(
           `A Presentation “${target.id}” usa conteúdo de componente e não pode ser aberta pela action “${command.action}”.`,
         );
-      } else if (target.body.action !== command.action) {
+      } else if (
+        isPresentationActionBody(target.body) &&
+        target.body.action !== command.action
+      ) {
         problems.push(
           `A Presentation “${target.id}” usa “${target.body.action}”, mas foi aberta por “${command.action}”.`,
         );
@@ -826,6 +1717,14 @@ export function validatePresentations(
   }
 
   if (problems.length > 0) throw new Error(problems.join("\n"));
+  for (const presentation of parsed) {
+    for (const link of presentation.links) {
+      if (!byId.get(link.presentation)?.route)
+        throw new Error(
+          `Destino de navegação não registrado: ${link.presentation}.`,
+        );
+    }
+  }
   return parsed;
 }
 
@@ -838,8 +1737,15 @@ function unwrapObjectSchema(schema: unknown): z.ZodObject<any> | null {
     !visited.has(current)
   ) {
     visited.add(current);
-    if (current instanceof z.ZodObject) return current;
     const definition = (current as { _def?: Record<string, unknown> })._def;
+    // Contratos podem vir de outra instância de Zod no loader da CLI.
+    if (
+      current instanceof z.ZodObject ||
+      (definition?.typeName === "ZodObject" &&
+        "shape" in current &&
+        typeof current.shape === "object")
+    )
+      return current as z.ZodObject<any>;
     current = definition?.innerType ?? definition?.schema ?? null;
   }
   return null;