@mantaq/traversal 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -1,11 +1,8 @@
 import { AnyActor, Context, ErrorInfo, InternalEvent, Snapshot, TransitionInfo } from "@mantaq/core";
-//#region src/types.d.ts
-/** Synthetic event object for graph introspection — matches minimal InternalEvent shape */
-interface SyntheticEvent {
-  type: string;
-  payload?: unknown;
-}
-/** Simplified handler return — matches TransitionResult with erased generics */
+/**
+ * Type guard for untyped transition-handler results. The single sanctioned
+ * `as` site for graph invocation: handler output crosses the untyped boundary.
+ */
 interface HandlerResult {
   state?: {
     name?: string;
@@ -14,6 +11,11 @@ interface HandlerResult {
     type?: string;
   }>;
 }
+/** Synthetic event object for graph introspection — matches minimal InternalEvent shape */
+interface SyntheticEvent {
+  type: string;
+  payload?: unknown;
+}
 type TransitionHandler = (event: SyntheticEvent, options: {
   context: Context<Record<string, unknown>>;
   actor: AnyActor<unknown>;
@@ -31,6 +33,13 @@ interface GraphNode {
   isActive: boolean;
   isFinal: boolean;
   isInitial?: boolean;
+  /** The `*` source of `onAny` edges: any non-final state. */
+  isAny?: boolean;
+}
+/** An effect a state runs on entry. `sends`: declared event types; null = not declared. */
+interface GraphEffect {
+  name: string;
+  sends: string[] | null;
 }
 interface GraphEdge {
   id: string;
@@ -40,10 +49,16 @@ interface GraphEdge {
   isActive: boolean;
   isInternal?: boolean;
   isUndetermined?: boolean;
+  /** Handled without a state change: the registration declares no `to`. */
+  isStay?: boolean;
+  /** Target comes from the builder's `to` list, not from running the handler. */
+  isDeclared?: boolean;
   payload?: {
     action?: string;
   };
   contexts: string[];
+  /** Effect self-loops only: the effects the state runs on entry, in registration order. */
+  effects?: GraphEffect[];
 }
 interface ActorGraph {
   nodes: GraphNode[];
@@ -68,8 +83,6 @@ interface HistoryEntry {
   type: "state_visit" | "transition" | "effect" | "send";
   data: StateVisit | TransitionRecord | EffectRecord | SendRecord;
 }
-//#endregion
-//#region src/history.d.ts
 interface History {
   append(entry: HistoryEntry): void;
   entries(): readonly HistoryEntry[];
@@ -85,28 +98,25 @@ interface History {
  * History records the runtime trace of an instrumented actor. A closure over
  * the entry list keeps the recorder mutable without exposing the raw array.
  */
-declare function createHistory(): History;
-//#endregion
-//#region src/graph.d.ts
-declare const INITIAL_NODE_ID = "__initial__";
-declare function collectActiveStates(snapshot: Snapshot, options: {
+export declare function createHistory(): History;
+export declare const INITIAL_NODE_ID = "__initial__";
+/** Source of `onAny` edges: any non-final state of the machine (`region.*` inside a region). */
+export declare const ANY_NODE_NAME = "*";
+export declare function isAnyNode(id: string): boolean;
+export declare function collectActiveStates(snapshot: Snapshot, options: {
   prefix: string;
   activeSet: Set<string>;
 }): void;
-declare function buildGraph<C>(actor: AnyActor<C>, options?: {
+export declare function buildGraph<C>(actor: AnyActor<C>, options?: {
   internalIds?: Set<string>;
   sampleContext?: Record<string, unknown>;
   sampleContexts?: Record<string, Record<string, unknown>>;
 }): ActorGraph;
-//#endregion
-//#region src/parse-graph.d.ts
-declare function parseStates(options: unknown): ReadonlyArray<StateDef>;
-declare function parseTransitionMap(source: unknown): TransitionDispatchMap;
-declare function parseInitialName(options: unknown): string | undefined;
-declare function parseContextRecord(context: unknown): Record<string, unknown>;
-declare function parseInternalEventIds(options: unknown): Set<string>;
-//#endregion
-//#region src/instrument.d.ts
+export declare function parseStates(options: unknown): ReadonlyArray<StateDef>;
+export declare function parseTransitionMap(source: unknown): TransitionDispatchMap;
+export declare function parseInitialName(options: unknown): string | undefined;
+export declare function parseContextRecord(context: unknown): Record<string, unknown>;
+export declare function parseInternalEventIds(options: unknown): Set<string>;
 type SubscriberEventName = "change" | "done" | "transition" | "error" | "output";
 type SubscriberHandler<C, E extends SubscriberEventName> = E extends "change" ? (snapshot: Snapshot<C>, prev: Snapshot<C>) => void : E extends "done" ? () => void : E extends "transition" ? (info: TransitionInfo) => void : E extends "error" ? (info: ErrorInfo) => void : E extends "output" ? (event: InternalEvent) => void : never;
 interface InstrumentedActor<C = Record<string, unknown>> {
@@ -129,24 +139,21 @@ interface InstrumentedActor<C = Record<string, unknown>> {
   inject(event: InternalEvent): void;
   dispose(): void;
 }
-declare function instrument<C>(actor: AnyActor<C>): InstrumentedActor<C>;
-//#endregion
-//#region src/algorithms.d.ts
-declare function reachable(graph: ActorGraph, endpoints: {
+export declare function instrument<C>(actor: AnyActor<C>): InstrumentedActor<C>;
+export declare function reachable(graph: ActorGraph, endpoints: {
   fromId: string;
   toId: string;
 }): boolean;
-declare function allPaths(graph: ActorGraph, endpoints: {
+export declare function allPaths(graph: ActorGraph, endpoints: {
   fromId: string;
   toId: string;
 }): string[][];
-declare function findCycles(graph: ActorGraph): string[][];
-declare function unreachableNodes(graph: ActorGraph, options: {
+export declare function findCycles(graph: ActorGraph): string[][];
+export declare function unreachableNodes(graph: ActorGraph, options: {
   fromId: string;
 }): string[];
-declare function shortestPath(graph: ActorGraph, endpoints: {
+export declare function shortestPath(graph: ActorGraph, endpoints: {
   fromId: string;
   toId: string;
 }): string[] | undefined;
-//#endregion
-export { type ActorGraph, type EffectRecord, type GraphEdge, type GraphNode, type History, type HistoryEntry, INITIAL_NODE_ID, type InstrumentedActor, type SendRecord, type StateDef, type StateVisit, type SyntheticEvent, type TransitionDispatchMap, type TransitionHandler, type TransitionRecord, allPaths, buildGraph, collectActiveStates, createHistory, findCycles, instrument, parseContextRecord, parseInitialName, parseInternalEventIds, parseStates, parseTransitionMap, reachable, shortestPath, unreachableNodes };
+export type { ActorGraph, EffectRecord, GraphEdge, GraphNode, History, HistoryEntry, InstrumentedActor, SendRecord, StateDef, StateVisit, SyntheticEvent, TransitionDispatchMap, TransitionHandler, TransitionRecord };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { Context, isStateRef } from "@mantaq/core";
 import { Either } from "@mantaq/utils";
-//#region src/history.ts
+// src/history.ts
 function entriesOfType(recordedEntries, options) {
 	return recordedEntries.filter((entry) => entry.type === options.type).map((entry) => entry.data);
 }
@@ -53,15 +53,177 @@ function createHistory() {
 		reset
 	};
 }
-//#endregion
-//#region src/is-handler-result.ts
+// src/graph-ids.ts
+const INITIAL_NODE_ID = "__initial__";
+/** Source of `onAny` edges: any non-final state of the machine (`region.*` inside a region). */
+const ANY_NODE_NAME = "*";
+function isAnyNode(id) {
+	return id === "*" || id.endsWith(`.*`);
+}
+function collectActiveStates(snapshot, options) {
+	if (!snapshot.path) return;
+	const currentName = snapshot.path[snapshot.path.length - 1];
+	if (!currentName) return;
+	const fullId = nodeId({
+		prefix: options.prefix,
+		name: currentName
+	});
+	options.activeSet.add(fullId);
+	if (snapshot.regions && !snapshot.done && !snapshot.error) for (const [regionName, regionSnapshot] of Object.entries(snapshot.regions)) collectActiveStates(regionSnapshot, {
+		prefix: regionName,
+		activeSet: options.activeSet
+	});
+}
+function nodeId(identity) {
+	return identity.prefix ? `${identity.prefix}.${identity.name}` : identity.name;
+}
+function collectActorsFromSnapshot(snapshot) {
+	const activeSet = /* @__PURE__ */ new Set();
+	collectActiveStates(snapshot, {
+		prefix: "",
+		activeSet
+	});
+	return activeSet;
+}
+// src/is-handler-result.ts
 function isHandlerResult(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const candidate = value;
 	return (candidate.state === void 0 || typeof candidate.state === "object" && candidate.state !== null && typeof candidate.state.name === "string") && (candidate.emit === void 0 || Array.isArray(candidate.emit));
 }
-//#endregion
-//#region src/parse-graph.ts
+// src/graph-edges.ts
+function invokeHandler(handler, options) {
+	return Either.from(() => {
+		const result = handler({
+			type: options.eventId,
+			payload: {}
+		}, {
+			context: Context({
+				get: () => options.context,
+				set: () => {}
+			}),
+			actor: options.actor
+		});
+		return isHandlerResult(result) ? {
+			targetName: result.state?.name,
+			emitNames: result.emit?.map((emitted) => emitted.type).filter((eventType) => Boolean(eventType)) ?? []
+		} : {
+			targetName: void 0,
+			emitNames: []
+		};
+	});
+}
+function probeAll(registration, pass) {
+	const probes = [];
+	for (const ctxName of pass.traversal.contextNames) {
+		const sampleContext = pass.traversal.contexts[ctxName];
+		if (sampleContext === void 0) continue;
+		const handled = Either.getRight(invokeHandler(registration.handler, {
+			eventId: registration.eventId,
+			context: sampleContext,
+			actor: pass.traversal.actor
+		}));
+		if (handled !== void 0) probes.push({
+			ctxName,
+			handled
+		});
+	}
+	return probes;
+}
+/**
+* One edge per declared target, a `stay` edge when `to` is empty, or one
+* undetermined edge when the actor carries no declaration. Probing only labels
+* edges: which sample contexts reach each target, and what it emits.
+*/
+function addRegistration(registration, pass) {
+	const probes = probeAll(registration, pass);
+	const declared = registration.declared ?? [];
+	const targets = declared.length > 0 ? declared : [void 0];
+	const undetermined = registration.declared === void 0;
+	for (const targetName of targets) {
+		const matching = undetermined ? probes : probes.filter((probe) => probe.handled.targetName === targetName);
+		const emitNames = [...new Set(matching.flatMap((probe) => probe.handled.emitNames))].sort();
+		const targetId = targetName ? nodeId({
+			prefix: pass.traversal.pathPrefix,
+			name: targetName
+		}) : pass.sourceId;
+		const suffix = targetName ? targetId : undetermined ? "undetermined" : "stay";
+		const edgeId = `${pass.sourceId}-${registration.eventId}-${suffix}`;
+		pass.edgeMap.set(edgeId, {
+			id: edgeId,
+			source: pass.sourceId,
+			target: targetId,
+			label: registration.eventId,
+			isActive: pass.isActive,
+			isInternal: pass.traversal.internalIds?.has(registration.eventId),
+			isUndetermined: undetermined,
+			isStay: !undetermined && targetName === void 0,
+			isDeclared: !undetermined,
+			contexts: matching.map((probe) => probe.ctxName),
+			...emitNames.length > 0 && { payload: { action: `emit(${emitNames.join(", ")})` } }
+		});
+	}
+}
+function registrations(handlers, declared) {
+	return Object.entries(handlers ?? {}).map(([eventId, handler]) => ({
+		eventId,
+		handler,
+		declared: declared?.[eventId]
+	}));
+}
+function stateEdges(edges) {
+	const sourceId = nodeId({
+		prefix: edges.traversal.pathPrefix,
+		name: edges.state.name
+	});
+	const pass = {
+		edgeMap: /* @__PURE__ */ new Map(),
+		sourceId,
+		isActive: edges.traversal.activeSet.has(sourceId),
+		traversal: edges.traversal
+	};
+	const own = registrations(edges.transitions[edges.state.name], edges.targets[edges.state.name]);
+	for (const registration of own) addRegistration(registration, pass);
+	return [...pass.edgeMap.values()];
+}
+/**
+* `onAny` edges leave one `*` source, once per target: "from any non-final
+* state". Expanding them per state would claim source/target pairs the code
+* never states. A state's own handler for the same event runs first; when it
+* stays, `onAny` may still transition, so both edges are kept.
+*/
+function anyEdges(edges) {
+	const prefix = edges.traversal.pathPrefix;
+	const pass = {
+		edgeMap: /* @__PURE__ */ new Map(),
+		sourceId: nodeId({
+			prefix,
+			name: "*"
+		}),
+		isActive: edges.states.some((state) => !state.isFinal && edges.traversal.activeSet.has(nodeId({
+			prefix,
+			name: state.name
+		}))),
+		traversal: edges.traversal
+	};
+	for (const registration of registrations(edges.transitions["Any"], edges.targets["Any"])) addRegistration(registration, pass);
+	return [...pass.edgeMap.values()];
+}
+function buildEdgesFromTransitions(edges) {
+	const scope = {
+		transitions: edges.transitions,
+		targets: edges.targets ?? {},
+		traversal: edges.traversal
+	};
+	return [...edges.states.flatMap((state) => stateEdges({
+		...scope,
+		state
+	})), ...anyEdges({
+		...scope,
+		states: edges.states
+	})];
+}
+// src/parse-graph.ts
 function parseStates(options) {
 	const states = options?.states;
 	if (!Array.isArray(states)) return [];
@@ -79,6 +241,19 @@ function parseTransitionMap(source) {
 	}
 	return dispatchMap;
 }
+function parseTargetMap(source) {
+	const targetMap = {};
+	if (typeof source !== "object" || source === null) return targetMap;
+	for (const [stateName, eventMap] of Object.entries(source)) {
+		if (typeof eventMap !== "object" || eventMap === null) continue;
+		for (const [eventType, names] of Object.entries(eventMap)) {
+			if (!Array.isArray(names)) continue;
+			const declared = names.filter((name) => typeof name === "string");
+			(targetMap[stateName] ??= {})[eventType] = declared;
+		}
+	}
+	return targetMap;
+}
 function parseInitialName(options) {
 	const initial = options?.initial;
 	if (initial === void 0 || initial === null) return void 0;
@@ -101,26 +276,7 @@ function parseInternalEventIds(options) {
 	}
 	return eventIds;
 }
-//#endregion
-//#region src/graph.ts
-const INITIAL_NODE_ID = "__initial__";
-function collectActiveStates(snapshot, options) {
-	if (!snapshot.path) return;
-	const currentName = snapshot.path[snapshot.path.length - 1];
-	if (!currentName) return;
-	const fullId = nodeId({
-		prefix: options.prefix,
-		name: currentName
-	});
-	options.activeSet.add(fullId);
-	if (snapshot.regions && !snapshot.done && !snapshot.error) for (const [regionName, regionSnapshot] of Object.entries(snapshot.regions)) collectActiveStates(regionSnapshot, {
-		prefix: regionName,
-		activeSet: options.activeSet
-	});
-}
-function nodeId(identity) {
-	return identity.prefix ? `${identity.prefix}.${identity.name}` : identity.name;
-}
+// src/graph.ts
 function buildNodesFromStates(states, options) {
 	return states.map((stateEntry) => {
 		const graphId = nodeId({
@@ -135,144 +291,32 @@ function buildNodesFromStates(states, options) {
 		};
 	});
 }
-function invokeHandler(handler, options) {
-	return Either.from(() => {
-		const result = handler({
-			type: options.eventId,
-			payload: {}
-		}, {
-			context: Context({
-				get: () => options.context,
-				set: () => {}
-			}),
-			actor: options.actor
-		});
-		return isHandlerResult(result) ? {
-			targetName: result.state?.name,
-			emitNames: result.emit?.map((emitted) => emitted.type).filter((eventType) => Boolean(eventType)) ?? []
-		} : {
-			targetName: void 0,
-			emitNames: []
-		};
-	});
-}
-function upsertEdge(sink) {
-	const undetermined = !sink.handled.targetName;
-	const targetId = sink.handled.targetName ? nodeId({
-		prefix: sink.traversal.pathPrefix,
-		name: sink.handled.targetName
-	}) : `${sink.sourceId}-undetermined-${sink.eventId}`;
-	const edgeId = `${sink.sourceId}-${sink.eventId}-${targetId}`;
-	const existing = sink.edgeMap.get(edgeId);
-	if (existing) existing.contexts.push(sink.ctxName);
-	else sink.edgeMap.set(edgeId, {
-		id: edgeId,
-		source: sink.sourceId,
-		target: targetId,
-		label: sink.eventId,
-		isActive: sink.traversal.activeSet.has(sink.sourceId),
-		isInternal: sink.traversal.internalIds?.has(sink.eventId),
-		isUndetermined: undetermined,
-		contexts: [sink.ctxName],
-		...sink.handled.emitNames.length > 0 && { payload: { action: `emit(${sink.handled.emitNames.join(", ")})` } }
-	});
-}
-function processStateTransitions(options) {
-	const stateTransitionedEvents = /* @__PURE__ */ new Set();
-	for (const [eventId, handler] of Object.entries(options.stateTransitions)) for (const ctxName of options.pass.traversal.contextNames) {
-		const sampleContext = options.pass.traversal.contexts[ctxName];
-		if (sampleContext === void 0) continue;
-		const handled = Either.getOrElse(invokeHandler(handler, {
-			eventId,
-			context: sampleContext,
-			actor: options.pass.traversal.actor
-		}), { onLeft: () => ({
-			targetName: void 0,
-			emitNames: []
-		}) });
-		if (handled.targetName) stateTransitionedEvents.add(eventId);
-		upsertEdge({
-			edgeMap: options.pass.edgeMap,
-			sourceId: options.pass.sourceId,
-			ctxName,
-			traversal: options.pass.traversal,
-			eventId,
-			handled
-		});
-	}
-	return stateTransitionedEvents;
-}
-function mergeAnyTransitions(options) {
-	for (const [eventId, handler] of Object.entries(options.anyTransitions)) {
-		if (options.stateTransitionedEvents.has(eventId)) continue;
-		for (const ctxName of options.pass.traversal.contextNames) {
-			const sampleContext = options.pass.traversal.contexts[ctxName];
-			if (sampleContext === void 0) continue;
-			const handled = Either.getOrElse(invokeHandler(handler, {
-				eventId,
-				context: sampleContext,
-				actor: options.pass.traversal.actor
-			}), { onLeft: () => ({
-				targetName: void 0,
-				emitNames: []
-			}) });
-			upsertEdge({
-				edgeMap: options.pass.edgeMap,
-				sourceId: options.pass.sourceId,
-				ctxName,
-				traversal: options.pass.traversal,
-				eventId,
-				handled
-			});
-		}
-	}
-}
-function collectTransitionsForState(edges) {
-	const edgeMap = /* @__PURE__ */ new Map();
-	const pass = {
-		edgeMap,
-		sourceId: edges.sourceId,
-		traversal: edges.traversal
-	};
-	const stateTransitionedEvents = edges.stateTransitions ? processStateTransitions({
-		stateTransitions: edges.stateTransitions,
-		pass
-	}) : /* @__PURE__ */ new Set();
-	if (edges.anyTransitions) mergeAnyTransitions({
-		anyTransitions: edges.anyTransitions,
-		stateTransitionedEvents,
-		pass
-	});
-	return edgeMap;
-}
-function buildEdgesFromTransitions(edges) {
-	const allEdges = [];
-	const anyTransitions = edges.transitions["Any"];
-	for (const stateEntry of edges.states) {
-		const sourceId = nodeId({
-			prefix: edges.traversal.pathPrefix,
-			name: stateEntry.name
-		});
-		const edgeMap = collectTransitionsForState({
-			stateTransitions: edges.transitions[stateEntry.name],
-			anyTransitions,
-			sourceId,
-			traversal: edges.traversal
-		});
-		allEdges.push(...edgeMap.values());
-	}
-	return allEdges;
-}
 function addNodesForActor(actor, layout) {
-	return buildNodesFromStates(parseStates(actor.options), {
+	const nodes = buildNodesFromStates(parseStates(actor.options), {
 		activeSet: layout.activeSet,
 		pathPrefix: layout.pathPrefix
 	});
+	const anyTransitions = parseTransitionMap(actor.options?.transitions)["Any"];
+	if (anyTransitions !== void 0 && Object.keys(anyTransitions).length > 0) {
+		const id = nodeId({
+			prefix: layout.pathPrefix,
+			name: "*"
+		});
+		nodes.push({
+			id,
+			label: "any state",
+			isActive: false,
+			isFinal: false,
+			isAny: true
+		});
+	}
+	return nodes;
 }
 function addEdgesForActor(actor, layout) {
 	return buildEdgesFromTransitions({
 		states: parseStates(actor.options),
 		transitions: parseTransitionMap(actor.options?.transitions),
+		targets: parseTargetMap(actor.options?.targets),
 		traversal: layout.traversal
 	});
 }
@@ -295,6 +339,16 @@ function recurseRegions(actor, layout) {
 		edges: childEdges
 	};
 }
+function readEffect(entry) {
+	if (typeof entry !== "object" || entry === null) return [];
+	const name = Reflect.get(entry, "name");
+	if (typeof name !== "string") return [];
+	const sends = Reflect.get(entry, "sends");
+	return [{
+		name,
+		sends: Array.isArray(sends) ? sends.filter((type) => typeof type === "string") : null
+	}];
+}
 function addEffectSelfLoops(actor, layout) {
 	const selfLoops = [];
 	const effects = actor.options?.effects;
@@ -311,7 +365,8 @@ function addEffectSelfLoops(actor, layout) {
 				label: `effect:${stateName}`,
 				isActive: layout.activeSet.has(loopId),
 				isInternal: true,
-				contexts: []
+				contexts: [],
+				effects: effectFns.flatMap((entry) => readEffect(entry))
 			});
 		}
 	}
@@ -363,14 +418,6 @@ function addInitialNode(actor, layout) {
 		contexts: []
 	});
 }
-function collectActorsFromSnapshot(snapshot) {
-	const activeSet = /* @__PURE__ */ new Set();
-	collectActiveStates(snapshot, {
-		prefix: "",
-		activeSet
-	});
-	return activeSet;
-}
 function collectNamedContexts(named) {
 	return named?.sampleContexts ?? (named?.sampleContext ? { default: named.sampleContext } : void 0);
 }
@@ -403,8 +450,7 @@ function buildGraph(actor, options) {
 		edges: []
 	}) });
 }
-//#endregion
-//#region src/instrument.ts
+// src/instrument.ts
 function wrapWithProxy(actor, wrapped) {
 	function forwardOn(event, options) {
 		return actor.on(event, options);
@@ -520,8 +566,7 @@ function attach(childActor, branch) {
 		})
 	});
 }
-//#endregion
-//#region src/algorithms.ts
+// src/algorithms.ts
 function buildAdjacency(graph) {
 	const adjacency = {};
 	for (const node of graph.nodes) adjacency[node.id] = [];
@@ -652,5 +697,4 @@ function shortestPath(graph, endpoints) {
 		});
 	}
 }
-//#endregion
-export { INITIAL_NODE_ID, allPaths, buildGraph, collectActiveStates, createHistory, findCycles, instrument, parseContextRecord, parseInitialName, parseInternalEventIds, parseStates, parseTransitionMap, reachable, shortestPath, unreachableNodes };
+export { ANY_NODE_NAME, INITIAL_NODE_ID, allPaths, buildGraph, collectActiveStates, createHistory, findCycles, instrument, isAnyNode, parseContextRecord, parseInitialName, parseInternalEventIds, parseStates, parseTransitionMap, reachable, shortestPath, unreachableNodes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantaq/traversal",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Graph extraction, traversal algorithms, and runtime tracking for mantaq actors.",
   "license": "MIT",
   "repository": {
@@ -20,16 +20,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@mantaq/core": "0.4.0",
+    "@mantaq/core": "0.5.0",
     "@mantaq/utils": "0.0.4"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "@vitest/coverage-v8": "4.1.10",
+    "@vitest/coverage-v8": "5.0.5",
     "typescript": "6.0.3",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.8",
-    "vite-plus": "0.2.8"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
+    "vite-plus": "1.4.0"
   },
   "scripts": {
     "build": "vp pack",