@ajclarkson/homerun 0.0.1-edge.0131fc6

package/dist/src/services.d.ts

@@ -0,0 +1,178 @@
+import type { Action } from './types/actions.js';
+type Target = {
+    entity_id: string;
+};
+export interface LightTurnOnData {
+    transition?: number;
+    brightness_pct?: number;
+    brightness?: number;
+    color_temp_kelvin?: number;
+    rgb_color?: [number, number, number];
+    effect?: string;
+}
+export type HvacMode = 'off' | 'heat' | 'cool' | 'heat_cool' | 'auto' | 'dry' | 'fan_only';
+export interface ClimateSetTemperatureData {
+    temperature?: number;
+    target_temp_high?: number;
+    target_temp_low?: number;
+    hvac_mode?: HvacMode;
+}
+export interface CoverSetPositionData {
+    position: number;
+}
+export interface CoverSetTiltPositionData {
+    tilt_position: number;
+}
+export type MediaPlayerEnqueue = 'next' | 'add' | 'play' | 'replace';
+export type MediaPlayerRepeat = 'off' | 'all' | 'one';
+export interface MediaPlayerPlayMediaData {
+    media_content_id: string;
+    media_content_type: string;
+    enqueue?: MediaPlayerEnqueue;
+    announce?: boolean;
+}
+export type AlarmCode = {
+    code?: string;
+};
+export declare const HomeAssistant: {
+    readonly light: {
+        readonly turn_on: (target: Target, data?: LightTurnOnData) => Action;
+        readonly turn_off: (target: Target, data?: {
+            transition?: number;
+        }) => Action;
+        readonly toggle: (target: Target, data?: LightTurnOnData) => Action;
+    };
+    readonly switch: {
+        readonly turn_on: (target: Target) => Action;
+        readonly turn_off: (target: Target) => Action;
+        readonly toggle: (target: Target) => Action;
+    };
+    readonly cover: {
+        readonly open_cover: (target: Target) => Action;
+        readonly close_cover: (target: Target) => Action;
+        readonly stop_cover: (target: Target) => Action;
+        readonly toggle: (target: Target) => Action;
+        readonly set_cover_position: (target: Target, data: CoverSetPositionData) => Action;
+        readonly set_cover_tilt_position: (target: Target, data: CoverSetTiltPositionData) => Action;
+    };
+    readonly fan: {
+        readonly turn_on: (target: Target, data?: {
+            percentage?: number;
+            preset_mode?: string;
+        }) => Action;
+        readonly turn_off: (target: Target) => Action;
+        readonly toggle: (target: Target) => Action;
+        readonly set_percentage: (target: Target, data: {
+            percentage: number;
+        }) => Action;
+        readonly set_preset_mode: (target: Target, data: {
+            preset_mode: string;
+        }) => Action;
+        readonly increase_speed: (target: Target) => Action;
+        readonly decrease_speed: (target: Target) => Action;
+    };
+    readonly lock: {
+        readonly lock: (target: Target, data?: AlarmCode) => Action;
+        readonly unlock: (target: Target, data?: AlarmCode) => Action;
+        readonly open: (target: Target, data?: AlarmCode) => Action;
+    };
+    readonly climate: {
+        readonly turn_on: (target: Target) => Action;
+        readonly turn_off: (target: Target) => Action;
+        readonly set_hvac_mode: (target: Target, data: {
+            hvac_mode: HvacMode;
+        }) => Action;
+        readonly set_temperature: (target: Target, data: ClimateSetTemperatureData) => Action;
+        readonly set_preset_mode: (target: Target, data: {
+            preset_mode: string;
+        }) => Action;
+        readonly set_fan_mode: (target: Target, data: {
+            fan_mode: string;
+        }) => Action;
+        readonly set_humidity: (target: Target, data: {
+            humidity: number;
+        }) => Action;
+    };
+    readonly media_player: {
+        readonly turn_on: (target: Target) => Action;
+        readonly turn_off: (target: Target) => Action;
+        readonly toggle: (target: Target) => Action;
+        readonly media_play: (target: Target) => Action;
+        readonly media_pause: (target: Target) => Action;
+        readonly media_play_pause: (target: Target) => Action;
+        readonly media_stop: (target: Target) => Action;
+        readonly media_next_track: (target: Target) => Action;
+        readonly media_previous_track: (target: Target) => Action;
+        readonly volume_up: (target: Target) => Action;
+        readonly volume_down: (target: Target) => Action;
+        readonly volume_set: (target: Target, data: {
+            volume_level: number;
+        }) => Action;
+        readonly volume_mute: (target: Target, data: {
+            is_volume_muted: boolean;
+        }) => Action;
+        readonly select_source: (target: Target, data: {
+            source: string;
+        }) => Action;
+        readonly shuffle_set: (target: Target, data: {
+            shuffle: boolean;
+        }) => Action;
+        readonly repeat_set: (target: Target, data: {
+            repeat: MediaPlayerRepeat;
+        }) => Action;
+        readonly play_media: (target: Target, data: MediaPlayerPlayMediaData) => Action;
+    };
+    readonly alarm_control_panel: {
+        readonly arm_away: (target: Target, data?: AlarmCode) => Action;
+        readonly arm_home: (target: Target, data?: AlarmCode) => Action;
+        readonly arm_night: (target: Target, data?: AlarmCode) => Action;
+        readonly arm_vacation: (target: Target, data?: AlarmCode) => Action;
+        readonly disarm: (target: Target, data?: AlarmCode) => Action;
+        readonly trigger: (target: Target, data?: AlarmCode) => Action;
+    };
+    readonly scene: {
+        readonly turn_on: (target: Target, data?: {
+            transition?: number;
+        }) => Action;
+    };
+    readonly input_boolean: {
+        readonly turn_on: (target: Target) => Action;
+        readonly turn_off: (target: Target) => Action;
+        readonly toggle: (target: Target) => Action;
+    };
+    readonly input_number: {
+        readonly set_value: (target: Target, data: {
+            value: number;
+        }) => Action;
+        readonly increment: (target: Target) => Action;
+        readonly decrement: (target: Target) => Action;
+        readonly set_min: (target: Target) => Action;
+        readonly set_max: (target: Target) => Action;
+    };
+    readonly input_select: {
+        readonly select_option: (target: Target, data: {
+            option: string;
+        }) => Action;
+        readonly select_next: (target: Target) => Action;
+        readonly select_previous: (target: Target) => Action;
+        readonly set_options: (target: Target, data: {
+            options: string[];
+        }) => Action;
+    };
+    readonly button: {
+        readonly press: (target: Target) => Action;
+    };
+    readonly number: {
+        readonly set_value: (target: Target, data: {
+            value: number;
+        }) => Action;
+    };
+    readonly select: {
+        readonly select_option: (target: Target, data: {
+            option: string;
+        }) => Action;
+        readonly select_next: (target: Target) => Action;
+        readonly select_previous: (target: Target) => Action;
+    };
+};
+export {};

