@marimo-team/islands 0.21.2-dev92 → 0.21.2-dev94

package/src/core/codemirror/rtc/extension.ts

@@ -2,8 +2,8 @@
 
 import type { Extension } from "@codemirror/state";
 import { EditorView, ViewPlugin } from "@codemirror/view";
+import { dequal as isEqual } from "dequal";
 import { atom } from "jotai";
-import { isEqual } from "lodash-es";
 import { Awareness, LoroDoc, LoroMap, LoroText } from "loro-crdt";
 import ReconnectingWebSocket from "partysocket/ws";
 import type { CellId } from "@/core/cells/ids";

package/src/core/network/requests-network.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { once } from "lodash-es";
+import { once } from "@/utils/once";
 import { getRuntimeManager } from "../runtime/config";
 import { API, createClientWithRuntimeManager } from "./api";
 import { waitForConnectionOpen } from "./connection";

package/src/core/rtc/state.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { atomWithStorage } from "jotai/utils";
-import { once } from "lodash-es";
+import { once } from "@/utils/once";
 import { jotaiJsonStorage } from "@/utils/storage/jotai";
 import { getFeatureFlag } from "../config/feature-flag";
 

package/src/core/saving/state.ts

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+
+import { dequal as isEqual } from "dequal";
 import { atom } from "jotai";
-import { isEqual } from "lodash-es";
 import { arrayShallowEquals } from "@/utils/arrays";
 import { type NotebookState, notebookAtom } from "../cells/cells";
 import { type LayoutState, layoutStateAtom } from "../layout/layout";

package/src/core/slots/slots.ts

@@ -6,4 +6,5 @@ export const slotsController = new SlotzController();
 export const SlotNames = {
   SIDEBAR: "sidebar",
   CONTEXT_AWARE_PANEL: "context-aware-panel",
+  CONTEXT_AWARE_PANEL_HEADER: "context-aware-panel-header",
 };

package/src/core/state/jotai.ts

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+
+import { dequal as isEqual } from "dequal";
 import { type Atom, atom, createStore, useStore } from "jotai";
