@marimo-team/islands 0.22.6-dev1 → 0.22.6-dev11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.22.6-dev1",
+  "version": "0.22.6-dev11",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/components/app-config/user-config-form.tsx

@@ -19,6 +19,7 @@ import { useForm } from "react-hook-form";
 import type z from "zod";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
+import { acceptCompletionOnEnterAtom } from "@/core/codemirror/completion/accept-on-enter-atom";
 import {
   Form,
   FormControl,
@@ -118,6 +119,9 @@ const LOCALE_SYSTEM_VALUE = "__system__";
 
 export const UserConfigForm: React.FC = () => {
   const [config, setConfig] = useUserConfig();
+  const [acceptOnEnter, setAcceptOnEnter] = useAtom(
+    acceptCompletionOnEnterAtom,
+  );
   const formElement = useRef<HTMLFormElement>(null);
   const setKeyboardShortcutsOpen = useSetAtom(keyboardShortcutsAtom);
   const [activeCategory, setActiveCategory] = useAtom(
@@ -446,6 +450,27 @@ export const UserConfigForm: React.FC = () => {
                   </div>
                 )}
               />
+              <div className="flex flex-col space-y-1">
+                <FormItem className={formItemClasses}>
+                  <FormLabel className="font-normal">
+                    Accept suggestion on Enter
+                  </FormLabel>
+                  <FormControl>
+                    <Checkbox
+                      data-testid="accept-completion-on-enter-checkbox"
+                      checked={acceptOnEnter}
+                      onCheckedChange={(checked) =>
+                        setAcceptOnEnter(Boolean(checked))
+                      }
+                    />
+                  </FormControl>
+                </FormItem>
+                <FormDescription>
+                  When unchecked, pressing Enter inserts a new line instead of
+                  accepting an autocomplete suggestion. Use Tab to accept
+                  suggestions.
+                </FormDescription>
+              </div>
               <FormField
                 control={form.control}
                 name="completion.signature_hint_on_typing"

package/src/components/editor/actions/pair-with-agent-modal.tsx

@@ -16,6 +16,7 @@ import { Events } from "@/utils/events";
 import { Tooltip } from "@/components/ui/tooltip";
 import { assertNever } from "@/utils/assertNever";
 import { asRemoteURL, useRuntimeManager } from "@/core/runtime/config";
+import { API } from "@/core/network/api";
 
 type AgentTab = "claude" | "codex" | "opencode";
 
@@ -54,7 +55,9 @@ const SKILL_INSTALL = "npx skills add marimo-team/marimo-pair";
 function useAuthToken(): string | null {
   const [token, setToken] = useState<string | null>(null);
   useEffect(() => {
-    fetch(asRemoteURL("/auth/token").href, { credentials: "include" })
+    fetch(asRemoteURL("/auth/token").href, {
+      headers: API.headers(),
+    })
       .then((res) =>
         res.ok ? (res.json() as Promise<{ token: string | null }>) : null,
       )

package/src/components/editor/cell/code/cell-editor.tsx

@@ -13,6 +13,7 @@ import { useCellActions } from "@/core/cells/cells";
 import { usePendingDeleteService } from "@/core/cells/pending-delete-service";
 import type { CellData, CellRuntimeState } from "@/core/cells/types";
 import { setupCodeMirror } from "@/core/codemirror/cm";
+import { acceptCompletionOnEnterAtom } from "@/core/codemirror/completion/accept-on-enter-atom";
 import {
   getInitialLanguageAdapter,
   languageAdapterState,
@@ -146,6 +147,7 @@ const CellEditorInternal = ({
   });
 
   const autoInstantiate = useAtomValue(autoInstantiateAtom);
+  const acceptCompletionOnEnter = useAtomValue(acceptCompletionOnEnterAtom);
   const afterToggleMarkdown = useEvent(() => {
     maybeAddMarimoImport({
       autoInstantiate,
@@ -212,6 +214,7 @@ const CellEditorInternal = ({
         },
       },
       completionConfig: userConfig.completion,
+      acceptCompletionOnEnter,
       keymapConfig: userConfig.keymap,
       lspConfig: userConfig.language_servers,
       theme,
@@ -261,6 +264,7 @@ const CellEditorInternal = ({
     return extensions;
   }, [
     cellId,
+    acceptCompletionOnEnter,
     userConfig.keymap,
     userConfig.completion,
     userConfig.language_servers,

package/src/components/editor/package-alert.tsx

@@ -76,6 +76,21 @@ function buildPackageSpecifier(name: string, extras: string[]): string {
   return `${name}[${extras.join(",")}]`;
 }
 
+const SourceBadge: React.FC<{ source?: "kernel" | "server" }> = ({
+  source,
+}) => {
+  if (source !== "server") {
+    return null;
+  }
+  return (
+    <Tooltip content="Installing into the server environment, not the notebook kernel">
+      <span className="ml-2 text-xs font-normal border border-current rounded px-1 py-0.5 opacity-60">
+        server
+      </span>
+    </Tooltip>
+  );
+};
+
 export const PackageAlert: React.FC = () => {
   const { packageAlert, packageLogs } = useAlerts();
   const { clearPackageAlert } = useAlertActions();
@@ -105,6 +120,7 @@ export const PackageAlert: React.FC = () => {
             <span className="font-bold text-lg flex items-center mb-2">
               <PackageXIcon className="w-5 h-5 inline-block mr-2" />
               Missing packages
+              <SourceBadge source={packageAlert.source} />
             </span>
             <Button
               variant="text"
@@ -217,6 +233,7 @@ export const PackageAlert: React.FC = () => {
             <span className="font-bold text-lg flex items-center mb-2">
               {titleIcon}
               {title}
+              <SourceBadge source={packageAlert.source} />
             </span>
             <Button
               variant="text"

package/src/core/alerts/state.ts

@@ -19,6 +19,7 @@ export interface InstallingPackageAlert {
   packages: PackageInstallationStatus;
   logs?: { [key: string]: string } | null;
   log_status?: "append" | "start" | "done" | null;
+  source?: "kernel" | "server";
 }
 
 export interface StartupLogsAlert {

package/src/core/codemirror/ai/resources.ts

@@ -72,6 +72,7 @@ export function resourceExtension(opts: {
       keymap.of([
         {
           key: "Tab",
+          preventDefault: true,
           run: (view: EditorView) => {
             return acceptCompletion(view);
           },

package/src/core/codemirror/cm.ts

@@ -73,6 +73,7 @@ export interface CodeMirrorSetupOpts {
   cellId: CellId;
   showPlaceholder: boolean;
   enableAI: boolean;
+  acceptCompletionOnEnter?: boolean;
   cellActions: CodemirrorCellActions;
   completionConfig: CompletionConfig;
   keymapConfig: KeymapConfig;
@@ -175,6 +176,7 @@ export const basicBundle = (opts: CodeMirrorSetupOpts): Extension[] => {
     theme,
     hotkeys,
     completionConfig,
+    acceptCompletionOnEnter,
     cellId,
     lspConfig,
     diagnosticsConfig,
@@ -207,7 +209,7 @@ export const basicBundle = (opts: CodeMirrorSetupOpts): Extension[] => {
     foldGutter(),
     stringsAutoCloseBraces(),
     closeBrackets(),
-    completionKeymap(),
+    completionKeymap(acceptCompletionOnEnter),
     // to avoid clash with charDeleteBackward keymap
     Prec.high(keymap.of(closeBracketsKeymap)),
     bracketMatching(),

package/src/core/codemirror/completion/__tests__/keymap.test.ts

@@ -1,8 +1,21 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { completionKeymap as defaultCompletionKeymap } from "@codemirror/autocomplete";
+import { EditorState } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
 import { describe, expect, it } from "vitest";
-import { filterCompletionBindings } from "../keymap";
+import { completionKeymap, filterCompletionBindings } from "../keymap";
+
+function hasEnterBinding(acceptOnEnter: boolean): boolean {
+  const state = EditorState.create({
+    extensions: [completionKeymap(acceptOnEnter)],
+  });
+
+  return state
+    .facet(keymap)
+    .flat()
+    .some((binding) => binding.key === "Enter");
+}
 
 describe("completionKeymap", () => {
   it("upstream includes the macOS-only completion bindings we care about", () => {
@@ -21,4 +34,30 @@ describe("completionKeymap", () => {
     expect(filtered.some((binding) => binding.key === "Escape")).toBe(false);
     expect(filtered.some((binding) => binding.mac === "Alt-i")).toBe(true);
   });
+
+  it("includes Enter by default", () => {
+    const filtered = filterCompletionBindings(defaultCompletionKeymap);
+    expect(filtered.some((binding) => binding.key === "Enter")).toBe(true);
+  });
+
+  it("removes Enter when passed a keysToRemove set containing Enter", () => {
+    const keysToRemove = new Set<string | undefined>([
+      "Escape",
+      "Alt-`",
+      "Enter",
+    ]);
+    const filtered = filterCompletionBindings(
+      defaultCompletionKeymap,
+      keysToRemove,
+    );
+    expect(filtered.some((binding) => binding.key === "Enter")).toBe(false);
+  });
+
+  it("completionKeymap includes Enter when acceptOnEnter is true", () => {
+    expect(hasEnterBinding(true)).toBe(true);
+  });
+
+  it("completionKeymap removes Enter when acceptOnEnter is false", () => {
+    expect(hasEnterBinding(false)).toBe(false);
+  });
 });

package/src/core/codemirror/completion/accept-on-enter-atom.ts

@@ -0,0 +1,10 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { atomWithStorage } from "jotai/utils";
+import { jotaiJsonStorage } from "@/utils/storage/jotai";
+// Default: true (Enter accepts suggestion, matching VS Code default)
+export const acceptCompletionOnEnterAtom = atomWithStorage<boolean>(
+  "marimo:accept-completion-on-enter",
+  true,
+  jotaiJsonStorage,
+  { getOnInit: true },
+);

package/src/core/codemirror/completion/keymap.ts

@@ -22,20 +22,27 @@ const KEYS_TO_REMOVE = new Set<string | undefined>([
   "Alt-`",
 ]);
 
-function hasRemovedKeybinding(binding: KeyBinding): boolean {
-  return [binding.key, binding.mac, binding.linux, binding.win].some((key) =>
-    KEYS_TO_REMOVE.has(key),
-  );
-}
-
 export function filterCompletionBindings(
   bindings: readonly KeyBinding[],
+  keysToRemove: Set<string | undefined> = KEYS_TO_REMOVE,
 ): readonly KeyBinding[] {
-  return bindings.filter((binding) => !hasRemovedKeybinding(binding));
+  return bindings.filter(
+    (binding) =>
+      ![binding.key, binding.mac, binding.linux, binding.win].some((key) =>
+        keysToRemove.has(key),
+      ),
+  );
 }
 
-export function completionKeymap(): Extension {
-  const withoutKeysToRemove = filterCompletionBindings(defaultCompletionKeymap);
+export function completionKeymap(acceptOnEnter = true): Extension {
+  const keysToRemove = new Set(KEYS_TO_REMOVE);
+  if (!acceptOnEnter) {
+    keysToRemove.add("Enter");
+  }
+  const withoutKeysToRemove = filterCompletionBindings(
+    defaultCompletionKeymap,
+    keysToRemove,
+  );
 
   return Prec.highest(
     keymap.of([

package/src/plugins/impl/plotly/PlotlyPlugin.tsx

@@ -19,6 +19,7 @@ import {
   extractPoints,
   extractSunburstPoints,
   extractTreemapPoints,
+  hasAreaTrace,
   hasPureLineTrace,
   lineSelectionButtons,
   type ModeBarButton,
@@ -113,7 +114,8 @@ export const PlotlyComponent = memo(
 
     const configMemo = useDeepCompareMemoize(config);
     const plotlyConfig = useMemo((): Partial<Plotly.Config> => {
-      const hasPureLine = hasPureLineTrace(figure.data);
+      const hasLineOrAreaTrace =
+        hasPureLineTrace(figure.data) || hasAreaTrace(figure.data);
       const defaultButtons: ModeBarButton[] = [
         // Custom button to reset the state
         {
@@ -130,7 +132,7 @@ export const PlotlyComponent = memo(
           click: handleResetWithClear,
         },
       ];
-      if (hasPureLine) {
+      if (hasLineOrAreaTrace) {
         defaultButtons.push(...lineSelectionButtons(handleSetDragmode));
       }
 

package/src/plugins/impl/plotly/__tests__/PlotlyPlugin.test.tsx

@@ -111,4 +111,54 @@ describe("PlotlyPlugin", () => {
       range: undefined,
     });
   });
+
+  it("clicking a violin element triggers onClick", async () => {
+    const setValue = vi.fn<Setter<unknown>>();
+
+    render(
+      <Suspense fallback={null}>
+        <PlotlyComponent
+          figure={{
+            data: [{ type: "violin" }],
+            layout: {},
+            frames: null,
+          }}
+          value={undefined}
+          setValue={setValue}
+          host={document.createElement("div")}
+          config={{}}
+        />
+      </Suspense>,
+    );
+
+    await waitFor(() => {
+      expect(capturedPlotProps).not.toBeNull();
+    });
+
+    act(() => {
+      capturedPlotProps?.onClick?.({
+        points: [
+          {
+            data: { type: "violin" },
+            x: "Group A",
+            y: 3,
+            pointIndex: 0,
+            pointNumber: 0,
+            curveNumber: 0,
+          },
+        ],
+      });
+    });
+
+    expect(setValue).toHaveBeenCalledTimes(1);
+    const updater = setValue.mock.calls[0][0] as (value: unknown) => unknown;
+    expect(updater({})).toEqual({
+      selections: [],
+      points: [
+        { x: "Group A", y: 3, curveNumber: 0, pointNumber: 0, pointIndex: 0 },
+      ],
+      indices: [0],
+      range: undefined,
+    });
+  });
 });

package/src/plugins/impl/plotly/__tests__/selection.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it, vi } from "vitest";
 import {
   extractIndices,
   extractPoints,
+  hasAreaTrace,
   hasPureLineTrace,
   lineSelectionButtons,
   type ModeBarButton,
@@ -101,6 +102,14 @@ describe("shouldHandleClickSelection", () => {
     expect(shouldHandleClickSelection([heatmapPoint])).toBe(true);
   });
 
+  it("accepts violin clicks", () => {
+    const violinPoint = createPlotDatum({
+      data: { type: "violin" },
+    });
+
+    expect(shouldHandleClickSelection([violinPoint])).toBe(true);
+  });
+
   it("accepts histogram clicks", () => {
     const histogramPoint = createPlotDatum({
       data: { type: "histogram" },
@@ -219,3 +228,67 @@ describe("extractPoints", () => {
     ]);
   });
 });
+
+describe("hasAreaTrace", () => {
+  it("detects scatter trace with tozeroy fill", () => {
+    expect(
+      hasAreaTrace([createTrace({ type: "scatter", fill: "tozeroy" })]),
+    ).toBe(true);
+  });
+
+  it("detects scatter trace with tonexty fill", () => {
+    expect(
+      hasAreaTrace([createTrace({ type: "scatter", fill: "tonexty" })]),
+    ).toBe(true);
+  });
+
+  it("detects scatter trace with stackgroup (px.area pattern)", () => {
+    expect(
+      hasAreaTrace([
+        createTrace({ type: "scatter", mode: "lines", stackgroup: "one" }),
+      ]),
+    ).toBe(true);
+  });
+
+  it("detects area traces with mode=none (fill-only, no visible line)", () => {
+    expect(
+      hasAreaTrace([
+        createTrace({ type: "scatter", fill: "tozeroy", mode: "none" }),
+      ]),
+    ).toBe(true);
+  });
+
+  it("ignores scatter traces with no fill and no stackgroup", () => {
+    expect(
+      hasAreaTrace([
+        createTrace({ type: "scatter", mode: "lines" }),
+        createTrace({ type: "scatter", mode: "markers" }),
+      ]),
+    ).toBe(false);
+  });
+
+  it("ignores scatter traces with fill=none", () => {
+    expect(hasAreaTrace([createTrace({ type: "scatter", fill: "none" })])).toBe(
+      false,
+    );
+  });
+
+  it("ignores scatter traces with fill=empty string", () => {
+    expect(
+      hasAreaTrace([createTrace({ type: "scatter", fill: "" as "none" })]),
+    ).toBe(false);
+  });
+
+  it("ignores non-scatter traces", () => {
+    expect(
+      hasAreaTrace([
+        createTrace({ type: "bar" }),
+        createTrace({ type: "heatmap" }),
+      ]),
+    ).toBe(false);
+  });
+
+  it("returns false for undefined data", () => {
+    expect(hasAreaTrace(undefined)).toBe(false);
+  });
+});

package/src/plugins/impl/plotly/__tests__/usePlotlyLayout.test.ts

@@ -8,11 +8,15 @@ import {
   computeLayoutUpdate,
   computeOmitKeys,
   createInitialLayout,
+  hasCompatibleTraces,
 } from "../usePlotlyLayout";
 
-function createFigure(layoutOverrides: Partial<Plotly.Layout> = {}): Figure {
+function createFigure(
+  layoutOverrides: Partial<Plotly.Layout> = {},
+  data: Plotly.Data[] = [],
+): Figure {
   return {
-    data: [],
+    data,
     layout: { ...layoutOverrides } as Plotly.Layout,
     frames: null,
   };
@@ -35,9 +39,46 @@ describe("createInitialLayout", () => {
   });
 });
 
+describe("hasCompatibleTraces", () => {
+  it("returns true for same trace types", () => {
+    const a = createFigure({}, [{ type: "scatter" } as Plotly.Data]);
+    const b = createFigure({}, [{ type: "scatter" } as Plotly.Data]);
+    expect(hasCompatibleTraces(a, b)).toBe(true);
+  });
+
+  it("returns true for default scatter types (undefined type)", () => {
+    const a = createFigure({}, [{} as Plotly.Data]);
+    const b = createFigure({}, [{ type: "scatter" } as Plotly.Data]);
+    expect(hasCompatibleTraces(a, b)).toBe(true);
+  });
+
+  it("returns false for different trace types", () => {
+    const a = createFigure({}, [{ type: "scatter" } as Plotly.Data]);
+    const b = createFigure({}, [{ type: "histogram" } as Plotly.Data]);
+    expect(hasCompatibleTraces(a, b)).toBe(false);
+  });
+
+  it("returns false for different number of traces", () => {
+    const a = createFigure({}, [{ type: "scatter" } as Plotly.Data]);
+    const b = createFigure({}, [
+      { type: "scatter" } as Plotly.Data,
+      { type: "scatter" } as Plotly.Data,
+    ]);
+    expect(hasCompatibleTraces(a, b)).toBe(false);
+  });
+
+  it("returns true for empty data arrays", () => {
+    const a = createFigure({}, []);
+    const b = createFigure({}, []);
+    expect(hasCompatibleTraces(a, b)).toBe(true);
+  });
+});
+
 describe("computeLayoutOnFigureChange", () => {
-  it("preserves only dragmode/xaxis/yaxis from previous layout (#7964)", () => {
-    const nextFigure = createFigure({ title: { text: "New" } });
+  it("preserves only dragmode/xaxis/yaxis from previous layout for compatible traces (#7964)", () => {
+    const scatterData = [{ type: "scatter" } as Plotly.Data];
+    const prevFigure = createFigure({}, scatterData);
+    const nextFigure = createFigure({ title: { text: "New" } }, scatterData);
     const prevLayout: Partial<Plotly.Layout> = {
       dragmode: "zoom",
       xaxis: { range: [0, 10] },
@@ -46,7 +87,11 @@ describe("computeLayoutOnFigureChange", () => {
       annotations: [{ text: "Old", x: 0, y: 0 }],
     };
 
-    const result = computeLayoutOnFigureChange(nextFigure, prevLayout);
+    const result = computeLayoutOnFigureChange(
+      nextFigure,
+      prevFigure,
+      prevLayout,
+    );
 
     // Preserved from prev
     expect(result.dragmode).toBe("zoom");
@@ -59,15 +104,68 @@ describe("computeLayoutOnFigureChange", () => {
     expect(result.annotations).toBeUndefined();
   });
 
+  it("resets axis settings when trace types change (#5898)", () => {
+    const prevFigure = createFigure({}, [{ type: "histogram" } as Plotly.Data]);
+    const nextFigure = createFigure({ title: { text: "Bar" } }, [
+      { type: "bar" } as Plotly.Data,
+    ]);
+    const prevLayout: Partial<Plotly.Layout> = {
+      dragmode: "zoom",
+      xaxis: { range: [-3, 3] },
+      yaxis: { range: [0, 200] },
+    };
+
+    const result = computeLayoutOnFigureChange(
+      nextFigure,
+      prevFigure,
+      prevLayout,
+    );
+
+    // Dragmode is still preserved
+    expect(result.dragmode).toBe("zoom");
+    // Axis settings are NOT preserved — they come from the new figure's layout
+    expect(result.xaxis).toBeUndefined();
+    expect(result.yaxis).toBeUndefined();
+    // New figure's layout is applied
+    expect(result.title).toEqual({ text: "Bar" });
+  });
+
+  it("preserves nextFigure dragmode when prevLayout has no dragmode", () => {
+    const prevFigure = createFigure({}, [{ type: "histogram" } as Plotly.Data]);
+    const nextFigure = createFigure({ dragmode: "lasso" }, [
+      { type: "bar" } as Plotly.Data,
+    ]);
+    const prevLayout: Partial<Plotly.Layout> = {
+      xaxis: { range: [0, 10] },
+    };
+
+    const result = computeLayoutOnFigureChange(
+      nextFigure,
+      prevFigure,
+      prevLayout,
+    );
+
+    // nextFigure.layout.dragmode should be preserved via base, not overwritten
+    expect(result.dragmode).toBe("lasso");
+    // Axis settings are NOT preserved for incompatible traces
+    expect(result.xaxis).toBeUndefined();
+    expect(result.yaxis).toBeUndefined();
+  });
+
   it("uses shapes from new figure, not previous layout", () => {
     const nextFigure = createFigure({
       shapes: [{ type: "circle", x0: 0, x1: 1, y0: 0, y1: 1 }],
     });
+    const prevFigure = createFigure({});
     const prevLayout: Partial<Plotly.Layout> = {
       shapes: [{ type: "rect", x0: 0, x1: 1, y0: 0, y1: 1 }],
     };
 
-    const result = computeLayoutOnFigureChange(nextFigure, prevLayout);
+    const result = computeLayoutOnFigureChange(
+      nextFigure,
+      prevFigure,
+      prevLayout,
+    );
 
     expect(result.shapes).toHaveLength(1);
     expect(result.shapes?.[0].type).toBe("circle");

package/src/plugins/impl/plotly/selection.ts

@@ -141,13 +141,44 @@ export function hasPureLineTrace(
   }
 
   return data.some((trace) => {
-    const traceType = (trace as { type?: unknown }).type;
+    const t = trace as Record<string, unknown>;
     const isScatterLike =
-      traceType === undefined || LINE_CLICK_TRACE_TYPES.has(String(traceType));
+      t.type === undefined || LINE_CLICK_TRACE_TYPES.has(String(t.type));
     if (!isScatterLike) {
       return false;
     }
-    return isPureLineMode((trace as { mode?: unknown }).mode);
+    return isPureLineMode(t.mode);
+  });
+}
+
+/**
+ * Return true when any scatter/scattergl trace has a non-empty fill or a
+ * stackgroup, i.e. it is an area chart.
+ *
+ * Area traces built with `mode="none"` have no visible line or markers, so
+ * `hasPureLineTrace` returns false for them even though they need select/lasso
+ * buttons just as much as `mode="lines"` area charts.  This function covers
+ * that gap and is OR-ed with `hasPureLineTrace` in the config builder.
+ */
+export function hasAreaTrace(
+  data: readonly Plotly.Data[] | undefined,
+): boolean {
+  if (!data) {
+    return false;
+  }
+
+  return data.some((trace) => {
+    const t = trace as Record<string, unknown>;
+    // Only scatter/scattergl can be area traces.
+    if (t.type !== undefined && !LINE_CLICK_TRACE_TYPES.has(String(t.type))) {
+      return false;
+    }
+    // A trace is an area trace when fill is a non-empty string other than
+    // "none", OR it belongs to a stackgroup (px.area always sets stackgroup).
+    return (
+      (typeof t.fill === "string" && t.fill !== "" && t.fill !== "none") ||
+      t.stackgroup != null
+    );
   });
 }
 
@@ -228,6 +259,7 @@ export function shouldHandleClickSelection(
       type === "heatmap" ||
       type === "histogram" ||
       type === "waterfall" ||
+      type === "violin" ||
       isLinePoint(point)
     );
   });