package/dist/src/services.js

@@ -0,0 +1,106 @@
+function svc(domain, service, target, data) {
+    return { type: 'ha.call_service', domain, service, ...(target && { target }), ...(data !== undefined ? { data: data } : {}) };
+}
+// ---------- HomeAssistant ----------
+export const HomeAssistant = {
+    light: {
+        turn_on: (target, data) => svc('light', 'turn_on', target, data),
+        turn_off: (target, data) => svc('light', 'turn_off', target, data),
+        toggle: (target, data) => svc('light', 'toggle', target, data),
+    },
+    switch: {
+        turn_on: (target) => svc('switch', 'turn_on', target),
+        turn_off: (target) => svc('switch', 'turn_off', target),
+        toggle: (target) => svc('switch', 'toggle', target),
+    },
+    cover: {
+        open_cover: (target) => svc('cover', 'open_cover', target),
+        close_cover: (target) => svc('cover', 'close_cover', target),
+        stop_cover: (target) => svc('cover', 'stop_cover', target),
+        toggle: (target) => svc('cover', 'toggle', target),
+        set_cover_position: (target, data) => svc('cover', 'set_cover_position', target, data),
+        set_cover_tilt_position: (target, data) => svc('cover', 'set_cover_tilt_position', target, data),
+    },
+    fan: {
+        turn_on: (target, data) => svc('fan', 'turn_on', target, data),
+        turn_off: (target) => svc('fan', 'turn_off', target),
+        toggle: (target) => svc('fan', 'toggle', target),
+        set_percentage: (target, data) => svc('fan', 'set_percentage', target, data),
+        set_preset_mode: (target, data) => svc('fan', 'set_preset_mode', target, data),
+        increase_speed: (target) => svc('fan', 'increase_speed', target),
+        decrease_speed: (target) => svc('fan', 'decrease_speed', target),
+    },
+    lock: {
+        lock: (target, data) => svc('lock', 'lock', target, data),
+        unlock: (target, data) => svc('lock', 'unlock', target, data),
+        open: (target, data) => svc('lock', 'open', target, data),
+    },
+    climate: {
+        turn_on: (target) => svc('climate', 'turn_on', target),
+        turn_off: (target) => svc('climate', 'turn_off', target),
+        set_hvac_mode: (target, data) => svc('climate', 'set_hvac_mode', target, data),
+        set_temperature: (target, data) => svc('climate', 'set_temperature', target, data),
+        set_preset_mode: (target, data) => svc('climate', 'set_preset_mode', target, data),
+        set_fan_mode: (target, data) => svc('climate', 'set_fan_mode', target, data),
+        set_humidity: (target, data) => svc('climate', 'set_humidity', target, data),
+    },
+    media_player: {
+        turn_on: (target) => svc('media_player', 'turn_on', target),
+        turn_off: (target) => svc('media_player', 'turn_off', target),
+        toggle: (target) => svc('media_player', 'toggle', target),
+        media_play: (target) => svc('media_player', 'media_play', target),
+        media_pause: (target) => svc('media_player', 'media_pause', target),
+        media_play_pause: (target) => svc('media_player', 'media_play_pause', target),
+        media_stop: (target) => svc('media_player', 'media_stop', target),
+        media_next_track: (target) => svc('media_player', 'media_next_track', target),
+        media_previous_track: (target) => svc('media_player', 'media_previous_track', target),
+        volume_up: (target) => svc('media_player', 'volume_up', target),
+        volume_down: (target) => svc('media_player', 'volume_down', target),
+        volume_set: (target, data) => svc('media_player', 'volume_set', target, data),
+        volume_mute: (target, data) => svc('media_player', 'volume_mute', target, data),
+        select_source: (target, data) => svc('media_player', 'select_source', target, data),
+        shuffle_set: (target, data) => svc('media_player', 'shuffle_set', target, data),
+        repeat_set: (target, data) => svc('media_player', 'repeat_set', target, data),
+        play_media: (target, data) => svc('media_player', 'play_media', target, data),
+    },
+    alarm_control_panel: {
+        arm_away: (target, data) => svc('alarm_control_panel', 'arm_away', target, data),
+        arm_home: (target, data) => svc('alarm_control_panel', 'arm_home', target, data),
+        arm_night: (target, data) => svc('alarm_control_panel', 'arm_night', target, data),
+        arm_vacation: (target, data) => svc('alarm_control_panel', 'arm_vacation', target, data),
+        disarm: (target, data) => svc('alarm_control_panel', 'disarm', target, data),
+        trigger: (target, data) => svc('alarm_control_panel', 'trigger', target, data),
+    },
+    scene: {
+        turn_on: (target, data) => svc('scene', 'turn_on', target, data),
+    },
+    input_boolean: {
+        turn_on: (target) => svc('input_boolean', 'turn_on', target),
+        turn_off: (target) => svc('input_boolean', 'turn_off', target),
+        toggle: (target) => svc('input_boolean', 'toggle', target),
+    },
+    input_number: {
+        set_value: (target, data) => svc('input_number', 'set_value', target, data),
+        increment: (target) => svc('input_number', 'increment', target),
+        decrement: (target) => svc('input_number', 'decrement', target),
+        set_min: (target) => svc('input_number', 'min', target),
+        set_max: (target) => svc('input_number', 'max', target),
+    },
+    input_select: {
+        select_option: (target, data) => svc('input_select', 'select_option', target, data),
+        select_next: (target) => svc('input_select', 'select_next', target),
+        select_previous: (target) => svc('input_select', 'select_previous', target),
+        set_options: (target, data) => svc('input_select', 'set_options', target, data),
+    },
+    button: {
+        press: (target) => svc('button', 'press', target),
+    },
+    number: {
+        set_value: (target, data) => svc('number', 'set_value', target, data),
+    },
+    select: {
+        select_option: (target, data) => svc('select', 'select_option', target, data),
+        select_next: (target) => svc('select', 'select_next', target),
+        select_previous: (target) => svc('select', 'select_previous', target),
+    },
+};

