@lumikmz/kmz 0.10.0 → 0.11.1

package/src/plan/plan-target-detection.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 import { degrees, meters, metersPerSecond } from "../types/branded.js";
 import type { TargetDetectionTemplate } from "../types/template.js";
 import { plan } from "./index.js";
@@ -54,6 +54,49 @@ function template(overrides: { pitch?: number; direction?: number } = {}): Targe
 }
 
 describe("plan(targetdetection)", () => {
+  it("matches FlightHub recording and target-detection actions without stopRecord", () => {
+    const input = template();
+    Object.assign(input.Folder.Placemark, {
+      recordEnable: true,
+      targetDetectionActionEnable: true,
+      action: {
+        actionId: 0,
+        actionActuatorFunc: "targetDetection",
+        actionActuatorFuncParam: {
+          focalLength: 70,
+          payloadPositionIndex: 0,
+          useGlobalPayloadLensIndex: false,
+          payloadLensIndex: ["visable"],
+          actionUUID: "test-target-detection",
+          customTitle: "巡逻",
+          customText: "检测到异常目标",
+          modelIndex: 0,
+          modelScore: 55,
+          alarmInterval: 2,
+          useThirdModel: false,
+          algorithmType: "visable_ai",
+          targetParam: {
+            maxThreshold: 10,
+            minThreshold: 10,
+            useMaxThreshold: false,
+            useMinThreshold: true,
+            targetType: "person",
+          },
+        },
+      },
+    });
+
+    const folder = plan(input, { lineSpacing: meters(25) }).Folder[0]!;
+    const startFuncs = folder.startActionGroup!.action.map((a) => a.actionActuatorFunc);
+    const routeFuncs = folder.Placemark[0]!.actionGroup![0]!.action.map(
+      (a) => a.actionActuatorFunc,
+    );
+
+    expect(startFuncs).toEqual(["gimbalRotate", "startRecord"]);
+    expect(routeFuncs).toEqual(["gimbalRotate", "startRecord", "targetDetection"]);
+    expect(JSON.stringify(folder)).not.toContain("stopRecord");
+  });
+
   it("centers floor(width / spacing) scan lines", () => {
     const waylines = plan(template(), { lineSpacing: meters(25) });
 

package/src/plan/plan-target-detection.ts

@@ -1,4 +1,5 @@
 import { degrees, meters, type LngLat, type Meters } from "../types/branded.js";
+import type { Action } from "../types/action.js";
 import { PlannerError } from "../types/errors.js";
 import type { ExecuteHeightMode } from "../types/enums.js";
 import type { WaylinesPlacemark } from "../types/placemark.js";
@@ -59,6 +60,18 @@ function gimbalAction(pitch: number) {
   };
 }
 
+function startRecordAction(payloadPositionIndex: number, actionId: number) {
+  return {
+    actionId,
+    actionActuatorFunc: "startRecord" as const,
+    actionActuatorFuncParam: {
+      payloadPositionIndex,
+      useGlobalPayloadLensIndex: true,
+      payloadLensIndex: ["visable" as const],
+    },
+  };
+}
+
 function pathPoints(
   template: TargetDetectionTemplate,
   lineSpacingM: number,
@@ -143,6 +156,14 @@ export function planTargetDetection(
   if (points.length < 2) throw new PlannerError("targetdetection polygon produced no flight path");
   const lastIndex = points.length - 1;
   const action = gimbalAction(pitch);
+  const payloadPositionIndex = folder.payloadParam?.payloadPositionIndex ?? 0;
+  const routeActions: Action[] = [action];
+  if (folder.Placemark.recordEnable) {
+    routeActions.push(startRecordAction(payloadPositionIndex, routeActions.length));
+  }
+  if (folder.Placemark.action) {
+    routeActions.push({ ...folder.Placemark.action, actionId: routeActions.length });
+  }
 
   const placemarks: WaylinesPlacemark[] = points.map((point, index) => ({
     Point: { coordinates: point },
@@ -185,7 +206,7 @@ export function planTargetDetection(
               actionGroupEndIndex: lastIndex,
               actionGroupMode: "sequence",
               actionTrigger: { actionTriggerType: "betweenAdjacentPointsIncludeFirstPoint" },
-              action: [action],
+              action: routeActions,
             },
           ],
         }
@@ -200,7 +221,11 @@ export function planTargetDetection(
         waylineId: 0,
         executeHeightMode: executeHeightMode(folder),
         autoFlightSpeed: folder.autoFlightSpeed,
-        startActionGroup: { action: [gimbalAction(pitch)] },
+        startActionGroup: {
+          action: folder.Placemark.recordEnable
+            ? [gimbalAction(pitch), startRecordAction(payloadPositionIndex, 1)]
+            : [gimbalAction(pitch)],
+        },
         Placemark: placemarks,
       },
     ],

package/src/plan/plan.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 import { degrees, meters, metersPerSecond } from "../types/branded.js";
 import { DroneEnum, PayloadEnum } from "../types/drone-payload.js";
 import type { Mapping2dTemplate, Mapping3dTemplate, WaypointTemplate } from "../types/template.js";

package/src/plan/strip-route-order.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, it } from "vite-plus/test";
+import { selectStripRouteCandidates, type StripRouteCandidate } from "./strip-route-order.js";
+import * as stripOrder from "./strip-route-order.js";
+
+function route(patch: Partial<StripRouteCandidate> = {}): StripRouteCandidate {
+  return {
+    start: [0, 0],
+    end: [10, 0],
+    entryDirection: [1, 0],
+    exitDirection: [1, 0],
+    length: 10,
+    ...patch,
+  };
+}
+
+describe("strip region transition ordering", () => {
+  it("chooses a slightly longer transfer when it avoids reversing the entry heading", () => {
+    const previous = route({ end: [0, 0] });
+    const reverse = route({ start: [10, 0], entryDirection: [-1, 0] });
+    const aligned = route({ start: [12, 0] });
+    expect(selectStripRouteCandidates([[previous], [reverse, aligned]])).toEqual([0, 1]);
+  });
+
+  it("prefers approaching the shared junction over cutting across a bent strip", () => {
+    const diagonal = Math.SQRT1_2;
+    const previous = route({ end: [0, 0], exitDirection: [diagonal, diagonal] });
+    const across = route({ start: [10, 0], entryDirection: [1, 0] });
+    const along = route({ start: [0, 12], entryDirection: [0, 1] });
+    expect(selectStripRouteCandidates([[previous], [across, along]], undefined, [[0, 10]])).toEqual(
+      [0, 1],
+    );
+  });
+
+  it("includes the candidate's internal flight length", () => {
+    expect(selectStripRouteCandidates([[route({ length: 100 }), route({ length: 10 })]])).toEqual([
+      1,
+    ]);
+  });
+
+  it("keeps heading preferences soft when the aligned transfer would be much longer", () => {
+    const previous = route({ end: [0, 0] });
+    expect(
+      selectStripRouteCandidates([
+        [previous],
+        [route({ start: [10, 0], entryDirection: [-1, 0] }), route({ start: [100, 0] })],
+      ]),
+    ).toEqual([0, 0]);
+  });
+
+  it("uses the exit and entry headings even when the endpoints coincide", () => {
+    const previous = route({ end: [0, 0] });
+    expect(
+      selectStripRouteCandidates([[previous], [route({ entryDirection: [-1, 0] }), route()]]),
+    ).toEqual([0, 1]);
+  });
+
+  it("optimizes the entire sequence instead of taking the locally closest start", () => {
+    const first = route({ end: [0, 0] });
+    const near = route({ start: [1, 0], end: [100, 0] });
+    const connected = route({ start: [2, 0], end: [5, 0] });
+    const last = route({ start: [6, 0] });
+    expect(selectStripRouteCandidates([[first], [near, connected], [last]])).toEqual([0, 1, 0]);
+  });
+
+  it("uses the takeoff point when selecting the first orientation", () => {
+    expect(selectStripRouteCandidates([[route({ start: [100, 0] }), route()]], [0, 0])).toEqual([
+      1,
+    ]);
+  });
+
+  it("handles coincident region endpoints without undefined directions", () => {
+    const groups = [[route({ end: [0, 0] })], [route(), route()]];
+    expect(selectStripRouteCandidates(groups, undefined, [[0, 0]])).toEqual([0, 0]);
+    expect(selectStripRouteCandidates([])).toEqual([]);
+  });
+
+  it("includes the final home leg only when the finish action requests it", () => {
+    const groups = [[route({ end: [100, 0], length: 100 }), route({ end: [1, 0], length: 101 })]];
+    expect(
+      selectStripRouteCandidates(groups, [0, 0], [], {
+        flightSpeed: 1,
+        transitSpeed: 1,
+        finishAction: "goHome",
+      }),
+    ).toEqual([1]);
+    for (const finishAction of ["noAction", "autoLand"] as const) {
+      expect(
+        selectStripRouteCandidates(groups, [0, 0], [], {
+          flightSpeed: 1,
+          transitSpeed: 1,
+          finishAction,
+        }),
+      ).toEqual([0]);
+    }
+  });
+
+  it("uses different survey and transit speeds instead of minimizing distance", () => {
+    const groups = [
+      [route({ end: [0, 0], length: 200 }), route({ start: [100, 0], end: [200, 0], length: 100 })],
+    ];
+    expect(
+      selectStripRouteCandidates(groups, [0, 0], [], {
+        flightSpeed: 1,
+        transitSpeed: 10,
+        finishAction: "noAction",
+      }),
+    ).toEqual([1]);
+    expect(
+      selectStripRouteCandidates(groups, [0, 0], [], {
+        flightSpeed: 1,
+        transitSpeed: 1,
+        finishAction: "noAction",
+      }),
+    ).toEqual([0]);
+  });
+
+  it("prefers the nearer entry when total flying times differ by at most two seconds", () => {
+    expect(
+      selectStripRouteCandidates(
+        [
+          [
+            route({ start: [100, 0], end: [200, 0], length: 100 }),
+            route({ start: [0, 0], end: [210, 0], length: 210 }),
+          ],
+        ],
+        [0, 0],
+        [],
+        { flightSpeed: 10, transitSpeed: 10, finishAction: "noAction" },
+      ),
+    ).toEqual([1]);
+  });
+
+  it("does not sacrifice a substantial time saving just to start closer", () => {
+    expect(
+      selectStripRouteCandidates(
+        [
+          [
+            route({ start: [100, 0], end: [200, 0], length: 100 }),
+            route({ start: [0, 0], end: [250, 0], length: 250 }),
+          ],
+        ],
+        [0, 0],
+        [],
+        { flightSpeed: 10, transitSpeed: 10, finishAction: "noAction" },
+      ),
+    ).toEqual([0]);
+  });
+
+  it("retains the nearer first entry after both paths reach the same later candidates", () => {
+    const groups = [
+      [
+        route({
+          start: [100, 0],
+          end: [0, 0],
+          entryDirection: [-1, 0],
+          exitDirection: [-1, 0],
+          length: 100,
+        }),
+        route({ end: [0, 0], length: 120 }),
+      ],
+      [route({ start: [0, 0], end: [100, 0], length: 100 })],
+      [route({ start: [100, 0], end: [200, 0], length: 100 })],
+    ];
+    expect(
+      selectStripRouteCandidates(groups, [0, 0], [], {
+        flightSpeed: 10,
+        transitSpeed: 100,
+        finishAction: "goHome",
+      }),
+    ).toEqual([1, 0, 0]);
+  });
+
+  it("applies the two-second tolerance once to the complete mission, not once per region", () => {
+    const groups = [[route({ end: [0, 0], length: 100 })]];
+    for (let index = 0; index < 4; index++)
+      groups.push([
+        route({ end: [0, 0], length: 100, entryDirection: [-1, 0], exitDirection: [-1, 0] }),
+        route({ end: [0, 0], length: 101.5 }),
+      ]);
+    const selected = selectStripRouteCandidates(groups);
+    const duration = groups.reduce((sum, group, index) => sum + group[selected[index]!]!.length, 0);
+    expect(duration).toBeLessThanOrEqual(502);
+  });
+
+  it("returns to the first waypoint without needing a takeoff reference", () => {
+    const groups = [[route({ end: [100, 0], length: 100 }), route({ end: [1, 0], length: 101 })]];
+    expect(
+      selectStripRouteCandidates(groups, undefined, [], {
+        flightSpeed: 1,
+        transitSpeed: 1,
+        finishAction: "gotoFirstWaypoint",
+      }),
+    ).toEqual([1]);
+    expect(
+      selectStripRouteCandidates(groups, undefined, [], {
+        flightSpeed: 1,
+        transitSpeed: 1,
+        finishAction: "goHome",
+      }),
+    ).toEqual([0]);
+  });
+
+  it("measures survey, ingress, between-region and finish legs with their respective speeds", () => {
+    const routes = [
+      route({ start: [10, 0], end: [30, 0], length: 20 }),
+      route({ start: [50, 0], end: [80, 0], length: 30 }),
+    ];
+    for (const [finishAction, distance, duration] of [
+      ["goHome", 160, 10.5],
+      ["noAction", 80, 6.5],
+      ["gotoFirstWaypoint", 150, 10],
+    ] as const) {
+      expect(
+        stripOrder.measureStripMission(routes, [0, 0], {
+          flightSpeed: 10,
+          transitSpeed: 20,
+          finishAction,
+        }),
+      ).toMatchObject({ distance, duration });
+    }
+  });
+
+  it("rejects invalid speeds instead of producing non-finite costs", () => {
+    for (const speed of [0, -1, NaN, Infinity]) {
+      expect(() =>
+        selectStripRouteCandidates([[route()]], [0, 0], [], {
+          flightSpeed: speed,
+          transitSpeed: 10,
+          finishAction: "goHome",
+        }),
+      ).toThrow();
+      expect(() =>
+        selectStripRouteCandidates([[route()]], [0, 0], [], {
+          flightSpeed: 10,
+          transitSpeed: speed,
+          finishAction: "goHome",
+        }),
+      ).toThrow();
+    }
+  });
+});

package/src/plan/strip-route-order.ts

@@ -0,0 +1,192 @@
+import type { EnuPoint } from "./geometry.js";
+import type { FinishAction } from "../types/enums.js";
+import { PlannerError } from "../types/errors.js";
+
+// Secondary route-shape preferences, never added to the estimated flying time.
+// A complete reversal costs 20 preference units; junction detours remain soft.
+const HEADING_COST_M = 10;
+const JUNCTION_DETOUR_WEIGHT = 0.5;
+const NEAR_EQUAL_TIME_S = 2;
+const TIME_EPS_S = 1e-8;
+
+const distance = (a: EnuPoint, b: EnuPoint) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+const headingChange = (a: EnuPoint, b: EnuPoint) =>
+  1 - Math.max(-1, Math.min(1, a[0] * b[0] + a[1] * b[1]));
+
+export interface StripRouteCandidate {
+  start: EnuPoint;
+  end: EnuPoint;
+  entryDirection: EnuPoint;
+  exitDirection: EnuPoint;
+  length: number;
+}
+
+export interface StripRouteTiming {
+  flightSpeed: number;
+  transitSpeed: number;
+  finishAction: FinishAction;
+}
+
+const DEFAULT_TIMING: StripRouteTiming = {
+  flightSpeed: 1,
+  transitSpeed: 1,
+  finishAction: "noAction",
+};
+
+function validateTiming(timing: StripRouteTiming): void {
+  if (
+    ![timing.flightSpeed, timing.transitSpeed].every((speed) => Number.isFinite(speed) && speed > 0)
+  )
+    throw new PlannerError(
+      "mappingStrip flight and transit speeds must be finite and greater than zero",
+    );
+}
+
+function finishDistance(
+  end: EnuPoint,
+  first: EnuPoint,
+  home: EnuPoint | undefined,
+  finish: FinishAction,
+): number {
+  const target = finish === "goHome" ? home : finish === "gotoFirstWaypoint" ? first : undefined;
+  return target ? distance(end, target) : 0;
+}
+
+/** Horizontal-flight estimate; vertical motion, wind and acceleration are not modeled. */
+export function measureStripMission(
+  routes: readonly Pick<StripRouteCandidate, "start" | "end" | "length">[],
+  home: EnuPoint | undefined,
+  timing: StripRouteTiming,
+): { distance: number; duration: number } {
+  validateTiming(timing);
+  if (routes.length === 0) return { distance: 0, duration: 0 };
+  const first = routes[0]!.start;
+  const workLength = routes.reduce((sum, route) => sum + route.length, 0);
+  let transitLength = home ? distance(home, first) : 0;
+  for (let index = 1; index < routes.length; index++)
+    transitLength += distance(routes[index - 1]!.end, routes[index]!.start);
+  transitLength += finishDistance(routes.at(-1)!.end, first, home, timing.finishAction);
+  return {
+    distance: workLength + transitLength,
+    duration: workLength / timing.flightSpeed + transitLength / timing.transitSpeed,
+  };
+}
+
+function transitionPreference(
+  previous: StripRouteCandidate,
+  next: StripRouteCandidate,
+  junction?: EnuPoint,
+): number {
+  const length = distance(previous.end, next.start);
+  const direction: EnuPoint | undefined =
+    length > 0.05
+      ? [(next.start[0] - previous.end[0]) / length, (next.start[1] - previous.end[1]) / length]
+      : undefined;
+  const turn = direction
+    ? headingChange(previous.exitDirection, direction) +
+      headingChange(direction, next.entryDirection)
+    : headingChange(previous.exitDirection, next.entryDirection);
+  const detour = junction
+    ? Math.max(0, distance(previous.end, junction) + distance(junction, next.start) - length)
+    : 0;
+  return HEADING_COST_M * turn + JUNCTION_DETOUR_WEIGHT * detour;
+}
+
+interface FinalChoice {
+  lastIndex: number;
+  time: number;
+  preference: number;
+  ingress: number;
+  back: number[][];
+}
+
+/** Optimize mission time, then favor nearer entries within a two-second total budget. */
+export function selectStripRouteCandidates(
+  groups: readonly (readonly StripRouteCandidate[])[],
+  home?: EnuPoint,
+  junctions: readonly EnuPoint[] = [],
+  timing: StripRouteTiming = DEFAULT_TIMING,
+): number[] {
+  if (groups.length === 0) return [];
+  validateTiming(timing);
+  if (groups.some((group) => group.length === 0))
+    throw new PlannerError("mappingStrip region has no route candidates");
+  const finals: FinalChoice[] = [];
+
+  // Keep each possible first entry separate. Otherwise a local near-equal-time
+  // tie can discard the globally fastest path or accumulate a tolerance per cut.
+  groups[0]!.forEach((first, firstIndex) => {
+    const ingress = home ? distance(home, first.start) : 0;
+    let times = groups[0]!.map((candidate, index) =>
+      index === firstIndex
+        ? candidate.length / timing.flightSpeed + ingress / timing.transitSpeed
+        : Infinity,
+    );
+    let preferences = groups[0]!.map((_, index) => (index === firstIndex ? 0 : Infinity));
+    const back = [groups[0]!.map(() => -1)];
+    for (let index = 1; index < groups.length; index++) {
+      const parents: number[] = [];
+      const nextPreferences: number[] = [];
+      const nextTimes = groups[index]!.map((candidate) => {
+        let bestTime = Infinity;
+        let bestPreference = Infinity;
+        let parent = 0;
+        groups[index - 1]!.forEach((previous, previousIndex) => {
+          const time =
+            times[previousIndex]! +
+            candidate.length / timing.flightSpeed +
+            distance(previous.end, candidate.start) / timing.transitSpeed;
+          const preference =
+            preferences[previousIndex]! +
+            transitionPreference(previous, candidate, junctions[index - 1]);
+          if (
+            time < bestTime - TIME_EPS_S ||
+            (Math.abs(time - bestTime) <= TIME_EPS_S && preference < bestPreference)
+          ) {
+            bestTime = time;
+            bestPreference = preference;
+            parent = previousIndex;
+          }
+        });
+        parents.push(parent);
+        nextPreferences.push(bestPreference);
+        return bestTime;
+      });
+      times = nextTimes;
+      preferences = nextPreferences;
+      back.push(parents);
+    }
+    groups.at(-1)!.forEach((last, lastIndex) => {
+      if (!Number.isFinite(times[lastIndex])) return;
+      finals.push({
+        lastIndex,
+        ingress,
+        back,
+        time:
+          times[lastIndex]! +
+          finishDistance(last.end, first.start, home, timing.finishAction) / timing.transitSpeed,
+        preference: preferences[lastIndex]!,
+      });
+    });
+  });
+  const fastest = Math.min(...finals.map((choice) => choice.time));
+  const close = finals.filter((choice) => choice.time <= fastest + NEAR_EQUAL_TIME_S + TIME_EPS_S);
+  const chosen = close.reduce((best, candidate) => {
+    if (candidate.ingress < best.ingress - 0.05) return candidate;
+    if (Math.abs(candidate.ingress - best.ingress) > 0.05) return best;
+    if (candidate.preference < best.preference - TIME_EPS_S) return candidate;
+    if (
+      Math.abs(candidate.preference - best.preference) <= TIME_EPS_S &&
+      candidate.time < best.time
+    )
+      return candidate;
+    return best;
+  });
+  let selected = chosen.lastIndex;
+  const result = groups.map(() => 0);
+  for (let index = groups.length - 1; index >= 0; index--) {
+    result[index] = selected;
+    selected = chosen.back[index]![selected]!;
+  }
+  return result;
+}

package/src/types/action.ts

@@ -34,6 +34,7 @@ export interface ActionTrigger {
 
 /** Discriminated by `actionActuatorFunc`. */
 export type Action =
+  | TargetDetectionAction
   | TakePhotoAction
   | StartRecordAction
   | StopRecordAction
@@ -64,6 +65,31 @@ interface ActionBase<F extends string, P> {
   actionActuatorFuncParam: P;
 }
 
+export interface TargetDetectionParam {
+  focalLength?: number;
+  payloadPositionIndex: number;
+  useGlobalPayloadLensIndex: boolean;
+  payloadLensIndex: LensType[];
+  actionUUID: string;
+  irGainMode?: string;
+  irColorPalette?: string;
+  customTitle: string;
+  customText: string;
+  modelIndex: number;
+  modelScore: number;
+  alarmInterval: number;
+  useThirdModel: boolean;
+  algorithmType: string;
+  targetParam: {
+    maxThreshold: number;
+    minThreshold: number;
+    useMaxThreshold: boolean;
+    useMinThreshold: boolean;
+    targetType: string;
+  };
+}
+export type TargetDetectionAction = ActionBase<"targetDetection", TargetDetectionParam>;
+
 // ─── Action params (one type per actionActuatorFunc) ─────────────────────────
 
 export interface TakePhotoParam {

package/src/types/drone-payload.ts

@@ -15,6 +15,8 @@ export interface PayloadInfo {
    */
   payloadSubEnumValue?: number;
   payloadPositionIndex: number;
+  /** FlightHub 2 patrol-camera selection, in 35mm-equivalent millimeters. */
+  equivalentFocalLength?: number;
 }
 
 /** Aircraft `{ droneEnumValue, droneSubEnumValue }` tuples. */

package/src/types/enums.ts

@@ -73,6 +73,7 @@ export type ActionTriggerType =
   | "multipleDistance";
 
 export type ActionActuatorFunc =
+  | "targetDetection"
   | "takePhoto"
   | "startRecord"
   | "stopRecord"

package/src/types/placemark.ts

@@ -1,5 +1,5 @@
 import type { Degrees, LngLat, Meters, MetersPerSecond } from "./branded.js";
-import type { ActionGroup } from "./action.js";
+import type { ActionGroup, TargetDetectionAction } from "./action.js";
 import type { ExecuteHeightMode, ShootType } from "./enums.js";
 import type {
   MappingHeadingParam,
@@ -127,6 +127,9 @@ export interface TargetDetectionPlacemark {
   mappingHeadingParam: MappingHeadingParam;
   gimbalPitchAngle: Degrees;
   recordEnable: boolean;
+  /** FlightHub 2 always emits this action for patrol-area routes. */
+  targetDetectionActionEnable?: boolean;
+  action?: TargetDetectionAction;
 }
 
 /** `Placemark` inside a `mappingStrip` Folder — uses a LineString; params live here. */

package/vite.config.ts

@@ -1,6 +1,13 @@
 import { defineConfig } from "vite-plus";
 
 export default defineConfig({
+  test: {
+    // Vitest v4 compatibility: preserve mock call history.
+    // Remove after tests no longer rely on calls from setup or earlier tests.
+    // https://viteplus.dev/guide/vitest-v5#remove-unneeded-compatibility-settings
+    // https://vitest.dev/guide/migration/#clearmocks-is-enabled-by-default
+    clearMocks: false,
+  },
   pack: {
     entry: ["src/index.ts"],
     format: "esm",