-import { isEqual } from "lodash-es";
 import { useEffect } from "react";
 
 /**

package/src/plugins/impl/DataTablePlugin.tsx

@@ -26,7 +26,6 @@ import type { CellSelectionState } from "@/components/data-table/cell-selection/
 import type { CellStyleState } from "@/components/data-table/cell-styling/types";
 import { TablePanel } from "@/components/data-table/charts/charts";
 import { hasChart } from "@/components/data-table/charts/storage";
-import { ColumnExplorerPanel } from "@/components/data-table/column-explorer-panel/column-explorer";
 import { ColumnChartSpecModel } from "@/components/data-table/column-summary/chart-spec-model";
 import { ColumnChartContext } from "@/components/data-table/column-summary/column-summary";
 import {
@@ -35,11 +34,11 @@ import {
 } from "@/components/data-table/filters";
 import { usePanelOwnership } from "@/components/data-table/hooks/use-panel-ownership";
 import { LoadingTable } from "@/components/data-table/loading-table";
-import { RowViewerPanel } from "@/components/data-table/row-viewer-panel/row-viewer";
 import {
   type DownloadAsArgs,
   DownloadAsSchema,
 } from "@/components/data-table/schemas";
+import { TableExplorerPanel } from "@/components/data-table/table-explorer-panel/table-explorer-panel";
 import {
   type BinValues,
   type ColumnHeaderStats,
@@ -839,7 +838,8 @@ const DataTableComponent = ({
   }): JSX.Element => {
   const id = useId();
   const [viewedRowIdx, setViewedRowIdx] = useState(0);
-  const { isPanelOpen, togglePanel } = usePanelOwnership(id, cellId);
+  const { isPanelOpen, isAnyPanelOpen, togglePanel, panelType, setPanelType } =
+    usePanelOwnership(id, cellId);
 
   const chartSpecModel = useMemo(() => {
     if (!columnSummaries) {
@@ -1002,8 +1002,7 @@ const DataTableComponent = ({
   );
 
   const isSelectable = selection === "multi" || selection === "single";
-  const showColExplorer =
-    showColumnExplorer && preview_column && isPanelOpen("column-explorer");
+  const canShowColumnExplorer = showColumnExplorer && !!preview_column;
 
   const isInVscode = isInVscodeExtension();
 
@@ -1032,28 +1031,24 @@ const DataTableComponent = ({
         </Banner>
       )}
 
-      {isPanelOpen("row-viewer") && (
+      {isAnyPanelOpen && (showRowExplorer || canShowColumnExplorer) && (
         <ContextAwarePanelItem>
-          <RowViewerPanel
-            getRow={getRow}
-            fieldTypes={memoizedUnclampedFieldTypes}
-            totalRows={totalRows}
+          <TableExplorerPanel
             rowIdx={viewedRowIdx}
             setRowIdx={setViewedRow}
+            totalRows={totalRows}
+            fieldTypes={memoizedUnclampedFieldTypes}
+            getRow={getRow}
             isSelectable={isSelectable}
-            isRowSelected={rowSelection[viewedRowIdx]}
+            isRowSelected={Boolean(rowSelection[viewedRowIdx])}
             handleRowSelectionChange={handleRowSelectionChange}
-          />
-        </ContextAwarePanelItem>
-      )}
-      {showColExplorer && (
-        <ContextAwarePanelItem>
-          <ColumnExplorerPanel
             previewColumn={preview_column}
-            fieldTypes={memoizedUnclampedFieldTypes}
-            totalRows={totalRows}
             totalColumns={totalColumns}
             tableId={id}
+            showRowExplorer={showRowExplorer && !isInVscode}
+            showColumnExplorer={canShowColumnExplorer && !isInVscode}
+            activeTab={panelType}
+            onTabChange={setPanelType}
           />
         </ContextAwarePanelItem>
       )}
@@ -1099,11 +1094,13 @@ const DataTableComponent = ({
             showChartBuilder={showChartBuilder}
             showPageSizeSelector={showPageSizeSelector}
             // Hidden in VSCode (for now) because we don't have a panel to show
-            // the column/row explorer.
-            showColumnExplorer={showColumnExplorer && !isInVscode}
-            showRowExplorer={showRowExplorer && !isInVscode}
+            // the table explorer.
+            showTableExplorer={
+              (showRowExplorer || canShowColumnExplorer) && !isInVscode
+            }
             togglePanel={togglePanel}
             isPanelOpen={isPanelOpen}
+            isAnyPanelOpen={isAnyPanelOpen}
             viewedRowIdx={viewedRowIdx}
             onViewedRowChange={(rowIdx) => setViewedRowIdx(rowIdx)}
           />

package/src/plugins/impl/RangeSliderPlugin.tsx

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { isEqual } from "lodash-es";
+import { dequal as isEqual } from "dequal";
 import { type JSX, useEffect, useId, useState } from "react";
 import { useLocale } from "react-aria";
 import { z } from "zod";

package/src/plugins/impl/chat/chat-ui.tsx

@@ -10,7 +10,6 @@ import {
   type TextUIPart,
   type UIMessageChunk,
 } from "ai";
-import { startCase } from "lodash-es";
 import {
   BotMessageSquareIcon,
   HelpCircleIcon,
@@ -57,6 +56,7 @@ import {
 import { cn } from "@/utils/cn";
 import { Logger } from "@/utils/Logger";
 import { Objects } from "@/utils/objects";
+import { Strings } from "@/utils/strings";
 import { ErrorBanner } from "../common/error-banner";
 import type { PluginFunctions } from "./ChatPlugin";
 import type { ChatConfig } from "./types";
@@ -670,7 +670,7 @@ const ConfigPopup: React.FC<{
                 htmlFor={key}
                 className="flex w-full justify-between col-span-3 align-end"
               >
-                {startCase(key)}
+                {Strings.startCase(key)}
                 <Tooltip
                   delayDuration={200}
                   side="top"

package/src/plugins/impl/data-editor/components.tsx

@@ -1,6 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { capitalize } from "lodash-es";
 import { PencilIcon, PlusIcon } from "lucide-react";
 import { useState } from "react";
 import { Button } from "@/components/ui/button";
@@ -20,6 +19,7 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import type { DataType } from "@/core/kernel/messages";
+import { capitalize } from "@/utils/strings";
 
 interface RenameColumnSubProps {
   currentColumnName: string;

package/src/plugins/impl/data-explorer/components/query-form.tsx

@@ -5,7 +5,6 @@ import { ExpandedType } from "compassql/build/src/query/expandedtype";
 import { PrimitiveType, type Schema } from "compassql/build/src/schema";
 import { SHORT_WILDCARD } from "compassql/build/src/wildcard";
 import { useAtomValue } from "jotai";
-import { startCase } from "lodash-es";
 import { FunctionSquareIcon } from "lucide-react";
 import React from "react";
 import { Label } from "@/components/ui/label";
@@ -19,6 +18,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { Strings } from "@/utils/strings";
 import type { EncodingChannel, FieldDefinition } from "../encoding";
 import {
   MULTI_TEMPORAL_FUNCTIONS,
@@ -281,7 +281,7 @@ const FieldOptions = ({
                 {label && <SelectLabel>{label}</SelectLabel>}
                 {fns.map((fn) => (
                   <SelectItem key={fn} value={fn ?? NONE_FN}>
-                    {startCase(fn)}
+                    {Strings.startCase(fn)}
                   </SelectItem>
                 ))}
               </SelectGroup>

package/src/plugins/impl/data-explorer/functions/types.ts

@@ -1,6 +1,5 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { isString } from "lodash-es";
 import type {
   ArgmaxDef,
   ArgminDef,
@@ -59,7 +58,7 @@ type SupportedAggregateOp = (typeof SUPPORTED_AGGREGATE_OPS)[number];
 export const isAggregateOp: typeof isAggregateOpVega = (
   a: string | ArgminDef | ArgmaxDef,
 ): a is AggregateOp => {
-  if (!isString(a)) {
+  if (typeof a !== "string") {
     return false;
   }
 

package/src/plugins/impl/data-frames/DataFramePlugin.tsx

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { isEqual } from "lodash-es";
+import { dequal as isEqual } from "dequal";
 import { Code2Icon, DatabaseIcon, FunctionSquareIcon } from "lucide-react";
 import {
   type JSX,

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

@@ -8,12 +8,13 @@ import type { Figure } from "./Plot";
 
 import "./plotly.css";
 import "./mapbox.css";
-import { pick, set } from "lodash-es";
+import { set } from "lodash-es";
 import { type JSX, lazy, memo, useMemo } from "react";
 import useEvent from "react-use-event-hook";
 import { useDeepCompareMemoize } from "@/hooks/useDeepCompareMemoize";
 import { useScript } from "@/hooks/useScript";
 import { Arrays } from "@/utils/arrays";
+import { Objects } from "@/utils/objects";
 import { createParser, type PlotlyTemplateParser } from "./parse-from-template";
 import { usePlotlyLayout } from "./usePlotlyLayout";
 
@@ -179,7 +180,9 @@ export const PlotlyComponent = memo(
 
           setValue((prev) => ({
             ...prev,
-            points: evt.points.map((point) => pick(point, TREE_MAP_DATA_KEYS)),
+            points: evt.points.map((point) =>
+              Objects.pick(point, TREE_MAP_DATA_KEYS),
+            ),
           }));
         })}
         onSunburstClick={useEvent((evt: Readonly<Plotly.PlotMouseEvent>) => {
@@ -189,7 +192,9 @@ export const PlotlyComponent = memo(
 
           setValue((prev) => ({
             ...prev,
-            points: evt.points.map((point) => pick(point, SUNBURST_DATA_KEYS)),
+            points: evt.points.map((point) =>
+              Objects.pick(point, SUNBURST_DATA_KEYS),
+            ),
           }));
         })}
         config={plotlyConfig}
@@ -264,7 +269,7 @@ function extractPoints(
   let parser: PlotlyTemplateParser | undefined;
 
   return points.map((point) => {
-    const standardPointFields = pick(point, STANDARD_POINT_KEYS);
+    const standardPointFields = Objects.pick(point, STANDARD_POINT_KEYS);
 
     // Get the first hovertemplate
     const hovertemplate = Array.isArray(point.data.hovertemplate)

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

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { usePrevious } from "@uidotdev/usehooks";
-import { isEqual, pick } from "lodash-es";
+import { dequal as isEqual } from "dequal";
 import type * as Plotly from "plotly.js";
 import { useEffect, useState } from "react";
 import { Objects } from "@/utils/objects";
@@ -50,7 +50,7 @@ export function computeLayoutOnFigureChange(
 ): Partial<Plotly.Layout> {
   return {
     ...createInitialLayout(nextFigure),
-    ...pick(prevLayout, PERSISTED_LAYOUT_KEYS),
+    ...Objects.pick(prevLayout, PERSISTED_LAYOUT_KEYS),
   };
 }
 

package/src/plugins/impl/vega/loader.ts

@@ -1,7 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { tableFromIPC } from "@uwdata/flechette";
-import { isNumber } from "lodash-es";
 import { Logger } from "@/utils/Logger";
 import { Objects } from "@/utils/objects";
 import { batchedArrowLoader, createBatchedLoader } from "./batched";
@@ -42,7 +41,9 @@ const BIG_INT_MIDDLEWARE: Middleware = () => {
     }
 
     const parsedInt = Number.parseInt(v, 10);
-    if (isNumber(parsedInt)) {
+    if (Number.isNaN(parsedInt)) {
+      return v;
+    } else {
       const needsBigInt = Math.abs(parsedInt) > Number.MAX_SAFE_INTEGER;
       if (!needsBigInt) {
         return previousIntegerParserWithoutNaN(v);
@@ -54,8 +55,6 @@ const BIG_INT_MIDDLEWARE: Middleware = () => {
         // as BigInt
         return previousIntegerParserWithoutNaN(v);
       }
-    } else {
-      return "";
     }
   };
   typeParsers.number = (v: string) => {

package/src/plugins/impl/vega/params.ts

@@ -1,8 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { uniq } from "lodash-es";
 import type { TopLevelSpec } from "vega-lite";
 import type { NonNormalizedSpec } from "vega-lite/types_unstable/spec/index.js";
+import { uniq } from "@/utils/arrays";
 import { Marks } from "./marks";
 import {
   type Field,

package/src/utils/__tests__/arrays.test.ts

@@ -9,6 +9,10 @@ import {
   arrayShallowEquals,
   arrayToggle,
   getNextIndex,
+  partition,
+  range,
+  sortBy,
+  uniq,
 } from "../arrays";
 
 describe("arrays", () => {
@@ -130,6 +134,120 @@ describe("arrays", () => {
   });
 });
 
+describe("range", () => {
+  it("should create an array of numbers from 0 to length - 1", () => {
+    expect(range(5)).toEqual([0, 1, 2, 3, 4]);
+  });
+
+  it("should return empty array for 0", () => {
+    expect(range(0)).toEqual([]);
+  });
+
+  it("should return single element for 1", () => {
+    expect(range(1)).toEqual([0]);
+  });
+});
+
+describe("uniq", () => {
+  it("should remove duplicate numbers", () => {
+    expect(uniq([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
+  });
+
+  it("should remove duplicate strings", () => {
+    expect(uniq(["a", "b", "a", "c"])).toEqual(["a", "b", "c"]);
+  });
+
+  it("should handle empty array", () => {
+    expect(uniq([])).toEqual([]);
+  });
+
+  it("should preserve order of first occurrence", () => {
+    expect(uniq([3, 1, 2, 1, 3])).toEqual([3, 1, 2]);
+  });
+});
+
+describe("sortBy", () => {
+  it("should sort by a numeric key", () => {
+    const items = [{ n: 3 }, { n: 1 }, { n: 2 }];
+    expect(sortBy(items, (x) => x.n)).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
+  });
+
+  it("should sort by a string key", () => {
+    const items = [{ name: "charlie" }, { name: "alice" }, { name: "bob" }];
+    expect(sortBy(items, (x) => x.name)).toEqual([
+      { name: "alice" },
+      { name: "bob" },
+      { name: "charlie" },
+    ]);
+  });
+
+  it("should not mutate the original array", () => {
+    const arr = [3, 1, 2];
+    sortBy(arr, (x) => x);
+    expect(arr).toEqual([3, 1, 2]);
+  });
+
+  it("should handle empty array", () => {
+    expect(sortBy([], (x) => x)).toEqual([]);
+  });
+
+  it("should sort null/undefined keys last", () => {
+    const items = [
+      { name: "b", v: undefined },
+      { name: "a", v: 1 },
+      { name: "c", v: null },
+      { name: "d", v: 2 },
+    ];
+    const result = sortBy(items, (x) => x.v);
+    expect(result.map((x) => x.name)).toEqual(["a", "d", "b", "c"]);
+  });
+
+  it("should sort numeric keys correctly", () => {
+    const items = [{ v: 10 }, { v: 2 }, { v: 1 }, { v: 20 }];
+    expect(sortBy(items, (x) => x.v)).toEqual([
+      { v: 1 },
+      { v: 2 },
+      { v: 10 },
+      { v: 20 },
+    ]);
+  });
+});
+
+describe("partition", () => {
+  it("should split array by predicate", () => {
+    const [evens, odds] = partition([1, 2, 3, 4, 5], (n) => n % 2 === 0);
+    expect(evens).toEqual([2, 4]);
+    expect(odds).toEqual([1, 3, 5]);
+  });
+
+  it("should handle all matching", () => {
+    const [pass, fail] = partition([2, 4, 6], (n) => n % 2 === 0);
+    expect(pass).toEqual([2, 4, 6]);
+    expect(fail).toEqual([]);
+  });
+
+  it("should handle none matching", () => {
+    const [pass, fail] = partition([1, 3, 5], (n) => n % 2 === 0);
+    expect(pass).toEqual([]);
+    expect(fail).toEqual([1, 3, 5]);
+  });
+
+  it("should handle empty array", () => {
+    const [pass, fail] = partition([], () => true);
+    expect(pass).toEqual([]);
+    expect(fail).toEqual([]);
+  });
+
+  it("should work with string predicates", () => {
+    const [long, short] = partition(
+      ["hi", "hello", "yo", "greetings"],
+      (s) => s.length > 3,
+    );
+    expect(long).toEqual(["hello", "greetings"]);
+    expect(short).toEqual(["hi", "yo"]);
+  });
+});
+
 describe("getNextIndex", () => {
   it("should return 0 if listLength is 0", () => {
     expect(getNextIndex(null, 0, "up")).toBe(0);

package/src/utils/__tests__/objects.test.ts

@@ -260,4 +260,38 @@ describe("Objects", () => {
       expect(result).toEqual({ a: 1, b: 2 });
     });
   });
+
+  describe("pick", () => {
+    it("should pick specified keys", () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(Objects.pick(obj, ["a", "c"])).toEqual({ a: 1, c: 3 });
+    });
+
+    it("should omit keys not present on the object", () => {
+      const obj = { a: 1, b: 2 };
+      expect(Objects.pick(obj, ["a", "z"])).toEqual({ a: 1 });
+    });
+
+    it("should preserve undefined values for existing keys", () => {
+      const obj = { a: undefined, b: 2 };
+      const result = Objects.pick(obj, ["a", "b"]);
+      expect(result).toEqual({ a: undefined, b: 2 });
+      expect("a" in result).toBe(true);
+    });
+
+    it("should not pick inherited properties", () => {
+      const parent = { inherited: true };
+      const obj = Object.create(parent);
+      obj.own = 1;
+      expect(Objects.pick(obj, ["own", "inherited"])).toEqual({ own: 1 });
+    });
+
+    it("should return empty object when picking no keys", () => {
+      expect(Objects.pick({ a: 1 }, [])).toEqual({});
+    });
+
+    it("should handle empty object", () => {
+      expect(Objects.pick({}, ["a"])).toEqual({});
+    });
+  });
 });

package/src/utils/__tests__/strings.test.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { describe, expect, it } from "vitest";
-import { decodeUtf8, Strings } from "../strings";
+import { capitalize, decodeUtf8, Strings } from "../strings";
 
 describe("Strings", () => {
   describe("startCase", () => {
@@ -58,6 +58,32 @@ describe("Strings", () => {
   });
 });
 
+describe("capitalize", () => {
+  it("capitalizes the first character", () => {
+    expect(capitalize("hello")).toBe("Hello");
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(capitalize("")).toBe("");
+  });
+
+  it("handles already-capitalized strings", () => {
+    expect(capitalize("Hello")).toBe("Hello");
+  });
+
+  it("handles single character", () => {
+    expect(capitalize("a")).toBe("A");
+  });
+
+  it("preserves the rest of the string", () => {
+    expect(capitalize("hELLO")).toBe("HELLO");
+  });
+
+  it("handles non-letter first character", () => {
+    expect(capitalize("123abc")).toBe("123abc");
+  });
+});
+
 describe("decodeUtf8", () => {
   it("decodes UTF-8 array to string", () => {
     const encoder = new TextEncoder();

package/src/utils/arrays.ts

@@ -61,6 +61,73 @@ export const Arrays = {
   },
 };
 
+/**
+ * Create an array of numbers from 0 to length - 1.
+ */
+export function range(length: number): number[] {
+  return Array.from({ length }, (_, i) => i);
+}
+
+/**
+ * Remove duplicate values from an array.
+ */
+export function uniq<T>(arr: readonly T[]): T[] {
+  return [...new Set(arr)];
+}
+
+/**
+ * Sort an array by a key function, returning a new array.
+ */
+export function sortBy<T>(
+  arr: readonly T[],
+  key: (item: T) => string | number | undefined | null,
+): T[] {
+  // Decorate/sort/undecorate to compute keys once per element
+  return arr
+    .map((item) => [key(item), item] as const)
+    .sort(([ka], [kb]) => {
+      // Nullish values sort last
+      if (ka == null && kb == null) {
+        return 0;
+      }
+      if (ka == null) {
+        return 1;
+      }
+      if (kb == null) {
+        return -1;
+      }
+      if (ka < kb) {
+        return -1;
+      }
+      if (ka > kb) {
+        return 1;
+      }
+      return 0;
+    })
+    .map(([, item]) => item);
+}
+
+/**
+ * Split an array into two groups based on a predicate.
+ * Returns [pass, fail] where pass contains items that match
+ * and fail contains items that don't.
+ */
+export function partition<T>(
+  arr: readonly T[],
+  predicate: (item: T) => boolean,
+): [T[], T[]] {
+  const pass: T[] = [];
+  const fail: T[] = [];
+  for (const item of arr) {
+    if (predicate(item)) {
+      pass.push(item);
+    } else {
+      fail.push(item);
+    }
+  }
+  return [pass, fail];
+}
+
 export function arrayToggle<T>(arr: T[], item: T): T[] {
   if (!arr) {
     return [item];

package/src/utils/objects.ts

@@ -105,4 +105,18 @@ export const Objects = {
     const set = new Set<K>(keys);
     return Objects.filter(obj, (_, key) => !set.has(key));
   },
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  pick<V extends Record<string, any>, K extends string>(
+    obj: V,
+    keys: readonly K[],
+  ): Pick<V, K & keyof V> {
+    const result = {} as Record<string, unknown>;
+    for (const key of keys) {
+      if (Object.hasOwn(obj, key)) {
+        result[key] = obj[key];
+      }
+    }
+    return result as Pick<V, K & keyof V>;
+  },
 };