package/dist/src/testing.d.ts

@@ -0,0 +1,18 @@
+import type { Automation, Decision, Abort } from './types/automation.js';
+import type { TriggerEvent } from './types/triggers.js';
+import type { HAContext } from './framework/ha-client.js';
+type TestStateEntry = {
+    state: string;
+    attributes?: Record<string, unknown>;
+    last_changed?: string;
+    last_updated?: string;
+};
+interface TestOptions {
+    event: TriggerEvent;
+    state?: Record<string, TestStateEntry>;
+    ha?: Partial<HAContext>;
+}
+export declare function testAutomation<C>(automation: Automation<C>, options: TestOptions): Decision;
+export declare function testAbort<C>(automation: Automation<C>, options: TestOptions): Abort;
+export declare function testUnavailable<C>(automation: Automation<C>, options: TestOptions): string;
+export {};

package/dist/src/testing.js

@@ -0,0 +1,60 @@
+import { isAbort, UnavailableInputError } from './types/automation.js';
+function buildStateAndHa(options) {
+    const { state = {}, ha = {} } = options;
+    const stateFunc = (entityId) => {
+        const entry = state[entityId];
+        if (!entry)
+            return undefined;
+        return {
+            entity_id: entityId,
+            state: entry.state,
+            attributes: entry.attributes ?? {},
+            last_changed: entry.last_changed ?? '',
+            last_updated: entry.last_updated ?? '',
+        };
+    };
+    const haContext = {
+        entitiesByLabel: ha.entitiesByLabel ?? (() => []),
+        labelsFor: ha.labelsFor ?? (() => []),
+        entitiesByArea: ha.entitiesByArea ?? (() => []),
+    };
+    return { stateFunc, haContext };
+}
+function run(automation, options) {
+    const { stateFunc, haContext } = buildStateAndHa(options);
+    const ctx = automation.context(stateFunc, haContext, options.event);
+    if (isAbort(ctx))
+        return ctx;
+    const result = automation.reduce(ctx);
+    // Mirrors runPipeline's default in src/framework/pipeline.ts, so tests observe the same
+    // `conditions` a real run would publish.
+    return { ...result, conditions: result.conditions ?? ctx };
+}
+export function testAutomation(automation, options) {
+    const result = run(automation, options);
+    if (isAbort(result))
+        throw new Error(`automation aborted: ${result.reason}`);
+    return result;
+}
+export function testAbort(automation, options) {
+    const result = run(automation, options);
+    if (!isAbort(result))
+        throw new Error(`expected abort but got decision: ${result.decision}`);
+    return result;
+}
+// For automations using requireState()/requireNumericState(), which throw
+// UnavailableInputError rather than returning Abort — testAbort() can't observe these since
+// run() never catches an exception thrown out of context(). Returns the entity id the
+// automation required, so tests can assert on which input was missing.
+export function testUnavailable(automation, options) {
+    const { stateFunc, haContext } = buildStateAndHa(options);
+    try {
+        automation.context(stateFunc, haContext, options.event);
+    }
+    catch (err) {
+        if (err instanceof UnavailableInputError)
+            return err.entityId;
+        throw err;
+    }
+    throw new Error('expected UnavailableInputError but context() completed normally');
+}

