@snksergio/design-system 0.55.0 → 0.57.0

package/dist-lib/index.cjs

@@ -11,6 +11,8 @@ const lucideReact = require("lucide-react");
 const input = require("./chunks/input-DqaLFxER.cjs");
 const kpiDelta = require("./chunks/kpi-delta-wEzw5zSu.cjs");
 const pageHeader = require("./chunks/page-header-sValhWca.cjs");
+const core = require("@dnd-kit/core");
+const dateFns = require("date-fns");
 const RechartsPrimitive = require("recharts");
 const reactVirtual = require("@tanstack/react-virtual");
 require("@hello-pangea/dnd");
@@ -5266,6 +5268,2596 @@ const MonthYearPicker = React.forwardRef(function MonthYearPicker2({
   ] });
 });
 MonthYearPicker.displayName = "MonthYearPicker";
+const schedulerRoot = avatar.tv({
+  base: [
+    "flex h-full min-h-0 w-full flex-col gap-gp-2xl",
+    "text-fg-default"
+  ]
+});
+const schedulerToolbar = avatar.tv({
+  base: [
+    "flex flex-col gap-gp-xl",
+    "lg:flex-row lg:flex-wrap lg:items-center lg:justify-between"
+  ]
+});
+const schedulerToolbarSide = avatar.tv({
+  base: "flex min-w-0 items-center gap-gp-md",
+  variants: {
+    /**
+     * `leading` = título + navegação. Empilhado, ocupa a linha inteira e
+     * separa os dois extremos — é o que joga `‹ Hoje ›` pro fim.
+     * `trailing` = busca + controles. A busca é quem estica (`flex-1` nela),
+     * então aqui basta ocupar a linha.
+     */
+    slot: {
+      leading: "w-full justify-between lg:w-auto lg:flex-wrap lg:justify-start",
+      trailing: "w-full lg:w-auto lg:flex-wrap"
+    }
+  },
+  defaultVariants: { slot: "trailing" }
+});
+const schedulerTitle = avatar.tv({
+  base: [
+    "min-w-0 truncate text-title-sm font-semibold text-fg-default",
+    "first-letter:uppercase"
+  ]
+});
+const schedulerNavGroup = avatar.tv({
+  base: [
+    "inline-flex shrink-0 items-center",
+    "[&>*:not(:first-child)]:-ml-px",
+    // O segmento com foco sobe pra que o anel não seja cortado pelo vizinho.
+    "[&>*:focus-visible]:relative [&>*:focus-visible]:z-[1]",
+    "[&>*:first-child]:!rounded-r-none",
+    "[&>*:last-child]:!rounded-l-none",
+    "[&>*:not(:first-child):not(:last-child)]:!rounded-none"
+  ]
+});
+avatar.tv({
+  base: "tabular-nums"
+});
+const schedulerViewMenuItem = avatar.tv({
+  base: "flex items-center justify-between gap-gp-xl"
+});
+const schedulerFilterDot = avatar.tv({
+  base: [
+    "pointer-events-none absolute -right-[4px] -top-[4px] z-[2]",
+    "size-[13px] rounded-radius-full",
+    "bg-bg-brand border-2 border-bg-canvas"
+  ]
+});
+const schedulerSearch = avatar.tv({
+  base: [
+    "relative flex cursor-text items-center gap-gp-md",
+    "h-form-lg rounded-radius-lg px-pad-lg",
+    "bg-bg-surface dark:bg-bg-muted",
+    "border border-border-subtle dark:border-border-input",
+    "shadow-sh-sm dark:shadow-sh-none",
+    "text-fg-default",
+    "min-w-0 flex-1 lg:flex-initial",
+    "lg:w-[200px] lg:focus-within:w-[300px]",
+    "transition-[width,border-color,background-color,box-shadow] duration-200",
+    "focus-within:border-border-brand focus-within:shadow-sh-ring",
+    "[&_svg]:size-icon-sm [&_svg]:shrink-0 [&_svg]:text-fg-muted"
+  ],
+  variants: {
+    /** Mantém expandido mesmo sem foco quando já há termo digitado. */
+    expanded: { true: "lg:w-[300px]", false: "" }
+  },
+  defaultVariants: { expanded: false }
+});
+const schedulerSearchInput = avatar.tv({
+  base: [
+    "min-w-0 flex-1 border-0 bg-transparent outline-none",
+    "text-body-sm font-normal text-fg-default",
+    "placeholder:text-fg-muted"
+  ]
+});
+const schedulerFilterRow = avatar.tv({
+  base: [
+    "flex items-center gap-gp-md",
+    "flex-nowrap overflow-x-auto sm:flex-wrap sm:overflow-x-visible",
+    "[scrollbar-width:none] [&::-webkit-scrollbar]:hidden"
+  ]
+});
+const schedulerFilterChip = avatar.tv({
+  base: [
+    "inline-flex shrink-0 cursor-pointer items-center gap-gp-sm",
+    "h-form-md rounded-radius-lg pl-pad-lg pr-pad-md",
+    "bg-bg-surface dark:bg-bg-muted",
+    "border text-body-xs font-normal text-fg-default",
+    "transition-[background-color,border-color] duration-150",
+    "hover:bg-bg-muted-hover hover:border-border-default dark:hover:bg-bg-accent",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand",
+    "[&_svg]:size-icon-xs [&_svg]:shrink-0 [&_svg]:text-fg-subtle"
+  ],
+  variants: {
+    applied: {
+      true: "border-solid border-border-brand bg-bg-brand-subtle dark:bg-bg-brand-subtle",
+      false: "border-dashed border-border-input"
+    }
+  },
+  defaultVariants: { applied: false }
+});
+const schedulerFilterChipName = avatar.tv({
+  base: "font-semibold text-fg-default"
+});
+const schedulerFilterChipValue = avatar.tv({
+  base: [
+    "inline-flex h-comp-2xs items-center px-pad-md",
+    "rounded-radius-sm bg-bg-muted dark:bg-bg-accent",
+    "text-body-xs font-medium text-fg-default"
+  ]
+});
+const schedulerClearLink = avatar.tv({
+  base: [
+    "ml-pad-sm cursor-pointer border-0 bg-transparent p-0",
+    "text-body-xs font-medium text-fg-brand outline-none",
+    "underline-offset-2 transition-opacity duration-150",
+    "hover:underline focus-visible:underline"
+  ]
+});
+const schedulerBody = avatar.tv({
+  base: "flex min-h-0 flex-1 gap-gp-2xl"
+});
+const schedulerMain = avatar.tv({
+  base: "flex min-h-0 min-w-0 flex-1 flex-col"
+});
+const schedulerFilterAside = avatar.tv({
+  base: [
+    "flex min-h-0 flex-col overflow-y-auto",
+    // `scrollbar-thin` é a barra do DS (26 usos no repo contra 2 do
+    // `scrollbar-default`) — trilho transparente + thumb tokenizado.
+    // ⚠️ É `@utility` do tema GERADO, não do globals.css: existe nos 4 canais.
+    "scrollbar-thin"
+  ],
+  variants: {
+    /**
+     * `embedded` = o painel vive DENTRO de outro contêiner que já é a
+     * superfície — hoje o `FloatingPanel` do modo drawer (<1024px).
+     *
+     * Como coluna (`false`, o default) ele É o card: largura própria, borda,
+     * radius e fundo. Embutido, os quatro viram defeito — largura fixa deixa
+     * uma faixa morta à direita do drawer, e borda+radius+fundo repetem a
+     * superfície do painel que já o embrulha (card dentro de card, a mesma
+     * classe de erro da L-050).
+     */
+    embedded: {
+      false: [
+        "w-[280px] shrink-0",
+        "rounded-radius-xl border border-border-default bg-bg-surface"
+      ],
+      true: "w-full"
+    }
+  },
+  defaultVariants: { embedded: false }
+});
+const schedulerAsideSection = avatar.tv({
+  base: [
+    "flex shrink-0 flex-col gap-gp-md",
+    "border-b border-border-default p-sp-xl last:border-b-0"
+  ],
+  variants: {
+    /** O cabeçalho é mais raso: só uma linha de título + ações. */
+    compact: { true: "py-pad-lg", false: "" },
+    /**
+     * Cabeçalho fixo no topo enquanto o resto rola.
+     *
+     * `bg-bg-surface` é **obrigatório** e não decoração: `sticky` não cria
+     * fundo, então sem ele o mini-calendário passaria por baixo do título. E
+     * `z-[1]` porque as caixas e o `Checkbox` do Radix criam contexto próprio
+     * de empilhamento — sem o z, o conteúdo que rola sobrepõe o cabeçalho.
+     */
+    sticky: { true: "sticky top-0 z-[1] bg-bg-surface", false: "" }
+  },
+  defaultVariants: { compact: false, sticky: false }
+});
+const schedulerAsideHead = avatar.tv({
+  base: "flex items-center justify-between gap-gp-md"
+});
+const schedulerAsideTitle = avatar.tv({
+  base: "text-body-sm font-semibold text-fg-default"
+});
+const schedulerMiniHead = avatar.tv({
+  base: "flex items-center justify-between gap-gp-sm"
+});
+const schedulerMiniTitle = avatar.tv({
+  base: "min-w-0 truncate text-body-sm font-semibold text-fg-default first-letter:uppercase"
+});
+const schedulerMiniGrid = avatar.tv({
+  base: "grid grid-cols-7 gap-gp-2xs"
+});
+const schedulerMiniWeekday = avatar.tv({
+  base: [
+    "grid size-comp-xs place-items-center",
+    "text-caption-xs font-medium uppercase text-fg-subtle"
+  ]
+});
+const schedulerMiniDay = avatar.tv({
+  base: [
+    "grid size-comp-xs cursor-pointer place-items-center rounded-radius-full",
+    "border-0 bg-transparent outline-none",
+    "text-caption-md tabular-nums",
+    "transition-[background-color,color,box-shadow] duration-150",
+    "hover:bg-bg-muted",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand"
+  ],
+  variants: {
+    outside: { true: "text-fg-subtle", false: "text-fg-default" },
+    hasEvents: { true: "font-semibold", false: "" },
+    today: { true: "ring-1 ring-border-brand", false: "" },
+    selected: {
+      true: "bg-bg-brand font-semibold text-fg-on-brand hover:bg-bg-brand-hover",
+      false: ""
+    }
+  },
+  compoundVariants: [
+    // Selecionado vence "hoje": um anel em volta do disco cheio não informa
+    // nada e adiciona 2px de ruído.
+    { selected: true, today: true, class: "ring-0" },
+    { selected: true, outside: true, class: "text-fg-on-brand" }
+  ],
+  defaultVariants: {
+    outside: false,
+    hasEvents: false,
+    today: false,
+    selected: false
+  }
+});
+const schedulerGroup = avatar.tv({
+  base: "flex flex-col gap-gp-sm"
+});
+const schedulerGroupHead = avatar.tv({
+  base: [
+    "flex w-full cursor-pointer items-center justify-between gap-gp-md",
+    "min-h-form-sm rounded-radius-sm border-0 bg-transparent -mx-pad-sm px-pad-sm outline-none",
+    "text-body-sm font-semibold text-fg-default",
+    "transition-colors duration-150",
+    "hover:bg-bg-muted",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand",
+    "[&_svg]:size-icon-sm [&_svg]:shrink-0 [&_svg]:text-fg-subtle"
+  ]
+});
+const schedulerGroupChevron = avatar.tv({
+  base: "transition-transform duration-150",
+  variants: { open: { true: "", false: "-rotate-90" } },
+  defaultVariants: { open: true }
+});
+const schedulerOption = avatar.tv({
+  base: [
+    "flex cursor-pointer items-center gap-gp-md",
+    "min-h-form-sm rounded-radius-sm -mx-pad-sm px-pad-sm",
+    "text-body-sm text-fg-default",
+    "transition-colors duration-150",
+    "hover:bg-bg-muted",
+    "has-[:focus-visible]:ring-4 has-[:focus-visible]:ring-ring-brand"
+  ]
+});
+const schedulerOptionLabel = avatar.tv({
+  base: "min-w-0 flex-1 truncate"
+});
+const schedulerOptionCount = avatar.tv({
+  base: "shrink-0 text-caption-sm tabular-nums text-fg-subtle"
+});
+const schedulerOptionBox = avatar.tv({
+  base: "shrink-0",
+  variants: {
+    color: {
+      brand: "data-[state=checked]:bg-bg-brand data-[state=checked]:border-border-brand [&_svg]:text-fg-on-brand",
+      info: "data-[state=checked]:bg-bg-info data-[state=checked]:border-bg-info [&_svg]:text-fg-on-info",
+      success: "data-[state=checked]:bg-bg-success data-[state=checked]:border-bg-success [&_svg]:text-fg-on-success",
+      warning: "data-[state=checked]:bg-bg-warning data-[state=checked]:border-bg-warning [&_svg]:text-fg-on-warning",
+      danger: "data-[state=checked]:bg-bg-danger data-[state=checked]:border-bg-danger [&_svg]:text-fg-on-danger",
+      neutral: "data-[state=checked]:bg-fg-subtle data-[state=checked]:border-fg-subtle [&_svg]:text-bg-surface"
+    }
+  },
+  defaultVariants: { color: "brand" }
+});
+const schedulerMonthFrame = avatar.tv({
+  base: [
+    "flex min-h-0 flex-1 flex-col overflow-hidden",
+    "rounded-radius-xl border border-border-default bg-bg-surface"
+  ]
+});
+const schedulerWeekdayRow = avatar.tv({
+  base: [
+    "grid grid-cols-7 border-b border-border-default bg-bg-subtle dark:bg-bg-canvas"
+  ]
+});
+const schedulerWeekdayCell = avatar.tv({
+  base: [
+    "flex min-h-form-md items-center justify-center",
+    "text-caption-md font-medium text-fg-muted",
+    "first-letter:uppercase"
+  ]
+});
+const schedulerMonthGrid = avatar.tv({
+  base: "grid min-h-0 flex-1 grid-cols-7 grid-rows-6"
+});
+const schedulerMonthCell = avatar.tv({
+  base: [
+    "group/cell relative flex min-h-comp-4xl min-w-0 flex-col gap-gp-2xs",
+    "border-b border-r border-border-subtle p-sp-2xs",
+    "[&:nth-child(7n)]:border-r-0",
+    "transition-colors duration-150"
+  ],
+  variants: {
+    /** Dia de mês vizinho — recuado, não escondido: a grade é sempre 6×7. */
+    outside: {
+      true: "bg-bg-subtle/40 dark:bg-bg-canvas",
+      false: "bg-bg-surface"
+    },
+    /** Última linha da grade não desenha borda inferior (o frame já fecha). */
+    lastRow: { true: "border-b-0", false: "" },
+    interactive: { true: "hover:bg-bg-table-row-hover", false: "" }
+  },
+  defaultVariants: { outside: false, lastRow: false, interactive: false }
+});
+const schedulerDayHead = avatar.tv({
+  base: "flex shrink-0 items-center justify-between gap-gp-sm"
+});
+const schedulerDayNumber = avatar.tv({
+  base: [
+    "grid size-comp-xs shrink-0 place-items-center rounded-radius-full",
+    "text-body-xs font-medium tabular-nums",
+    "transition-colors duration-150"
+  ],
+  variants: {
+    today: {
+      true: "bg-bg-brand font-semibold text-fg-on-brand",
+      false: "text-fg-default"
+    },
+    outside: { true: "text-fg-subtle", false: "" }
+  },
+  compoundVariants: [
+    // `today` vence `outside`: o dia de hoje continua marcado mesmo quando
+    // aparece como dia vizinho na grade de outro mês.
+    { today: true, outside: true, class: "text-fg-on-brand" }
+  ],
+  defaultVariants: { today: false, outside: false }
+});
+const schedulerSlotAdd = avatar.tv({
+  base: [
+    "grid size-comp-3xs shrink-0 place-items-center rounded-radius-sm",
+    "cursor-pointer border-0 bg-transparent text-fg-subtle outline-none",
+    "opacity-0 transition-[opacity,background-color,color] duration-150",
+    "group-hover/cell:opacity-100 focus-visible:opacity-100",
+    "hover:bg-bg-muted hover:text-fg-default",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand",
+    "[&_svg]:size-icon-xs"
+  ]
+});
+const schedulerCellEvents = avatar.tv({
+  base: "flex min-h-0 flex-col gap-gp-2xs overflow-hidden"
+});
+const schedulerOverflowButton = avatar.tv({
+  base: [
+    "flex min-h-comp-2xs w-full cursor-pointer items-center",
+    "rounded-radius-sm border-0 bg-transparent px-pad-md",
+    "text-caption-sm font-medium text-fg-muted outline-none",
+    "transition-colors duration-150",
+    "hover:bg-bg-muted hover:text-fg-default",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand"
+  ]
+});
+const schedulerOverflowPanel = avatar.tv({
+  base: "flex max-h-[320px] min-w-[240px] flex-col gap-gp-2xs overflow-y-auto p-sp-xs"
+});
+const schedulerOverflowPanelTitle = avatar.tv({
+  base: "px-pad-md pb-pad-sm text-caption-sm font-semibold text-fg-muted first-letter:uppercase"
+});
+const schedulerTimeFrame = avatar.tv({
+  base: [
+    "flex min-h-0 flex-1 flex-col overflow-hidden",
+    "rounded-radius-xl border border-border-default bg-bg-surface"
+  ]
+});
+const schedulerTimeHead = avatar.tv({
+  base: "flex shrink-0 border-b border-border-default bg-bg-subtle dark:bg-bg-canvas"
+});
+const schedulerTimeGutter = avatar.tv({
+  base: "w-comp-4xl shrink-0"
+});
+const schedulerTimeHeadDay = avatar.tv({
+  base: [
+    "flex min-w-0 flex-1 flex-col items-center justify-center gap-gp-2xs",
+    "border-l border-border-subtle py-pad-md"
+  ],
+  variants: {
+    /** Sábado/domingo recuados — mesma leitura da grade do mês. */
+    weekend: { true: "bg-bg-subtle/40 dark:bg-bg-canvas", false: "" }
+  },
+  defaultVariants: { weekend: false }
+});
+const schedulerTimeHeadWeekday = avatar.tv({
+  base: "text-caption-md font-medium uppercase text-fg-muted"
+});
+const schedulerAllDayRow = avatar.tv({
+  base: "flex shrink-0 border-b border-border-default"
+});
+const schedulerAllDayLabel = avatar.tv({
+  base: [
+    "flex w-comp-4xl shrink-0 items-start justify-end",
+    "px-pad-md py-pad-sm text-caption-sm text-fg-subtle"
+  ]
+});
+const schedulerAllDayCell = avatar.tv({
+  base: [
+    "flex min-w-0 flex-1 flex-col gap-gp-2xs",
+    "border-l border-border-subtle p-sp-2xs"
+  ]
+});
+const schedulerTimeBody = avatar.tv({
+  base: "min-h-0 flex-1 overflow-y-auto overscroll-contain scrollbar-thin"
+});
+const schedulerTimeCanvas = avatar.tv({
+  base: "relative flex"
+});
+const schedulerHourLabel = avatar.tv({
+  base: [
+    "relative flex h-comp-3xl items-start justify-end pr-pad-md",
+    "text-caption-sm tabular-nums text-fg-subtle",
+    "first:opacity-0"
+  ]
+});
+const schedulerHourLabelText = avatar.tv({
+  base: "-translate-y-1/2"
+});
+const schedulerTimeColumn = avatar.tv({
+  base: "relative min-w-0 flex-1 border-l border-border-subtle",
+  variants: {
+    weekend: { true: "bg-bg-subtle/40 dark:bg-bg-canvas", false: "" }
+  },
+  defaultVariants: { weekend: false }
+});
+const schedulerHourSlot = avatar.tv({
+  base: [
+    "block h-comp-3xl w-full cursor-pointer",
+    "border-b border-border-subtle bg-transparent p-0 outline-none",
+    "transition-colors duration-150",
+    "hover:bg-bg-table-row-hover",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand",
+    "last:border-b-0"
+  ]
+});
+const schedulerNowLine = avatar.tv({
+  base: "pointer-events-none absolute left-0 right-0 z-[2] flex items-center"
+});
+const schedulerNowDot = avatar.tv({
+  base: "-ml-[4px] size-[8px] shrink-0 rounded-radius-full bg-bg-brand"
+});
+const schedulerNowStroke = avatar.tv({
+  base: "h-px flex-1 bg-bg-brand"
+});
+const schedulerNowLabel = avatar.tv({
+  base: [
+    "pointer-events-none absolute right-pad-md z-[2] -translate-y-1/2",
+    "rounded-radius-xs bg-bg-brand px-pad-sm",
+    "text-caption-xs font-semibold tabular-nums text-fg-on-brand"
+  ]
+});
+const schedulerListFrame = avatar.tv({
+  base: [
+    "flex min-h-0 flex-1 flex-col overflow-y-auto overscroll-contain scrollbar-thin",
+    "rounded-radius-xl border border-border-default bg-bg-surface"
+  ]
+});
+const schedulerListDay = avatar.tv({
+  base: "flex flex-col gap-gp-md border-b border-border-subtle p-sp-xl last:border-b-0"
+});
+const schedulerListDayHead = avatar.tv({
+  base: [
+    "sticky top-0 z-[1] -mx-sp-xl -mt-sp-xl px-sp-xl pb-pad-md pt-sp-xl",
+    "flex items-baseline gap-gp-md bg-bg-surface"
+  ]
+});
+const schedulerListDayNumber = avatar.tv({
+  base: "text-title-sm font-semibold tabular-nums",
+  variants: {
+    today: { true: "text-fg-brand", false: "text-fg-default" }
+  },
+  defaultVariants: { today: false }
+});
+const schedulerListDayName = avatar.tv({
+  base: "text-body-sm text-fg-muted first-letter:uppercase"
+});
+const schedulerListEvents = avatar.tv({
+  base: "flex flex-col gap-gp-sm"
+});
+const schedulerEvent = avatar.tv({
+  base: [
+    "group/event relative flex min-w-0 cursor-pointer items-center gap-gp-sm",
+    "border text-left outline-none",
+    "transition-[background-color,border-color,box-shadow] duration-150",
+    "focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand"
+  ],
+  variants: {
+    color: {
+      brand: "border-border-brand-subtle bg-bg-brand-subtle hover:bg-bg-brand-subtle-hover",
+      info: "border-border-info-muted bg-bg-info-muted hover:bg-bg-info-muted-hover",
+      success: "border-border-success-muted bg-bg-success-muted hover:bg-bg-success-muted-hover",
+      warning: "border-border-warning-muted bg-bg-warning-muted hover:bg-bg-warning-muted-hover",
+      danger: "border-border-danger-muted bg-bg-danger-muted hover:bg-bg-danger-muted-hover",
+      neutral: "border-border-default bg-bg-muted hover:bg-bg-muted-hover"
+    },
+    variant: {
+      /** Mês: linha de 20px, uma só, sem quebra. */
+      pill: "min-h-comp-2xs rounded-radius-sm px-pad-md text-caption-sm",
+      /** Week/day: bloco absoluto que ocupa a duração. */
+      block: "absolute min-h-comp-3xs flex-col items-start gap-0 rounded-radius-md px-pad-md py-pad-sm text-caption-sm",
+      /** List/agenda: linha larga com descrição. */
+      row: "min-h-form-lg w-full rounded-radius-lg px-pad-xl py-pad-md text-body-sm"
+    },
+    /** Continuação de evento multi-dia: perde o canto do lado truncado. */
+    truncateStart: { true: "rounded-l-none border-l-0", false: "" },
+    truncateEnd: { true: "rounded-r-none border-r-0", false: "" },
+    /**
+     * Enquanto arrasta: sombra alta pra o bloco "sair da superfície", z acima
+     * dos vizinhos, e `cursor-grabbing`.
+     *
+     * ⚠️ **Sem `transition` neste estado.** O `transform` do dnd-kit é atualizado
+     * a cada movimento do ponteiro; uma transição em cima dele faz o bloco
+     * perseguir o cursor com atraso — o gesto fica elástico e impreciso. A
+     * transição vive no estado NÃO-arrastando (`movable`), que é onde ela serve:
+     * o assentamento depois do soltar.
+     */
+    dragging: {
+      true: "z-[3] cursor-grabbing shadow-sh-lg opacity-90 transition-none",
+      false: ""
+    },
+    /** Arrastável e em repouso: mão aberta + transição de assentamento. */
+    movable: {
+      true: "cursor-grab transition-[top,left,height,width,background-color,border-color,box-shadow] duration-200 ease-out",
+      false: ""
+    },
+    disabled: { true: "pointer-events-none opacity-50", false: "" }
+  },
+  defaultVariants: {
+    color: "brand",
+    variant: "pill",
+    truncateStart: false,
+    truncateEnd: false,
+    dragging: false,
+    movable: false,
+    disabled: false
+  }
+});
+const schedulerResizeHandle = avatar.tv({
+  base: [
+    "absolute inset-x-0 z-[1] h-[6px] cursor-ns-resize",
+    "opacity-0 transition-opacity duration-150",
+    "group-hover/event:opacity-100 focus-visible:opacity-100",
+    "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring-brand",
+    // A barrinha só aparece no hover; o alvo de 6px existe sempre.
+    "after:absolute after:inset-x-[25%] after:top-[2px] after:h-[2px]",
+    "after:rounded-radius-full after:bg-fg-default/40"
+  ],
+  variants: {
+    edge: {
+      start: "-top-[3px]",
+      end: "-bottom-[3px]"
+    }
+  },
+  defaultVariants: { edge: "end" }
+});
+const schedulerDropTarget = avatar.tv({
+  base: "bg-bg-brand-subtle shadow-[inset_0_0_0_2px_var(--color-border-brand)]"
+});
+const schedulerEventDot = avatar.tv({
+  base: "shrink-0 rounded-radius-full",
+  variants: {
+    color: {
+      brand: "bg-bg-brand",
+      info: "bg-bg-info",
+      success: "bg-bg-success",
+      warning: "bg-bg-warning",
+      danger: "bg-bg-danger",
+      neutral: "bg-fg-subtle"
+    },
+    size: {
+      sm: "size-icon-2xs",
+      md: "size-icon-xs"
+    }
+  },
+  defaultVariants: { color: "brand", size: "sm" }
+});
+const schedulerEventTitle = avatar.tv({
+  base: "min-w-0 flex-1 truncate font-medium text-fg-default"
+});
+const schedulerEventTime = avatar.tv({
+  base: "shrink-0 tabular-nums text-fg-muted"
+});
+const schedulerEventDescription = avatar.tv({
+  base: "min-w-0 truncate text-caption-sm text-fg-muted"
+});
+const schedulerPlaceholder = avatar.tv({
+  base: [
+    "flex min-h-[320px] flex-1 flex-col items-center justify-center gap-gp-md",
+    "rounded-radius-xl border border-dashed border-border-input bg-bg-subtle dark:bg-bg-canvas",
+    "p-sp-3xl text-center"
+  ]
+});
+const VIEW_ITEMS = [
+  { value: "month", label: "Mês", icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CalendarDays, {}) },
+  { value: "week", label: "Semana", icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Columns3, {}) },
+  { value: "day", label: "Dia", icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Square, {}) },
+  { value: "list", label: "Lista", icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.List, {}) }
+];
+function SchedulerToolbar({
+  title: title2,
+  view,
+  onViewChange,
+  onPrev,
+  onNext,
+  onToday,
+  searchable,
+  search,
+  onSearchChange,
+  filterFields,
+  filterModel,
+  onClearField,
+  onClearAll,
+  appliedCount,
+  filterPanelOpen,
+  onToggleFilterPanel,
+  toolbarActions,
+  primaryAction
+}) {
+  const hasFilters = (filterFields?.length ?? 0) > 0;
+  const activeView = VIEW_ITEMS.find((v) => v.value === view) ?? VIEW_ITEMS[0];
+  const filterEngaged = filterPanelOpen || appliedCount > 0;
+  const appliedFields = (filterFields ?? []).filter(
+    (field) => (filterModel[field.id] ?? []).length > 0
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-gp-xl", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerToolbar(), children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerToolbarSide({ slot: "leading" }), children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerTitle(), children: title2 }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { role: "group", "aria-label": "Navegação de período", className: schedulerNavGroup(), children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            avatar.Button,
+            {
+              variant: "outline",
+              color: "secondary",
+              size: "icon-sm",
+              onClick: onPrev,
+              "aria-label": "Período anterior",
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronLeft, {})
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(avatar.Button, { variant: "outline", color: "secondary", size: "sm", onClick: onToday, children: "Hoje" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            avatar.Button,
+            {
+              variant: "outline",
+              color: "secondary",
+              size: "icon-sm",
+              onClick: onNext,
+              "aria-label": "Próximo período",
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, {})
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerToolbarSide({ slot: "trailing" }), children: [
+        searchable ? /* @__PURE__ */ jsxRuntime.jsxs("label", { className: schedulerSearch({ expanded: search !== "" }), children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Search, { "aria-hidden": "true" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "search",
+              value: search,
+              onChange: (e) => onSearchChange(e.target.value),
+              placeholder: "Buscar evento…",
+              "aria-label": "Buscar evento",
+              className: schedulerSearchInput()
+            }
+          )
+        ] }) : null,
+        toolbarActions,
+        /* @__PURE__ */ jsxRuntime.jsxs(avatar.DropdownMenu, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(avatar.DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+            avatar.Button,
+            {
+              variant: "outline",
+              color: "secondary",
+              size: "sm",
+              iconLeft: activeView.icon,
+              iconRight: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronDown, { className: "hidden lg:block" }),
+              "aria-label": `Visualização: ${activeView.label}`,
+              className: "shrink-0 max-lg:size-form-xl max-lg:p-0",
+              children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden lg:inline", children: activeView.label })
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(avatar.DropdownMenuContent, { align: "end", className: "min-w-[168px]", children: /* @__PURE__ */ jsxRuntime.jsx(
+            avatar.DropdownMenuRadioGroup,
+            {
+              value: view,
+              onValueChange: (v) => onViewChange(v),
+              children: VIEW_ITEMS.map((item) => /* @__PURE__ */ jsxRuntime.jsx(avatar.DropdownMenuRadioItem, { value: item.value, children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerViewMenuItem(), children: item.label }) }, item.value))
+            }
+          ) })
+        ] }),
+        hasFilters ? (
+          /* `relative` no wrapper e não no Button: o ponto é posicionado
+             contra a caixa do botão, e o Button não expõe `position`. */
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "relative shrink-0", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              avatar.Button,
+              {
+                variant: filterEngaged ? "soft" : "outline",
+                color: filterEngaged ? "primary" : "secondary",
+                size: "sm",
+                iconLeft: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ListFilter, {}),
+                onClick: onToggleFilterPanel,
+                "aria-expanded": filterPanelOpen,
+                className: avatar.cn(
+                  "max-lg:size-form-xl max-lg:p-0",
+                  filterEngaged && "border-border-brand hover:border-border-brand"
+                ),
+                "aria-label": "Filtro",
+                children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden lg:inline", children: "Filtro" })
+              }
+            ),
+            appliedCount > 0 ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerFilterDot(), "aria-hidden": "true" }) : null
+          ] })
+        ) : null,
+        primaryAction
+      ] })
+    ] }),
+    appliedFields.length > 0 ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerFilterRow(), children: [
+      appliedFields.map((field) => {
+        const selected = filterModel[field.id] ?? [];
+        const selectedLabels = field.options.filter((o) => selected.includes(o.value)).map((o) => o.label);
+        return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: schedulerFilterChip({ applied: true }), children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerFilterChipName(), children: field.label }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerFilterChipValue(), children: selectedLabels.length === 1 ? selectedLabels[0] : `${selectedLabels.length} selecionados` }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "aria-label": `Limpar filtro ${field.label}`,
+              onClick: () => onClearField(field.id),
+              className: "grid size-icon-sm shrink-0 place-items-center rounded-radius-full text-fg-subtle transition-colors duration-150 hover:text-fg-default focus-visible:outline-none focus-visible:ring-4 focus-visible:ring-ring-brand",
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { "aria-hidden": "true" })
+            }
+          )
+        ] }, field.id);
+      }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onClearAll,
+          className: avatar.cn(schedulerClearLink(), "shrink-0"),
+          children: "Limpar tudo"
+        }
+      )
+    ] }) : null
+  ] });
+}
+function buildMonthMatrix(date, weekStartsOn, locale) {
+  const monthStart = dateFns.startOfMonth(date);
+  const gridStart = dateFns.startOfWeek(monthStart, { weekStartsOn, locale });
+  const days = [];
+  for (let i = 0; i < 42; i++) {
+    days.push(dateFns.startOfDay(dateFns.addDays(gridStart, i)));
+  }
+  const weeks = [];
+  for (let row = 0; row < 6; row++) {
+    weeks.push(days.slice(row * 7, row * 7 + 7));
+  }
+  return weeks;
+}
+function segmentMultiDay(events, weekRows) {
+  const segments = [];
+  for (const event of events) {
+    const dayStart = dateFns.startOfDay(event.start);
+    const dayEnd = dateFns.startOfDay(event.end);
+    weekRows.forEach((row, weekIndex) => {
+      if (row.length === 0) return;
+      const rowStart = row[0];
+      const rowEnd = row[row.length - 1];
+      if (dayEnd.getTime() < rowStart.getTime() || dayStart.getTime() > rowEnd.getTime()) {
+        return;
+      }
+      const segStart = dayStart.getTime() > rowStart.getTime() ? dayStart : rowStart;
+      const segEnd = dayEnd.getTime() < rowEnd.getTime() ? dayEnd : rowEnd;
+      const colStart = dateFns.differenceInCalendarDays(segStart, rowStart);
+      const colSpan = dateFns.differenceInCalendarDays(segEnd, segStart) + 1;
+      segments.push({
+        event,
+        weekIndex,
+        colStart,
+        colSpan,
+        isStart: segStart.getTime() === dayStart.getTime(),
+        isEnd: segEnd.getTime() === dayEnd.getTime()
+      });
+    });
+  }
+  return segments;
+}
+function effectiveEndMs(event, snapMinutes) {
+  return event.start.getTime() === event.end.getTime() ? event.end.getTime() + snapMinutes * 6e4 : event.end.getTime();
+}
+function packLanes(events, snapMinutes) {
+  if (events.length === 0) return [];
+  const sorted = [...events].sort((a, b) => {
+    const startDiff = a.start.getTime() - b.start.getTime();
+    if (startDiff !== 0) return startDiff;
+    return effectiveEndMs(b, snapMinutes) - effectiveEndMs(a, snapMinutes);
+  });
+  const result = [];
+  let group = [];
+  let groupMaxEnd = -Infinity;
+  const flushGroup = () => {
+    if (group.length === 0) return;
+    const laneEnds = [];
+    const laneOf = /* @__PURE__ */ new Map();
+    for (const ev of group) {
+      const evEnd = effectiveEndMs(ev, snapMinutes);
+      const freeLane = laneEnds.findIndex((end) => end <= ev.start.getTime());
+      if (freeLane === -1) {
+        laneOf.set(ev, laneEnds.length);
+        laneEnds.push(evEnd);
+      } else {
+        laneOf.set(ev, freeLane);
+        laneEnds[freeLane] = evEnd;
+      }
+    }
+    const laneCount = laneEnds.length;
+    for (const ev of group) {
+      result.push({ event: ev, laneIndex: laneOf.get(ev), laneCount });
+    }
+    group = [];
+    groupMaxEnd = -Infinity;
+  };
+  for (const ev of sorted) {
+    const evStart = ev.start.getTime();
+    if (group.length > 0 && evStart >= groupMaxEnd) {
+      flushGroup();
+    }
+    group.push(ev);
+    groupMaxEnd = Math.max(groupMaxEnd, effectiveEndMs(ev, snapMinutes));
+  }
+  flushGroup();
+  return result;
+}
+const MONTH_PILL_HEIGHT_PX = 20;
+const MONTH_PILL_GAP_PX = 2;
+function computeOverflow(dayEvents, availableHeight) {
+  if (dayEvents.length === 0) {
+    return { visible: [], overflowCount: 0 };
+  }
+  const rawFit = Math.max(
+    0,
+    Math.floor(
+      (availableHeight + MONTH_PILL_GAP_PX) / (MONTH_PILL_HEIGHT_PX + MONTH_PILL_GAP_PX)
+    )
+  );
+  if (rawFit >= dayEvents.length) {
+    return { visible: dayEvents, overflowCount: 0 };
+  }
+  const visibleCount = Math.max(0, rawFit - 1);
+  return {
+    visible: dayEvents.slice(0, visibleCount),
+    overflowCount: dayEvents.length - visibleCount
+  };
+}
+function snapToGrid(date, snapMinutes, dayRange) {
+  const dayStart = dateFns.startOfDay(date);
+  const minutesSinceMidnight = (date.getTime() - dayStart.getTime()) / 6e4;
+  const snappedMinutes = Math.round(minutesSinceMidnight / snapMinutes) * snapMinutes;
+  const [rangeStartHour, rangeEndHour] = dayRange;
+  const rangeStartMin = rangeStartHour * 60;
+  const rangeEndMin = Math.min(rangeEndHour * 60, 24 * 60);
+  const clampedMinutes = Math.min(
+    Math.max(snappedMinutes, rangeStartMin),
+    rangeEndMin
+  );
+  const snapped = dateFns.addMinutes(dayStart, clampedMinutes);
+  const dayEnd = dateFns.endOfDay(date);
+  return snapped.getTime() > dayEnd.getTime() ? dayEnd : snapped;
+}
+function resolveResize(event, edge, deltaMin, snapMinutes) {
+  const snappedDelta = Math.round(deltaMin / snapMinutes) * snapMinutes;
+  if (edge === "start") {
+    const proposedStart = dateFns.addMinutes(event.start, snappedDelta);
+    const maxStart = dateFns.addMinutes(event.end, -snapMinutes);
+    const start = proposedStart.getTime() > maxStart.getTime() ? maxStart : proposedStart;
+    return { start, end: event.end };
+  }
+  const proposedEnd = dateFns.addMinutes(event.end, snappedDelta);
+  const minEnd = dateFns.addMinutes(event.start, snapMinutes);
+  const end = proposedEnd.getTime() < minEnd.getTime() ? minEnd : proposedEnd;
+  return { start: event.start, end };
+}
+function pixelsToMinutes(px, hourHeight) {
+  return px / hourHeight * 60;
+}
+function resolveMonthDrop(event, targetDay) {
+  const diasDeslocados = dateFns.differenceInCalendarDays(
+    dateFns.startOfDay(targetDay),
+    dateFns.startOfDay(event.start)
+  );
+  if (diasDeslocados === 0) {
+    return { start: event.start, end: event.end };
+  }
+  return {
+    start: dateFns.addDays(event.start, diasDeslocados),
+    end: dateFns.addDays(event.end, diasDeslocados)
+  };
+}
+function resolveTimeGridMove(event, dayDelta, minuteDelta, snapMinutes, dayRange) {
+  const duracaoMs = event.end.getTime() - event.start.getTime();
+  const bruto = dateFns.addMinutes(dateFns.addDays(event.start, dayDelta), minuteDelta);
+  const start = snapToGrid(bruto, snapMinutes, dayRange);
+  return { start, end: new Date(start.getTime() + duracaoMs) };
+}
+function minutesToOffset(date, dayRange, hourHeight) {
+  const gridStart = dateFns.addHours(dateFns.startOfDay(date), dayRange[0]);
+  const elapsedMinutes = (date.getTime() - gridStart.getTime()) / 6e4;
+  return elapsedMinutes / 60 * hourHeight;
+}
+function MiniMonth({
+  selected,
+  now,
+  locale,
+  weekStartsOn,
+  events,
+  onSelect
+}) {
+  const [offset, setOffset] = React.useState(0);
+  const cursor = React.useMemo(
+    () => dateFns.addMonths(dateFns.startOfDay(selected), offset),
+    [selected, offset]
+  );
+  const weeks = React.useMemo(
+    () => buildMonthMatrix(cursor, weekStartsOn, locale),
+    [cursor, weekStartsOn, locale]
+  );
+  const daysWithEvents = React.useMemo(() => {
+    const set = /* @__PURE__ */ new Set();
+    for (const ev of events) {
+      let cur = dateFns.startOfDay(ev.start);
+      const last = dateFns.startOfDay(ev.end);
+      let guard = 0;
+      while (cur.getTime() <= last.getTime() && guard < 400) {
+        set.add(cur.getTime());
+        cur = new Date(cur.getFullYear(), cur.getMonth(), cur.getDate() + 1);
+        guard++;
+      }
+    }
+    return set;
+  }, [events]);
+  const weekdayLabels = React.useMemo(
+    () => weeks[0].map((day) => dateFns.format(day, "EEEEE", { locale })),
+    [weeks, locale]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-gp-md", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerMiniHead(), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerMiniTitle(), children: dateFns.format(cursor, "MMMM yyyy", { locale }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex shrink-0 items-center", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          avatar.Button,
+          {
+            variant: "ghost",
+            color: "secondary",
+            size: "icon-2xs",
+            "aria-label": "Mês anterior",
+            onClick: () => setOffset((o) => o - 1),
+            children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronLeft, {})
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          avatar.Button,
+          {
+            variant: "ghost",
+            color: "secondary",
+            size: "icon-2xs",
+            "aria-label": "Próximo mês",
+            onClick: () => setOffset((o) => o + 1),
+            children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ChevronRight, {})
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerMiniGrid(), children: [
+      weekdayLabels.map((label, i) => /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerMiniWeekday(), children: label }, `${label}-${i}`)),
+      weeks.flat().map((day) => /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: () => {
+            onSelect(day);
+            setOffset(0);
+          },
+          "aria-label": dateFns.format(day, "PPPP", { locale }),
+          "aria-current": dateFns.isSameDay(day, selected) ? "date" : void 0,
+          className: schedulerMiniDay({
+            outside: !dateFns.isSameMonth(day, cursor),
+            hasEvents: daysWithEvents.has(day.getTime()),
+            today: dateFns.isSameDay(day, now),
+            selected: dateFns.isSameDay(day, selected)
+          }),
+          children: dateFns.format(day, "d", { locale })
+        },
+        day.getTime()
+      ))
+    ] })
+  ] });
+}
+function SchedulerFilterPanel({
+  filterFields,
+  filterModel,
+  onToggleValue,
+  onClearAll,
+  appliedCount,
+  onClose,
+  embedded = false,
+  counts,
+  date,
+  now,
+  locale,
+  weekStartsOn,
+  events,
+  onDateSelect
+}) {
+  const [collapsed, setCollapsed] = React.useState(() => /* @__PURE__ */ new Set());
+  const toggleGroup2 = (id) => setCollapsed((prev) => {
+    const next = new Set(prev);
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    return next;
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs("aside", { className: schedulerFilterAside({ embedded }), "aria-label": "Filtros do calendário", children: [
+    embedded ? null : /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerAsideSection({ compact: true, sticky: true }), children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerAsideHead(), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerAsideTitle(), children: "Filtros" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex shrink-0 items-center gap-gp-sm", children: [
+        appliedCount > 0 ? /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: onClearAll, className: schedulerClearLink(), children: "Limpar" }) : null,
+        /* @__PURE__ */ jsxRuntime.jsx(
+          avatar.Button,
+          {
+            variant: "ghost",
+            color: "secondary",
+            size: "icon-2xs",
+            "aria-label": "Fechar painel de filtros",
+            onClick: onClose,
+            children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, {})
+          }
+        )
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerAsideSection(), children: /* @__PURE__ */ jsxRuntime.jsx(
+      MiniMonth,
+      {
+        selected: date,
+        now,
+        locale,
+        weekStartsOn,
+        events,
+        onSelect: onDateSelect
+      }
+    ) }),
+    filterFields.map((field) => {
+      const selected = filterModel[field.id] ?? [];
+      const isOpen = !collapsed.has(field.id);
+      const fieldCounts = counts[field.id] ?? {};
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          className: avatar.cn(schedulerAsideSection(), schedulerGroup()),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(
+              "button",
+              {
+                type: "button",
+                "aria-expanded": isOpen,
+                onClick: () => toggleGroup2(field.id),
+                className: schedulerGroupHead(),
+                children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex min-w-0 items-baseline gap-gp-sm", children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: field.label }),
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerOptionCount(), children: selected.length === 0 ? "Todas" : selected.length })
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    lucideReact.ChevronDown,
+                    {
+                      className: schedulerGroupChevron({ open: isOpen }),
+                      "aria-hidden": "true"
+                    }
+                  )
+                ]
+              }
+            ),
+            isOpen ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col", children: field.options.map((option) => {
+              const id = `scheduler-filter-${field.id}-${option.value}`;
+              const isOn = selected.includes(option.value);
+              const count = fieldCounts[option.value];
+              return /* @__PURE__ */ jsxRuntime.jsxs("label", { htmlFor: id, className: schedulerOption(), children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  sheet.Checkbox,
+                  {
+                    id,
+                    checked: isOn,
+                    onCheckedChange: () => onToggleValue(field.id, option.value),
+                    className: schedulerOptionBox({
+                      color: option.color ?? "brand"
+                    })
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerOptionLabel(), children: option.label }),
+                count !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerOptionCount(), children: count }) : null
+              ] }, option.value);
+            }) }) : null
+          ]
+        },
+        field.id
+      );
+    })
+  ] });
+}
+const SchedulerEventItem = React.forwardRef(function SchedulerEventItem2({
+  event,
+  view,
+  variant,
+  truncateStart = false,
+  truncateEnd = false,
+  dragging = false,
+  disabled = false,
+  timeLabel,
+  style,
+  renderContent,
+  onClick,
+  className,
+  dragAttributes,
+  dragListeners,
+  setDragNodeRef,
+  dragTransform,
+  movable = false,
+  resizeHandles
+}, ref) {
+  const color = event.color ?? "brand";
+  const mergeRefs = (el) => {
+    setDragNodeRef?.(el);
+    if (typeof ref === "function") ref(el);
+    else if (ref) {
+      ref.current = el;
+    }
+  };
+  const estilo = {
+    ...style,
+    ...dragTransform ? { transform: `translate3d(${dragTransform.x}px, ${dragTransform.y}px, 0)` } : null
+  };
+  const ariaLabel = [
+    typeof event.title === "string" ? event.title : event.searchText,
+    timeLabel
+  ].filter(Boolean).join(", ");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      ref: mergeRefs,
+      type: "button",
+      disabled,
+      style: estilo,
+      "aria-label": ariaLabel || void 0,
+      onClick: (evt) => onClick?.(evt),
+      ...dragAttributes,
+      ...dragListeners,
+      className: avatar.cn(
+        schedulerEvent({
+          color,
+          variant,
+          truncateStart,
+          truncateEnd,
+          dragging,
+          // `movable` só pinta em REPOUSO: durante o arraste o `dragging` manda,
+          // e ele desliga a transição de propósito (ver nota no styles).
+          movable: movable && !dragging,
+          disabled
+        }),
+        className
+      ),
+      children: [
+        renderContent ? renderContent() : variant === "row" ? (
+          /* `row` é a única forma com espaço pra 2 linhas — a descrição só
+             aparece aqui. No pill de 20px ela não caberia, e no block ela
+             competiria com o título quando a duração é curta. */
+          /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: schedulerEventDot({ color, size: "md" }),
+                "aria-hidden": "true"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex min-w-0 flex-1 flex-col", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerEventTitle(), children: event.title }),
+              event.description ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerEventDescription(), children: event.description }) : null
+            ] }),
+            timeLabel ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerEventTime(), children: timeLabel }) : null
+          ] })
+        ) : variant === "block" ? (
+          /* No block o horário vem ANTES do título e em linha própria: o bloco
+             tem altura proporcional à duração, e num evento longo o título
+             sozinho no topo deixaria o horário fora do campo de leitura. */
+          /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            timeLabel ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: avatar.cn(schedulerEventTime(), "text-caption-xs"), children: timeLabel }) : null,
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: avatar.cn(schedulerEventTitle(), "w-full"), children: event.title })
+          ] })
+        ) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          !truncateStart ? /* @__PURE__ */ jsxRuntime.jsx(
+            "span",
+            {
+              className: schedulerEventDot({ color, size: "sm" }),
+              "aria-hidden": "true"
+            }
+          ) : null,
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerEventTitle(), children: event.title }),
+          timeLabel && view === "month" ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerEventTime(), children: timeLabel }) : null
+        ] }),
+        resizeHandles
+      ]
+    }
+  );
+});
+const MOVE_PREFIX = "move:";
+const RESIZE_PREFIX = "resize:";
+const DAY_PREFIX = "day:";
+const draggableIdForMove = (eventId) => `${MOVE_PREFIX}${eventId}`;
+const draggableIdForResize = (eventId, edge) => `${RESIZE_PREFIX}${eventId}:${edge}`;
+const droppableIdForDay = (day) => `${DAY_PREFIX}${dateFns.startOfDay(day).getTime()}`;
+function parseDayDroppable(overId) {
+  if (!overId || !overId.startsWith(DAY_PREFIX)) return null;
+  const ms = Number(overId.slice(DAY_PREFIX.length));
+  return Number.isFinite(ms) ? new Date(ms) : null;
+}
+function parseDraggable(activeId) {
+  if (activeId.startsWith(MOVE_PREFIX)) {
+    return { kind: "move", eventId: activeId.slice(MOVE_PREFIX.length) };
+  }
+  if (activeId.startsWith(RESIZE_PREFIX)) {
+    const resto = activeId.slice(RESIZE_PREFIX.length);
+    const corte = resto.lastIndexOf(":");
+    if (corte < 0) return null;
+    const edge = resto.slice(corte + 1);
+    if (edge !== "start" && edge !== "end") return null;
+    return { kind: "resize", eventId: resto.slice(0, corte), edge };
+  }
+  return null;
+}
+function useSchedulerDnd({
+  enabled,
+  view,
+  events,
+  snapMinutes,
+  dayRange,
+  hourHeight,
+  draggable,
+  resizable,
+  onEventMove,
+  onEventResize
+}) {
+  const [ativo, setAtivo] = React.useState(null);
+  const [diaSobreposto, setDiaSobreposto] = React.useState(null);
+  const sensors = core.useSensors(
+    core.useSensor(core.PointerSensor, { activationConstraint: { distance: 6 } })
+  );
+  const porId = React.useMemo(() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const e of events) m.set(e.id, e);
+    return m;
+  }, [events]);
+  const podeMover = React.useCallback(
+    (e) => enabled && (e.draggable ?? draggable),
+    [enabled, draggable]
+  );
+  const podeRedimensionar = React.useCallback(
+    (e) => (
+      // Resize só existe onde há eixo de tempo. No mês a altura da pílula não
+      // representa duração, então arrastar a borda não teria o que significar.
+      enabled && view !== "month" && view !== "list" && (e.resizable ?? resizable) && !e.allDay
+    ),
+    [enabled, view, resizable]
+  );
+  const handleDragStart = React.useCallback((evt) => {
+    const parsed = parseDraggable(String(evt.active.id));
+    if (parsed) setAtivo(parsed);
+  }, []);
+  const handleDragOver = React.useCallback((evt) => {
+    const dia = parseDayDroppable(evt.over ? String(evt.over.id) : null);
+    setDiaSobreposto(dia ? dia.getTime() : null);
+  }, []);
+  const handleDragCancel = React.useCallback(() => {
+    setAtivo(null);
+    setDiaSobreposto(null);
+  }, []);
+  const handleDragEnd = React.useCallback(
+    (evt) => {
+      setAtivo(null);
+      setDiaSobreposto(null);
+      const atual = parseDraggable(String(evt.active.id));
+      if (!atual) return;
+      if (!enabled) return;
+      const evento = porId.get(atual.eventId);
+      if (!evento) return;
+      if (atual.kind === "resize") {
+        if (!podeRedimensionar(evento)) return;
+        const minutos = pixelsToMinutes(evt.delta.y, hourHeight);
+        if (Math.abs(minutos) < 1) return;
+        const r = resolveResize(evento, atual.edge, minutos, snapMinutes);
+        if (r.start.getTime() === evento.start.getTime() && r.end.getTime() === evento.end.getTime()) {
+          return;
+        }
+        onEventResize?.({ id: evento.id, start: r.start, end: r.end });
+        return;
+      }
+      if (!podeMover(evento)) return;
+      const diaAlvo = parseDayDroppable(evt.over ? String(evt.over.id) : null);
+      if (view === "month") {
+        if (!diaAlvo) return;
+        const r = resolveMonthDrop(evento, diaAlvo);
+        if (r.start.getTime() === evento.start.getTime()) return;
+        onEventMove?.({ id: evento.id, start: r.start, end: r.end });
+        return;
+      }
+      if (view === "week" || view === "day") {
+        const deslocamentoDeDias = diaAlvo ? dateFns.differenceInCalendarDays(diaAlvo, dateFns.startOfDay(evento.start)) : 0;
+        const minutos = evento.allDay ? 0 : pixelsToMinutes(evt.delta.y, hourHeight);
+        if (deslocamentoDeDias === 0 && Math.abs(minutos) < 1) return;
+        const r = resolveTimeGridMove(
+          evento,
+          deslocamentoDeDias,
+          minutos,
+          snapMinutes,
+          dayRange
+        );
+        if (r.start.getTime() === evento.start.getTime() && r.end.getTime() === evento.end.getTime()) {
+          return;
+        }
+        onEventMove?.({ id: evento.id, start: r.start, end: r.end });
+      }
+    },
+    [
+      enabled,
+      porId,
+      view,
+      hourHeight,
+      snapMinutes,
+      dayRange,
+      podeMover,
+      podeRedimensionar,
+      onEventMove,
+      onEventResize
+    ]
+  );
+  return {
+    sensors,
+    /** `move:<id>` ou `resize:<id>:<edge>` em andamento, pra pintar o estado. */
+    dragAtivo: ativo,
+    /** `getTime()` do dia sob o cursor — a célula/coluna se pinta com isso. */
+    diaSobreposto,
+    podeMover,
+    podeRedimensionar,
+    handleDragStart,
+    handleDragOver,
+    handleDragEnd,
+    handleDragCancel
+  };
+}
+function ResizeHandle({
+  eventId,
+  edge,
+  label
+}) {
+  const { attributes, listeners, setNodeRef } = core.useDraggable({
+    id: draggableIdForResize(eventId, edge)
+  });
+  return (
+    /* `<span role="button">` e não `<button>`: a alça vive DENTRO do botão do
+       evento, e botão dentro de botão é HTML inválido — o navegador quebra a
+       árvore e o clique do evento para de funcionar. */
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "span",
+      {
+        ref: setNodeRef,
+        ...attributes,
+        ...listeners,
+        role: "button",
+        tabIndex: -1,
+        "aria-label": label,
+        className: schedulerResizeHandle({ edge }),
+        onClick: (e) => e.stopPropagation(),
+        onPointerDown: (e) => {
+          e.stopPropagation();
+          listeners?.onPointerDown?.(e);
+        }
+      }
+    )
+  );
+}
+function DraggableEvent({
+  movable = false,
+  resizable = false,
+  ...rest
+}) {
+  const { attributes, listeners, setNodeRef, isDragging } = core.useDraggable({
+    id: draggableIdForMove(rest.event.id),
+    disabled: !movable
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SchedulerEventItem,
+    {
+      ...rest,
+      movable,
+      dragging: isDragging,
+      setDragNodeRef: setNodeRef,
+      dragTransform: null,
+      dragAttributes: movable ? { ...attributes } : void 0,
+      dragListeners: movable ? { ...listeners } : void 0,
+      resizeHandles: resizable && !isDragging ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ResizeHandle,
+          {
+            eventId: rest.event.id,
+            edge: "start",
+            label: "Ajustar início"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ResizeHandle,
+          {
+            eventId: rest.event.id,
+            edge: "end",
+            label: "Ajustar fim"
+          }
+        )
+      ] }) : null
+    }
+  );
+}
+function DroppableDay({
+  day,
+  disabled,
+  className,
+  overClassName,
+  children,
+  cellRef,
+  ...rest
+}) {
+  const { setNodeRef, isOver } = core.useDroppable({
+    id: droppableIdForDay(day),
+    disabled
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: (el) => {
+        setNodeRef(el);
+        cellRef?.(el);
+      },
+      className: avatar.cn(className, isOver && !disabled && overClassName),
+      ...rest,
+      children
+    }
+  );
+}
+function useSchedulerKeyboard({
+  count,
+  columns,
+  onActivate,
+  enabled = true
+}) {
+  const [ativo, setAtivo] = React.useState(0);
+  const [moveuPorTeclado, setMoveuPorTeclado] = React.useState(false);
+  const refs = React.useRef([]);
+  React.useEffect(() => {
+    if (ativo > count - 1) setAtivo(Math.max(0, count - 1));
+  }, [count, ativo]);
+  React.useEffect(() => {
+    if (!moveuPorTeclado) return;
+    refs.current[ativo]?.focus();
+    setMoveuPorTeclado(false);
+  }, [ativo, moveuPorTeclado]);
+  const registrarRef = React.useCallback(
+    (index) => (el) => {
+      refs.current[index] = el;
+    },
+    []
+  );
+  const handleKeyDown = React.useCallback(
+    (index) => (e) => {
+      if (!enabled) return;
+      const irPara = (proximo) => {
+        e.preventDefault();
+        setAtivo(Math.min(count - 1, Math.max(0, proximo)));
+        setMoveuPorTeclado(true);
+      };
+      switch (e.key) {
+        case "ArrowRight":
+          return irPara(index + 1);
+        case "ArrowLeft":
+          return irPara(index - 1);
+        case "ArrowDown":
+          return irPara(index + columns);
+        case "ArrowUp":
+          return irPara(index - columns);
+        case "Home":
+          return irPara(index - index % columns);
+        case "End":
+          return irPara(index - index % columns + (columns - 1));
+        case "PageUp":
+          return irPara(0);
+        case "PageDown":
+          return irPara(count - 1);
+        case "Enter":
+        case " ":
+          e.preventDefault();
+          onActivate?.(index);
+          return;
+        default:
+          return;
+      }
+    },
+    [enabled, count, columns, onActivate]
+  );
+  const getCellProps = React.useCallback(
+    (index) => ({
+      tabIndex: enabled && index === ativo ? 0 : -1,
+      onKeyDown: handleKeyDown(index),
+      onFocus: () => setAtivo(index)
+    }),
+    [enabled, ativo, handleKeyDown]
+  );
+  const getCellRef = React.useCallback(
+    (index) => registrarRef(index),
+    [registrarRef]
+  );
+  return { activeIndex: ativo, getCellProps, getCellRef };
+}
+const CELL_CHROME_PX = 24 + 4 + 2;
+const FALLBACK_ROW_HEIGHT_PX = 96;
+function SchedulerMonthView({
+  date,
+  events,
+  locale,
+  weekStartsOn,
+  hourFormat,
+  now,
+  maxPerCell,
+  onEventClick,
+  onSlotClick,
+  renderEvent,
+  dndAtivo = false,
+  podeMover
+}) {
+  const weeks = React.useMemo(
+    () => buildMonthMatrix(date, weekStartsOn, locale),
+    [date, weekStartsOn, locale]
+  );
+  const teclado = useSchedulerKeyboard({
+    count: weeks.length * 7,
+    columns: 7,
+    onActivate: (index) => {
+      const dia = weeks[Math.floor(index / 7)]?.[index % 7];
+      if (dia) onSlotClick?.(dateFns.startOfDay(dia), dateFns.startOfDay(dia));
+    }
+  });
+  const gridRef = React.useRef(null);
+  const [rowHeight, setRowHeight] = React.useState(FALLBACK_ROW_HEIGHT_PX);
+  React.useLayoutEffect(() => {
+    const el = gridRef.current;
+    if (!el) return;
+    const medir = () => {
+      const altura = el.getBoundingClientRect().height;
+      if (altura > 0) setRowHeight(altura / weeks.length);
+    };
+    medir();
+    if (typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(medir);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [weeks.length]);
+  const alturaDisponivel = Math.max(0, rowHeight - CELL_CHROME_PX);
+  const segments = React.useMemo(
+    () => segmentMultiDay(events, weeks),
+    [events, weeks]
+  );
+  const byDay = React.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const seg of segments) {
+      const row = weeks[seg.weekIndex];
+      for (let i = 0; i < seg.colSpan; i++) {
+        const day = row[seg.colStart + i];
+        if (!day) continue;
+        const key = day.getTime();
+        const isFirstOfSegment = i === 0;
+        const isLastOfSegment = i === seg.colSpan - 1;
+        const list = map.get(key) ?? [];
+        list.push({
+          event: seg.event,
+          // A ponta só é "de verdade" quando é a ponta do segmento E a ponta
+          // do evento: um evento que vem da semana anterior chega com
+          // `isStart: false` e nunca ganha canto arredondado à esquerda.
+          truncateStart: !(isFirstOfSegment && seg.isStart),
+          truncateEnd: !(isLastOfSegment && seg.isEnd)
+        });
+        map.set(key, list);
+      }
+    }
+    for (const list of map.values()) {
+      list.sort((a, b) => a.event.start.getTime() - b.event.start.getTime());
+    }
+    return map;
+  }, [segments, weeks]);
+  const weekdayLabels = React.useMemo(
+    () => weeks[0].map((day) => dateFns.format(day, "EEEEEE", { locale })),
+    [weeks, locale]
+  );
+  const timeLabelOf = (event) => {
+    if (event.allDay) return void 0;
+    return dateFns.format(event.start, hourFormat === "12h" ? "h:mm a" : "HH:mm", {
+      locale
+    });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerMonthFrame(), children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerWeekdayRow(), children: weekdayLabels.map((label, i) => /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerWeekdayCell(), children: label }, `${label}-${i}`)) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: gridRef, role: "grid", className: schedulerMonthGrid(), children: weeks.map(
+      (week, weekIndex) => week.map((day) => {
+        const dayEvents = byDay.get(day.getTime()) ?? [];
+        const todos = dayEvents.map((d) => d.event);
+        const { visible, overflowCount } = maxPerCell !== void 0 ? {
+          visible: todos.slice(
+            0,
+            todos.length <= maxPerCell ? maxPerCell : Math.max(0, maxPerCell - 1)
+          ),
+          overflowCount: todos.length <= maxPerCell ? 0 : todos.length - Math.max(0, maxPerCell - 1)
+        } : computeOverflow(todos, alturaDisponivel);
+        const outside = !dateFns.isSameMonth(day, date);
+        const today = dateFns.isSameDay(day, now);
+        const indiceDaCelula = weekIndex * 7 + week.indexOf(day);
+        return /* @__PURE__ */ jsxRuntime.jsxs(
+          DroppableDay,
+          {
+            day,
+            disabled: !dndAtivo,
+            className: schedulerMonthCell({
+              outside,
+              lastRow: weekIndex === weeks.length - 1,
+              interactive: Boolean(onSlotClick)
+            }),
+            overClassName: schedulerDropTarget(),
+            role: "gridcell",
+            "aria-label": dateFns.format(day, "PPPP", { locale }),
+            ...teclado.getCellProps(indiceDaCelula),
+            cellRef: teclado.getCellRef(indiceDaCelula),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerDayHead(), children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerDayNumber({ today, outside }), children: dateFns.format(day, "d", { locale }) }),
+                onSlotClick ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: schedulerSlotAdd(),
+                    "aria-label": `Criar evento em ${dateFns.format(day, "PPP", { locale })}`,
+                    tabIndex: -1,
+                    onClick: () => (
+                      // Dia inteiro: quem cria decide a hora no formulário.
+                      // Emitir 00:00–23:59 seria inventar uma duração que o
+                      // usuário não pediu.
+                      onSlotClick(dateFns.startOfDay(day), dateFns.startOfDay(day))
+                    ),
+                    children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { "aria-hidden": "true" })
+                  }
+                ) : null
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerCellEvents(), children: [
+                visible.map((event) => {
+                  const meta = dayEvents.find((d) => d.event.id === event.id);
+                  return /* @__PURE__ */ jsxRuntime.jsx(
+                    DraggableEvent,
+                    {
+                      event,
+                      view: "month",
+                      variant: "pill",
+                      movable: podeMover?.(event) ?? false,
+                      truncateStart: meta?.truncateStart,
+                      truncateEnd: meta?.truncateEnd,
+                      timeLabel: timeLabelOf(event),
+                      onClick: (evt) => onEventClick?.(event, evt),
+                      renderContent: renderEvent ? () => renderEvent({
+                        event,
+                        view: "month",
+                        selected: false
+                      }) : void 0
+                    },
+                    `${event.id}-${day.getTime()}`
+                  );
+                }),
+                overflowCount > 0 ? /* @__PURE__ */ jsxRuntime.jsxs(avatar.Popover, { children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(avatar.PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsxs("button", { type: "button", className: schedulerOverflowButton(), children: [
+                    "+",
+                    overflowCount,
+                    " mais"
+                  ] }) }),
+                  /* @__PURE__ */ jsxRuntime.jsx(avatar.PopoverContent, { align: "start", className: "p-0", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerOverflowPanel(), children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerOverflowPanelTitle(), children: dateFns.format(day, "EEEE, d 'de' MMMM", { locale }) }),
+                    dayEvents.map((d) => /* @__PURE__ */ jsxRuntime.jsx(
+                      SchedulerEventItem,
+                      {
+                        event: d.event,
+                        view: "month",
+                        variant: "row",
+                        timeLabel: timeLabelOf(d.event),
+                        onClick: (evt) => onEventClick?.(d.event, evt)
+                      },
+                      `overflow-${d.event.id}`
+                    ))
+                  ] }) })
+                ] }) : null
+              ] })
+            ]
+          },
+          day.getTime()
+        );
+      })
+    ) })
+  ] });
+}
+const HOUR_HEIGHT_PX = 48;
+const MIN_BLOCK_PX = 22;
+function SchedulerTimeGrid({
+  date,
+  view,
+  events,
+  locale,
+  weekStartsOn,
+  hourFormat,
+  dayRange,
+  scrollToHour,
+  nowIndicator,
+  now,
+  snapMinutes,
+  onEventClick,
+  onSlotClick,
+  renderEvent,
+  dndAtivo = false,
+  podeMover,
+  podeRedimensionar
+}) {
+  const bodyRef = React.useRef(null);
+  const days = React.useMemo(() => {
+    if (view === "day") return [dateFns.startOfDay(date)];
+    const first = dateFns.startOfWeek(date, { weekStartsOn, locale });
+    return Array.from({ length: 7 }, (_, i) => dateFns.startOfDay(dateFns.addDays(first, i)));
+  }, [date, view, weekStartsOn, locale]);
+  const [rangeStart, rangeEnd] = dayRange;
+  const hours = React.useMemo(
+    () => Array.from({ length: Math.max(1, rangeEnd - rangeStart) }, (_, i) => rangeStart + i),
+    [rangeStart, rangeEnd]
+  );
+  const teclado = useSchedulerKeyboard({
+    count: hours.length * days.length,
+    columns: days.length,
+    onActivate: (index) => {
+      const hora = hours[Math.floor(index / days.length)];
+      const dia = days[index % days.length];
+      if (hora === void 0 || !dia) return;
+      const start = new Date(dia);
+      start.setHours(hora, 0, 0, 0);
+      const end = new Date(start);
+      end.setHours(hora + 1, 0, 0, 0);
+      onSlotClick?.(start, end);
+    },
+    enabled: Boolean(onSlotClick)
+  });
+  React.useEffect(() => {
+    const el = bodyRef.current;
+    if (!el) return;
+    const target = (scrollToHour - rangeStart) * HOUR_HEIGHT_PX;
+    el.scrollTop = Math.max(0, target);
+  }, [scrollToHour, rangeStart]);
+  const fmtHour = (hour) => {
+    const d = new Date(2e3, 0, 1, hour % 24, 0);
+    return dateFns.format(d, hourFormat === "12h" ? "h a" : "HH:mm", { locale });
+  };
+  const fmtTime = (d) => dateFns.format(d, hourFormat === "12h" ? "h:mm a" : "HH:mm", { locale });
+  const allDayByDay = React.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const day of days) map.set(day.getTime(), []);
+    for (const ev of events) {
+      if (!ev.allDay) continue;
+      for (const day of days) {
+        if (dateFns.startOfDay(ev.start).getTime() <= day.getTime() && dateFns.startOfDay(ev.end).getTime() >= day.getTime()) {
+          map.get(day.getTime())?.push(ev);
+        }
+      }
+    }
+    return map;
+  }, [events, days]);
+  const hasAllDay = React.useMemo(
+    () => [...allDayByDay.values()].some((list) => list.length > 0),
+    [allDayByDay]
+  );
+  const blocksByDay = React.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const day of days) {
+      const dayStart = dateFns.startOfDay(day);
+      const dayEnd = dateFns.endOfDay(day);
+      const gridTop = new Date(dayStart.getTime() + rangeStart * 36e5);
+      const gridBottom = new Date(dayStart.getTime() + rangeEnd * 36e5);
+      const doDia = events.filter(
+        (ev) => !ev.allDay && ev.start.getTime() < gridBottom.getTime() && ev.end.getTime() > gridTop.getTime() && ev.start.getTime() <= dayEnd.getTime() && ev.end.getTime() >= dayStart.getTime()
+      );
+      const recortados = doDia.map((ev) => ({
+        original: ev,
+        clamped: {
+          ...ev,
+          start: ev.start.getTime() < gridTop.getTime() ? gridTop : ev.start,
+          end: ev.end.getTime() > gridBottom.getTime() ? gridBottom : ev.end
+        }
+      }));
+      const lanes = packLanes(
+        recortados.map((r) => r.clamped),
+        snapMinutes
+      );
+      map.set(
+        day.getTime(),
+        lanes.map((box) => {
+          const original = recortados.find((r) => r.clamped.id === box.event.id)?.original ?? box.event;
+          const top = minutesToOffset(box.event.start, dayRange, HOUR_HEIGHT_PX);
+          const rawHeight = (box.event.end.getTime() - box.event.start.getTime()) / 36e5 * HOUR_HEIGHT_PX;
+          return {
+            event: original,
+            top,
+            height: Math.max(MIN_BLOCK_PX, rawHeight),
+            left: `${box.laneIndex / box.laneCount * 100}%`,
+            width: `${1 / box.laneCount * 100}%`,
+            // O rótulo mostra o horário REAL do evento, não o recortado — quem
+            // vê "22:00" num bloco que começa no topo da grade entende que ele
+            // vem de antes; ver "00:00" seria mentira.
+            label: `${fmtTime(original.start)}`
+          };
+        })
+      );
+    }
+    return map;
+  }, [events, days, dayRange, rangeStart, rangeEnd, snapMinutes, hourFormat, locale]);
+  const nowOffset = React.useMemo(() => {
+    if (!nowIndicator) return null;
+    const visivel = days.some((d) => dateFns.isSameDay(d, now));
+    if (!visivel) return null;
+    const offset = minutesToOffset(now, dayRange, HOUR_HEIGHT_PX);
+    const total = hours.length * HOUR_HEIGHT_PX;
+    if (offset < 0 || offset > total) return null;
+    return offset;
+  }, [nowIndicator, days, now, dayRange, hours.length]);
+  const isWeekend = (d) => d.getDay() === 0 || d.getDay() === 6;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerTimeFrame(), children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerTimeHead(), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerTimeGutter() }),
+      days.map((day) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          className: schedulerTimeHeadDay({ weekend: isWeekend(day) }),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerTimeHeadWeekday(), children: dateFns.format(day, view === "day" ? "EEEE" : "EEEEEE", { locale }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: schedulerDayNumber({ today: dateFns.isSameDay(day, now) }),
+                children: dateFns.format(day, "d", { locale })
+              }
+            )
+          ]
+        },
+        day.getTime()
+      ))
+    ] }),
+    hasAllDay ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerAllDayRow(), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerAllDayLabel(), children: "Dia inteiro" }),
+      days.map((day) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerAllDayCell(), children: (allDayByDay.get(day.getTime()) ?? []).map((ev) => /* @__PURE__ */ jsxRuntime.jsx(
+        DraggableEvent,
+        {
+          event: ev,
+          view,
+          variant: "pill",
+          movable: podeMover?.(ev) ?? false,
+          truncateStart: dateFns.startOfDay(ev.start).getTime() < day.getTime(),
+          truncateEnd: dateFns.startOfDay(ev.end).getTime() > day.getTime(),
+          onClick: (evt) => onEventClick?.(ev, evt),
+          renderContent: renderEvent ? () => renderEvent({ event: ev, view, selected: false }) : void 0
+        },
+        `${ev.id}-${day.getTime()}`
+      )) }, day.getTime()))
+    ] }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: bodyRef, className: schedulerTimeBody(), children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerTimeCanvas(), children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `${schedulerTimeGutter()} relative`, children: [
+        hours.map((h) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerHourLabel(), children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerHourLabelText(), children: fmtHour(h) }) }, h)),
+        nowOffset !== null ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerNowLabel(), style: { top: nowOffset }, children: fmtTime(now) }) : null
+      ] }),
+      days.map((day, indiceDaColuna) => /* @__PURE__ */ jsxRuntime.jsxs(
+        DroppableDay,
+        {
+          day,
+          disabled: !dndAtivo,
+          className: schedulerTimeColumn({ weekend: isWeekend(day) }),
+          overClassName: schedulerDropTarget(),
+          children: [
+            hours.map((h, indiceHora) => /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                className: schedulerHourSlot(),
+                "aria-label": `Criar evento em ${dateFns.format(day, "PPP", { locale })} às ${fmtHour(h)}`,
+                onClick: () => {
+                  const start = new Date(day);
+                  start.setHours(h, 0, 0, 0);
+                  const end = new Date(start);
+                  end.setHours(h + 1, 0, 0, 0);
+                  onSlotClick?.(start, end);
+                },
+                disabled: !onSlotClick,
+                ref: teclado.getCellRef(
+                  indiceHora * days.length + indiceDaColuna
+                ),
+                ...teclado.getCellProps(
+                  indiceHora * days.length + indiceDaColuna
+                )
+              },
+              h
+            )),
+            (blocksByDay.get(day.getTime()) ?? []).map((b) => /* @__PURE__ */ jsxRuntime.jsx(
+              DraggableEvent,
+              {
+                event: b.event,
+                view,
+                variant: "block",
+                movable: podeMover?.(b.event) ?? false,
+                resizable: podeRedimensionar?.(b.event) ?? false,
+                timeLabel: b.label,
+                style: {
+                  top: b.top,
+                  height: b.height,
+                  left: b.left,
+                  width: b.width,
+                  // 2px de folga à direita pra dois blocos vizinhos não
+                  // encostarem; `width` já é a fração da lane.
+                  paddingRight: void 0
+                },
+                className: "mr-[2px]",
+                onClick: (evt) => onEventClick?.(b.event, evt),
+                renderContent: renderEvent ? () => renderEvent({ event: b.event, view, selected: false }) : void 0
+              },
+              b.event.id
+            )),
+            nowOffset !== null && dateFns.isSameDay(day, now) ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: schedulerNowLine(), style: { top: nowOffset }, children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerNowDot(), "aria-hidden": "true" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerNowStroke(), "aria-hidden": "true" })
+            ] }) : null
+          ]
+        },
+        day.getTime()
+      ))
+    ] }) })
+  ] });
+}
+function SchedulerListView({
+  date,
+  events,
+  locale,
+  hourFormat,
+  now,
+  onEventClick,
+  renderEvent,
+  emptyState
+}) {
+  const grupos = React.useMemo(() => {
+    const inicio = dateFns.startOfMonth(date).getTime();
+    const fim = dateFns.endOfMonth(date).getTime();
+    const map = /* @__PURE__ */ new Map();
+    for (const ev of events) {
+      let cursor = dateFns.startOfDay(ev.start);
+      const ultimo = dateFns.startOfDay(ev.end);
+      let guard = 0;
+      while (cursor.getTime() <= ultimo.getTime() && guard < 400) {
+        const t = cursor.getTime();
+        if (t >= inicio && t <= fim) {
+          const lista = map.get(t) ?? [];
+          lista.push(ev);
+          map.set(t, lista);
+        }
+        cursor = new Date(
+          cursor.getFullYear(),
+          cursor.getMonth(),
+          cursor.getDate() + 1
+        );
+        guard++;
+      }
+    }
+    return [...map.entries()].sort(([a], [b]) => a - b).map(([t, lista]) => ({
+      dia: new Date(t),
+      // Dia inteiro primeiro, depois por horário — é a ordem em que o dia
+      // acontece: o que vale pro dia todo emoldura o resto.
+      eventos: lista.sort((x, y) => {
+        if (!!x.allDay !== !!y.allDay) return x.allDay ? -1 : 1;
+        return x.start.getTime() - y.start.getTime();
+      })
+    }));
+  }, [events, date]);
+  const fmtTime = (d) => dateFns.format(d, hourFormat === "12h" ? "h:mm a" : "HH:mm", { locale });
+  const rotuloHorario = (ev) => {
+    if (ev.allDay) return "Dia inteiro";
+    if (ev.start.getTime() === ev.end.getTime()) return fmtTime(ev.start);
+    return `${fmtTime(ev.start)} – ${fmtTime(ev.end)}`;
+  };
+  if (grupos.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerPlaceholder(), children: emptyState ?? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        lucideReact.CalendarSearch,
+        {
+          className: "size-icon-xl text-fg-subtle",
+          "aria-hidden": "true"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-body-md font-semibold text-fg-default", children: [
+        "Nenhum evento em ",
+        dateFns.format(date, "MMMM 'de' yyyy", { locale })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "max-w-[42ch] text-body-sm text-fg-muted", children: "Ajuste a busca ou os filtros, ou navegue pra outro mês." })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerListFrame(), children: grupos.map(({ dia, eventos }) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerListDay(), children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerListDayHead(), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerListDayNumber({ today: dateFns.isSameDay(dia, now) }), children: dateFns.format(dia, "d", { locale }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: schedulerListDayName(), children: dateFns.format(dia, "EEEE, MMMM", { locale }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerListEvents(), children: eventos.map((ev) => /* @__PURE__ */ jsxRuntime.jsx(
+      SchedulerEventItem,
+      {
+        event: ev,
+        view: "list",
+        variant: "row",
+        timeLabel: rotuloHorario(ev),
+        onClick: (evt) => onEventClick?.(ev, evt),
+        renderContent: renderEvent ? () => renderEvent({ event: ev, view: "list", selected: false }) : void 0
+      },
+      `${ev.id}-${dia.getTime()}`
+    )) })
+  ] }, dia.getTime())) });
+}
+function matchesField(event, fieldId, values) {
+  if (values.length === 0) return true;
+  switch (fieldId) {
+    case "categoryId":
+      return event.categoryId !== void 0 && values.includes(event.categoryId);
+    case "tagIds":
+      return (event.tagIds ?? []).some((tag) => values.includes(tag));
+    case "color":
+      return values.includes(event.color ?? "brand");
+    default:
+      return true;
+  }
+}
+function matchesSearch(event, term) {
+  if (term === "") return true;
+  const haystack = [];
+  if (event.searchText) haystack.push(event.searchText);
+  if (typeof event.title === "string") haystack.push(event.title);
+  if (typeof event.description === "string") haystack.push(event.description);
+  if (event.tagIds?.length) haystack.push(...event.tagIds);
+  return haystack.some((piece) => piece.toLowerCase().includes(term));
+}
+function useSchedulerFilter({
+  events,
+  searchable,
+  search: searchProp,
+  onSearchChange,
+  filterFields,
+  filterModel: modelProp,
+  onFilterModelChange,
+  filterMode
+}) {
+  const isSearchControlled = searchProp !== void 0;
+  const isModelControlled = modelProp !== void 0;
+  const [searchState, setSearchState] = React.useState("");
+  const [modelState, setModelState] = React.useState({});
+  const search = isSearchControlled ? searchProp : searchState;
+  const filterModel = isModelControlled ? modelProp : modelState;
+  React.useRef(false);
+  React.useEffect(() => {
+    return;
+  }, [filterFields, filterMode]);
+  const commitSearch = React.useCallback(
+    (next) => {
+      if (!isSearchControlled) setSearchState(next);
+      onSearchChange?.(next);
+    },
+    [isSearchControlled, onSearchChange]
+  );
+  const commitModel = React.useCallback(
+    (next) => {
+      if (!isModelControlled) setModelState(next);
+      onFilterModelChange?.(next);
+    },
+    [isModelControlled, onFilterModelChange]
+  );
+  const toggleValue = React.useCallback(
+    (fieldId, value) => {
+      const current = filterModel[fieldId] ?? [];
+      const nextValues = current.includes(value) ? current.filter((v) => v !== value) : [...current, value];
+      const next = { ...filterModel };
+      if (nextValues.length === 0) {
+        delete next[fieldId];
+      } else {
+        next[fieldId] = nextValues;
+      }
+      commitModel(next);
+    },
+    [commitModel, filterModel]
+  );
+  const clearField = React.useCallback(
+    (fieldId) => {
+      const next = { ...filterModel };
+      delete next[fieldId];
+      commitModel(next);
+    },
+    [commitModel, filterModel]
+  );
+  const clearAll = React.useCallback(() => {
+    commitModel({});
+    commitSearch("");
+  }, [commitModel, commitSearch]);
+  const appliedCount = React.useMemo(
+    () => Object.values(filterModel).reduce(
+      (total, values) => total + values.length,
+      0
+    ),
+    [filterModel]
+  );
+  const optionCounts = React.useMemo(() => {
+    const term = searchable ? search.trim().toLowerCase() : "";
+    const base = events.filter((e) => matchesSearch(e, term));
+    const out = {};
+    for (const field of filterFields ?? []) {
+      const perValue = {};
+      for (const option of field.options) {
+        perValue[option.value] = base.filter(
+          (e) => matchesField(e, field.id, [option.value])
+        ).length;
+      }
+      out[field.id] = perValue;
+    }
+    return out;
+  }, [events, filterFields, search, searchable]);
+  const filteredEvents = React.useMemo(() => {
+    if (filterMode === "server") return events;
+    const term = searchable ? search.trim().toLowerCase() : "";
+    const activeFields = Object.entries(filterModel).filter(
+      ([, values]) => values.length > 0
+    );
+    if (term === "" && activeFields.length === 0) return events;
+    return events.filter((event) => {
+      if (!matchesSearch(event, term)) return false;
+      return activeFields.every(
+        ([fieldId, values]) => matchesField(event, fieldId, values)
+      );
+    });
+  }, [events, filterMode, filterModel, search, searchable]);
+  return {
+    search,
+    setSearch: commitSearch,
+    filterModel,
+    toggleValue,
+    clearField,
+    clearAll,
+    appliedCount,
+    optionCounts,
+    filteredEvents
+  };
+}
+function useSchedulerState({
+  defaultDate,
+  date: dateProp,
+  onDateChange,
+  defaultView,
+  view: viewProp,
+  onViewChange,
+  weekStartsOn,
+  locale,
+  now
+}) {
+  const isDateControlled = dateProp !== void 0;
+  const isViewControlled = viewProp !== void 0;
+  const [dateState, setDateState] = React.useState(
+    () => defaultDate ?? dateFns.startOfDay(now)
+  );
+  const [viewState, setViewState] = React.useState(
+    () => defaultView ?? "month"
+  );
+  const date = isDateControlled ? dateProp : dateState;
+  const view = isViewControlled ? viewProp : viewState;
+  React.useRef(false);
+  React.useEffect(() => {
+    return;
+  }, [dateProp, defaultDate, viewProp, defaultView, onDateChange, onViewChange]);
+  const commitDate = React.useCallback(
+    (next2) => {
+      if (!isDateControlled) setDateState(next2);
+      onDateChange?.(next2);
+    },
+    [isDateControlled, onDateChange]
+  );
+  const commitView = React.useCallback(
+    (next2) => {
+      if (!isViewControlled) setViewState(next2);
+      onViewChange?.(next2);
+    },
+    [isViewControlled, onViewChange]
+  );
+  const shift = React.useCallback(
+    (direction) => {
+      const step = view === "month" ? dateFns.addMonths(date, direction) : view === "week" ? dateFns.addWeeks(date, direction) : dateFns.addDays(date, direction);
+      commitDate(dateFns.startOfDay(step));
+    },
+    [commitDate, date, view]
+  );
+  const next = React.useCallback(() => shift(1), [shift]);
+  const prev = React.useCallback(() => shift(-1), [shift]);
+  const goToToday = React.useCallback(
+    () => commitDate(dateFns.startOfDay(now)),
+    [commitDate, now]
+  );
+  const goToDate = React.useCallback(
+    (target) => commitDate(dateFns.startOfDay(target)),
+    [commitDate]
+  );
+  const visibleRange = React.useMemo(() => {
+    switch (view) {
+      case "month": {
+        const gridStart = dateFns.startOfWeek(dateFns.startOfMonth(date), {
+          weekStartsOn,
+          locale
+        });
+        return { start: gridStart, end: dateFns.endOfDay(dateFns.addDays(gridStart, 41)) };
+      }
+      case "week":
+        return {
+          start: dateFns.startOfWeek(date, { weekStartsOn, locale }),
+          end: dateFns.endOfWeek(date, { weekStartsOn, locale })
+        };
+      case "day":
+        return { start: dateFns.startOfDay(date), end: dateFns.endOfDay(date) };
+      case "list":
+      default:
+        return { start: dateFns.startOfMonth(date), end: dateFns.endOfMonth(date) };
+    }
+  }, [date, view, weekStartsOn, locale]);
+  return {
+    date,
+    view,
+    setDate: commitDate,
+    setView: commitView,
+    next,
+    prev,
+    goToToday,
+    goToDate,
+    visibleRange
+  };
+}
+function useMediaQuery(query) {
+  const [matches, setMatches] = React.useState(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query).matches;
+  });
+  React.useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mql = window.matchMedia(query);
+    const handler = (e) => setMatches(e.matches);
+    setMatches(mql.matches);
+    mql.addEventListener("change", handler);
+    return () => mql.removeEventListener("change", handler);
+  }, [query]);
+  return matches;
+}
+const Scheduler = React.forwardRef(
+  function Scheduler2({
+    events,
+    locale,
+    weekStartsOn = 0,
+    hourFormat = "24h",
+    nowIndicator = true,
+    dayRange = [0, 24],
+    scrollToHour = 8,
+    snapMinutes = 15,
+    defaultDate,
+    date,
+    onDateChange,
+    defaultView,
+    view,
+    onViewChange,
+    onEventClick,
+    onSlotClick,
+    onEventMove,
+    onEventResize,
+    draggable = false,
+    resizable = false,
+    searchable = true,
+    search,
+    onSearchChange,
+    filterFields,
+    filterModel,
+    onFilterModelChange,
+    filterMode = "client",
+    defaultFilterPanelOpen = false,
+    toolbarActions,
+    primaryAction,
+    title: title2,
+    renderEvent,
+    emptyState,
+    className,
+    ...rest
+  }, ref) {
+    const nowRef = React.useRef(/* @__PURE__ */ new Date());
+    const now = nowRef.current;
+    const state = useSchedulerState({
+      defaultDate,
+      date,
+      onDateChange,
+      defaultView,
+      view,
+      onViewChange,
+      weekStartsOn,
+      locale,
+      now
+    });
+    const filter = useSchedulerFilter({
+      events,
+      searchable,
+      search,
+      onSearchChange,
+      filterFields,
+      filterModel,
+      onFilterModelChange,
+      filterMode
+    });
+    const dndAtivo = Boolean(
+      (draggable || resizable || events.some((e) => e.draggable || e.resizable)) && (onEventMove || onEventResize)
+    );
+    const dnd = useSchedulerDnd({
+      enabled: dndAtivo,
+      view: state.view,
+      events: filter.filteredEvents,
+      snapMinutes,
+      dayRange,
+      hourHeight: HOUR_HEIGHT_PX,
+      draggable,
+      resizable,
+      onEventMove,
+      onEventResize
+    });
+    React.useRef(false);
+    React.useEffect(() => {
+      return;
+    }, [draggable, resizable, onEventMove, onEventResize]);
+    const eventoArrastado = dnd.dragAtivo?.kind === "move" ? filter.filteredEvents.find((e) => e.id === dnd.dragAtivo?.eventId) ?? null : null;
+    const wideLayout = useMediaQuery("(min-width: 1024px)");
+    const [filterPanelOpen, setFilterPanelOpen] = React.useState(defaultFilterPanelOpen);
+    const hasFilterFields = (filterFields?.length ?? 0) > 0;
+    const showFilterPanel = filterPanelOpen && wideLayout && hasFilterFields;
+    const showFilterDrawer = filterPanelOpen && !wideLayout && hasFilterFields;
+    React.useImperativeHandle(
+      ref,
+      () => ({
+        goToDate: state.goToDate,
+        goToToday: state.goToToday,
+        next: state.next,
+        prev: state.prev,
+        getVisibleRange: () => state.visibleRange
+      }),
+      [state]
+    );
+    const periodTitle = React.useMemo(() => {
+      if (title2 !== void 0) return title2;
+      const { start, end } = state.visibleRange;
+      switch (state.view) {
+        case "week": {
+          const sameMonth = start.getMonth() === end.getMonth();
+          return sameMonth ? `${dateFns.format(start, "d", { locale })}–${dateFns.format(end, "d 'de' MMMM yyyy", { locale })}` : `${dateFns.format(start, "d MMM", { locale })} – ${dateFns.format(end, "d MMM yyyy", { locale })}`;
+        }
+        case "day":
+          return dateFns.format(state.date, "EEEE, d 'de' MMMM yyyy", { locale });
+        case "month":
+        case "list":
+        default:
+          return dateFns.format(state.date, "MMMM yyyy", { locale });
+      }
+    }, [title2, state.view, state.date, state.visibleRange, locale]);
+    return (
+      /* `role="region"` + `aria-label` com o período: é o que dá ao leitor de
+         tela um ponto de navegação ("Calendário, setembro 2026") sem que o
+         título do período precise se declarar `<h2>` e entrar no outline da
+         página. O rótulo só é montado quando o título é string — com um
+         `ReactNode` custom não dá pra derivar texto sem varrer a árvore. */
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          role: "region",
+          "aria-label": typeof periodTitle === "string" ? `Calendário, ${periodTitle}` : "Calendário",
+          className: avatar.cn(schedulerRoot(), className),
+          ...rest,
+          children: /* @__PURE__ */ jsxRuntime.jsxs(
+            core.DndContext,
+            {
+              sensors: dnd.sensors,
+              onDragStart: dnd.handleDragStart,
+              onDragOver: dnd.handleDragOver,
+              onDragEnd: dnd.handleDragEnd,
+              onDragCancel: dnd.handleDragCancel,
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  SchedulerToolbar,
+                  {
+                    title: periodTitle,
+                    view: state.view,
+                    onViewChange: state.setView,
+                    onPrev: state.prev,
+                    onNext: state.next,
+                    onToday: state.goToToday,
+                    searchable,
+                    search: filter.search,
+                    onSearchChange: filter.setSearch,
+                    filterFields,
+                    filterModel: filter.filterModel,
+                    onClearField: filter.clearField,
+                    onClearAll: filter.clearAll,
+                    appliedCount: filter.appliedCount,
+                    filterPanelOpen: showFilterPanel || showFilterDrawer,
+                    onToggleFilterPanel: () => setFilterPanelOpen((o) => !o),
+                    toolbarActions,
+                    primaryAction
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: schedulerBody(), children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("div", { className: schedulerMain(), children: state.view === "month" ? /* @__PURE__ */ jsxRuntime.jsx(
+                    SchedulerMonthView,
+                    {
+                      date: state.date,
+                      events: filter.filteredEvents,
+                      locale,
+                      weekStartsOn,
+                      hourFormat,
+                      now,
+                      onEventClick,
+                      onSlotClick,
+                      renderEvent,
+                      dndAtivo,
+                      podeMover: dnd.podeMover
+                    }
+                  ) : state.view === "list" ? /* @__PURE__ */ jsxRuntime.jsx(
+                    SchedulerListView,
+                    {
+                      date: state.date,
+                      events: filter.filteredEvents,
+                      locale,
+                      hourFormat,
+                      now,
+                      onEventClick,
+                      renderEvent,
+                      emptyState
+                    }
+                  ) : (
+                    /* `week` e `day` são a MESMA view, com 7 ou 1 coluna. */
+                    /* @__PURE__ */ jsxRuntime.jsx(
+                      SchedulerTimeGrid,
+                      {
+                        date: state.date,
+                        view: state.view,
+                        events: filter.filteredEvents,
+                        locale,
+                        weekStartsOn,
+                        hourFormat,
+                        dayRange,
+                        scrollToHour,
+                        nowIndicator,
+                        now,
+                        snapMinutes,
+                        onEventClick,
+                        onSlotClick,
+                        renderEvent,
+                        dndAtivo,
+                        podeMover: dnd.podeMover,
+                        podeRedimensionar: dnd.podeRedimensionar
+                      }
+                    )
+                  ) }),
+                  showFilterPanel && filterFields ? /* @__PURE__ */ jsxRuntime.jsx(
+                    SchedulerFilterPanel,
+                    {
+                      filterFields,
+                      filterModel: filter.filterModel,
+                      onToggleValue: filter.toggleValue,
+                      onClearAll: filter.clearAll,
+                      appliedCount: filter.appliedCount,
+                      onClose: () => setFilterPanelOpen(false),
+                      counts: filter.optionCounts,
+                      date: state.date,
+                      now,
+                      locale,
+                      weekStartsOn,
+                      events: filter.filteredEvents,
+                      onDateSelect: state.goToDate
+                    }
+                  ) : null
+                ] }),
+                showFilterDrawer && filterFields ? /* @__PURE__ */ jsxRuntime.jsx(
+                  panel.FloatingPanel,
+                  {
+                    open: true,
+                    onOpenChange: (aberto) => setFilterPanelOpen(aberto),
+                    side: "right",
+                    size: "sm",
+                    bodyPadded: false,
+                    title: "Filtros",
+                    titleIcon: lucideReact.ListFilter,
+                    description: filter.appliedCount === 1 ? "1 filtro ativo" : `${filter.appliedCount} filtros ativos`,
+                    footer: /* @__PURE__ */ jsxRuntime.jsx(
+                      avatar.Button,
+                      {
+                        variant: "ghost",
+                        color: "secondary",
+                        size: "sm",
+                        onClick: filter.clearAll,
+                        disabled: filter.appliedCount === 0,
+                        children: "Limpar tudo"
+                      }
+                    ),
+                    children: /* @__PURE__ */ jsxRuntime.jsx(
+                      SchedulerFilterPanel,
+                      {
+                        embedded: true,
+                        filterFields,
+                        filterModel: filter.filterModel,
+                        onToggleValue: filter.toggleValue,
+                        onClearAll: filter.clearAll,
+                        appliedCount: filter.appliedCount,
+                        onClose: () => setFilterPanelOpen(false),
+                        counts: filter.optionCounts,
+                        date: state.date,
+                        now,
+                        locale,
+                        weekStartsOn,
+                        events: filter.filteredEvents,
+                        onDateSelect: (d) => {
+                          state.goToDate(d);
+                          setFilterPanelOpen(false);
+                        }
+                      }
+                    )
+                  }
+                ) : null,
+                /* @__PURE__ */ jsxRuntime.jsx(core.DragOverlay, { dropAnimation: null, children: eventoArrastado ? /* @__PURE__ */ jsxRuntime.jsx(
+                  SchedulerEventItem,
+                  {
+                    event: eventoArrastado,
+                    view: state.view,
+                    variant: state.view === "month" ? "pill" : "block",
+                    dragging: true,
+                    timeLabel: eventoArrastado.allDay ? void 0 : dateFns.format(
+                      eventoArrastado.start,
+                      hourFormat === "12h" ? "h:mm a" : "HH:mm",
+                      { locale }
+                    )
+                  }
+                ) : null })
+              ]
+            }
+          )
+        }
+      )
+    );
+  }
+);
 const spinnerStyles = avatar.tv({
   base: ["inline-block shrink-0", "animate-spin motion-reduce:animate-none"],
   variants: {
@@ -8160,7 +10752,7 @@ function useDataList({
     for (const f of filterFields ?? []) m.set(f.id, f);
     return m;
   }, [filterFields]);
-  const matchesSearch = React.useCallback(
+  const matchesSearch2 = React.useCallback(
     (item) => {
       const s = query.search.trim().toLowerCase();
       if (!s) return true;
@@ -8176,9 +10768,9 @@ function useDataList({
   );
   const processedItems = React.useMemo(() => {
     if (mode === "server") return items;
-    const searched = query.search ? items.filter(matchesSearch) : items;
+    const searched = query.search ? items.filter(matchesSearch2) : items;
     return applyFilterModel(searched, query.filterModel, fieldsById);
-  }, [mode, items, query.search, query.filterModel, matchesSearch, fieldsById]);
+  }, [mode, items, query.search, query.filterModel, matchesSearch2, fieldsById]);
   return {
     query,
     activeViewId,
@@ -9090,6 +11682,8 @@ exports.MessageComposer = MessageComposer;
 exports.MessageVariablesPicker = MessageVariablesPicker;
 exports.Modal = Modal;
 exports.MonthYearPicker = MonthYearPicker;
+exports.Scheduler = Scheduler;
+exports.SchedulerFilterPanel = SchedulerFilterPanel;
 exports.ScreenLoader = ScreenLoader;
 exports.Spinner = Spinner;
 exports.TabsNavigation = TabsNavigation;