package/dist/src/types/actions.d.ts

@@ -0,0 +1,23 @@
+export interface HaCallServiceAction {
+    type: 'ha.call_service';
+    domain: string;
+    service: string;
+    target?: {
+        entity_id: string;
+    };
+    data?: Record<string, unknown>;
+}
+export type Action = HaCallServiceAction | {
+    type: 'mqtt.publish';
+    topic: string;
+    payload: string;
+    retain?: boolean;
+    impliesEntity?: string;
+} | {
+    type: 'timer.start';
+    timerKey: string;
+    delayMs: number;
+} | {
+    type: 'timer.cancel';
+    timerKey: string;
+};

package/dist/src/types/actions.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/automation.d.ts

@@ -0,0 +1,32 @@
+import type { HAState, HAContext } from '../framework/ha-client.js';
+import type { Trigger, TriggerEvent } from './triggers.js';
+import type { Action } from './actions.js';
+export type { HAState, HAContext };
+export interface Decision {
+    decision: string;
+    reason?: string;
+    actions: Action[];
+    conditions?: Record<string, unknown>;
+}
+export type Abort = {
+    abort: true;
+    reason: string;
+};
+export declare const abort: (reason: string) => Abort;
+export declare function isAbort(value: unknown): value is Abort;
+export declare class UnavailableInputError extends Error {
+    readonly entityId: string;
+    constructor(entityId: string);
+}
+export declare function requireState(state: HAState, entityId: Parameters<HAState>[0]): string;
+export declare function requireNumericState(state: HAState, entityId: Parameters<HAState>[0]): number;
+export interface Automation<C> {
+    id: string;
+    location: string;
+    subsystem: string;
+    enabled?: boolean;
+    triggers: Trigger[];
+    context: (state: HAState, ha: HAContext, event: TriggerEvent) => C | Abort;
+    reduce: (ctx: C) => Decision;
+}
+export declare function defineAutomation<C>(automation: Automation<C>): Automation<C>;

package/dist/src/types/automation.js

@@ -0,0 +1,44 @@
+export const abort = (reason) => ({ abort: true, reason });
+export function isAbort(value) {
+    return typeof value === 'object' && value !== null && value.abort === true;
+}
+// ---------- Required state ----------
+// Covers the dominant abort() pattern found across real automations (~70% of call sites,
+// per #142's audit): a required entity's state is missing or invalid, so context() can't
+// proceed. Thrown, not returned — pipeline.ts already wraps context() in try/catch, so this
+// collapses `const x = state(id)?.state; if (x === undefined) return abort(...)` at every call
+// site down to one line, with no per-call guard needed. Caught specially in pipeline.ts and
+// classified as abort_kind: 'unavailable_input' with the entity name, distinct from a genuine
+// bug (abort_kind: 'unhandled_error').
+export class UnavailableInputError extends Error {
+    entityId;
+    constructor(entityId) {
+        super(`required entity unavailable: ${entityId}`);
+        this.entityId = entityId;
+        this.name = 'UnavailableInputError';
+    }
+}
+// HA's own sentinel values for "entity is registered but not producing readings" — an
+// offline zigbee device, an integration that hasn't polled yet. Distinct from the entity
+// key being absent from the state cache entirely, but the same "unavailable" in practice:
+// every real audited call site treated these three cases identically.
+const HA_UNAVAILABLE_STATES = new Set(['unavailable', 'unknown']);
+export function requireState(state, entityId) {
+    const value = state(entityId)?.state;
+    if (value === undefined || HA_UNAVAILABLE_STATES.has(value)) {
+        throw new UnavailableInputError(String(entityId));
+    }
+    return value;
+}
+export function requireNumericState(state, entityId) {
+    const raw = requireState(state, entityId);
+    const parsed = parseFloat(raw);
+    if (!Number.isFinite(parsed))
+        throw new UnavailableInputError(String(entityId));
+    return parsed;
+}
+// Identity function — provides type inference on C so the reduce argument
+// is typed correctly without the user annotating the context shape explicitly.
+export function defineAutomation(automation) {
+    return automation;
+}

package/dist/src/types/triggers.d.ts

@@ -0,0 +1,77 @@
+import type { EntityState } from '../framework/ha-client.js';
+type _HAEntityKey = keyof HAEntities extends never ? string : keyof HAEntities;
+export type Trigger = {
+    type: 'state_changed';
+    entity: _HAEntityKey | RegExp;
+    to?: string | string[];
+    duration?: number;
+} | {
+    type: 'schedule';
+    cron: string;
+} | {
+    type: 'on_start';
+} | {
+    type: 'timer_expired';
+    timerKey: string;
+} | {
+    type: 'button';
+    entity: _HAEntityKey | RegExp;
+    gesture: 'single_press' | 'double_press' | 'hold';
+    button?: string;
+} | {
+    type: 'mqtt_in';
+    topic: string;
+};
+type TriggerEventBase = {
+    correlation_id: string;
+    parent_correlation_id?: string;
+    root_correlation_id?: string;
+    parent_automation_id?: string;
+};
+export type TriggerEvent = TriggerEventBase & ({
+    type: 'state_changed';
+    entity_id: string;
+    old_state: EntityState | undefined;
+    new_state: EntityState;
+} | {
+    type: 'schedule';
+    cron: string;
+} | {
+    type: 'on_start';
+} | {
+    type: 'timer_expired';
+    timerKey: string;
+} | {
+    type: 'button';
+    entity_id: string;
+    gesture: 'single_press' | 'double_press' | 'hold';
+    button?: string;
+} | {
+    type: 'mqtt_in';
+    topic: string;
+    payload: string;
+});
+export type TriggerSummary = {
+    type: 'state_changed';
+    entity_id: string;
+    to: string;
+    from?: string;
+} | {
+    type: 'schedule';
+    cron: string;
+} | {
+    type: 'on_start';
+} | {
+    type: 'timer_expired';
+    timerKey: string;
+} | {
+    type: 'button';
+    entity_id: string;
+    gesture: 'single_press' | 'double_press' | 'hold';
+    button?: string;
+} | {
+    type: 'mqtt_in';
+    topic: string;
+};
+export declare function summarizeTrigger(event: TriggerEvent): TriggerSummary;
+export {};

package/dist/src/types/triggers.js

@@ -0,0 +1,26 @@
+export function summarizeTrigger(event) {
+    switch (event.type) {
+        case 'state_changed':
+            return {
+                type: 'state_changed',
+                entity_id: event.entity_id,
+                to: event.new_state.state,
+                ...(event.old_state && { from: event.old_state.state }),
+            };
+        case 'schedule':
+            return { type: 'schedule', cron: event.cron };
+        case 'on_start':
+            return { type: 'on_start' };
+        case 'timer_expired':
+            return { type: 'timer_expired', timerKey: event.timerKey };
+        case 'button':
+            return {
+                type: 'button',
+                entity_id: event.entity_id,
+                gesture: event.gesture,
+                ...(event.button !== undefined && { button: event.button }),
+            };
+        case 'mqtt_in':
+            return { type: 'mqtt_in', topic: event.topic };
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@ajclarkson/homerun",
+  "type": "module",
+  "version": "0.0.1-edge.0131fc6",
+  "description": "TypeScript automation framework for Home Assistant",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/src/lib.js",
+  "types": "./dist/src/lib.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/lib.d.ts",
+      "default": "./dist/src/lib.js"
+    },
+    "./testing": {
+      "types": "./dist/src/testing.d.ts",
+      "default": "./dist/src/testing.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "generate:ha-types": "tsx scripts/generate-ha-types.ts",
+    "generate:ha-types:compiled": "homerun-generate-ha-types",
+    "generate:ha-services": "tsx scripts/generate-ha-services.ts",
+    "generate:ha-services:compiled": "homerun-generate-ha-services"
+  },
+  "bin": {
+    "homerun": "./dist/src/index.js",
+    "homerun-generate-ha-types": "./dist/scripts/generate-ha-types.js",
+    "homerun-generate-ha-services": "./dist/scripts/generate-ha-services.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ajclarkson/homerun"
+  },
+  "keywords": [],
+  "author": "Adam Clarkson",
+  "license": "MIT",
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "dotenv": "^17.4.2",
+    "esbuild": "^0.28.1",
+    "home-assistant-js-websocket": "^9.6.0",
+    "js-yaml": "^5.2.1",
+    "mqtt": "^5.15.1",
+    "node-cron": "^4.4.1",
+    "prom-client": "^15.1.3",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^26.0.0",
+    "tsx": "^4.22.4",
+    "typescript": "^7.0.0",
+    "vitest": "^4.1.9"
+  }
+}