@arkts/image-manager 0.4.3 → 0.5.1

package/dist/index.mjs

@@ -1,1288 +1,1561 @@
-import axios, { AxiosError } from "axios";
-import satisfies from "semver/functions/satisfies";
 import INI from "ini";
-import mitt from "mitt";
-import progress from "progress-stream";
+import { fromByteArray } from "base64-js";
+import { RelativePattern, WriteableFlags, createNodeFileSystem } from "vscode-fs";
 
 //#region package.json
-var version = "0.4.3";
+var version = "0.5.1";
 
 //#endregion
-//#region src/devices/list.ts
-let DevModel = /* @__PURE__ */ function(DevModel) {
-	DevModel["MCHEMU_AL00CN"] = "MCHEMU-AL00CN";
-	DevModel["PHEMU_FD00"] = "PHEMU-FD00";
-	DevModel["PHEMU_FD01"] = "PHEMU-FD01";
-	DevModel["PHEMU_FD02"] = "PHEMU-FD02";
-	DevModel["PHEMU_FD06"] = "PHEMU-FD06";
-	DevModel["PCEMU_FD00"] = "PCEMU-FD00";
-	DevModel["PCEMU_FD05"] = "PCEMU-FD05";
-	return DevModel;
-}({});
-
-//#endregion
-//#region src/emulator-config.ts
-let BaseEmulatorConfigItem;
-(function(_BaseEmulatorConfigItem) {
-	function is(value) {
-		return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string" && "deviceType" in value && typeof value.deviceType === "string" && "api" in value && typeof value.api === "number";
-	}
-	_BaseEmulatorConfigItem.is = is;
-})(BaseEmulatorConfigItem || (BaseEmulatorConfigItem = {}));
-let ParentEmulatorConfigItem;
-(function(_ParentEmulatorConfigItem) {
-	function is(value) {
-		return BaseEmulatorConfigItem.is(value) && "resolutionWidth" in value && typeof value.resolutionWidth === "number" && "resolutionHeight" in value && typeof value.resolutionHeight === "number" && "physicalWidth" in value && typeof value.physicalWidth === "number" && "physicalHeight" in value && typeof value.physicalHeight === "number" && "diagonalSize" in value && typeof value.diagonalSize === "number" && "density" in value && typeof value.density === "number" && "memoryRamSize" in value && typeof value.memoryRamSize === "number" && "datadiskSize" in value && typeof value.datadiskSize === "number" && "procNumber" in value && typeof value.procNumber === "number" && "api" in value && typeof value.api === "number";
-	}
-	_ParentEmulatorConfigItem.is = is;
-})(ParentEmulatorConfigItem || (ParentEmulatorConfigItem = {}));
-let PhoneAllEmulatorConfigItem;
-(function(_PhoneAllEmulatorConfigItem) {
-	function is(value) {
-		return ParentEmulatorConfigItem.is(value);
+//#region src/common/serializable-content.ts
+var SerializableContentImpl = class {
+	constructor(imageManager, content) {
+		this.imageManager = imageManager;
+		this.content = content;
 	}
-	_PhoneAllEmulatorConfigItem.is = is;
-})(PhoneAllEmulatorConfigItem || (PhoneAllEmulatorConfigItem = {}));
-let GroupPhoneAllEmulatorConfigItem;
-(function(_GroupPhoneAllEmulatorConfigItem) {
-	function is(value) {
-		return BaseEmulatorConfigItem.is(value) && "children" in value && Array.isArray(value.children) && value.children.every(PhoneAllEmulatorConfigItem.is);
+	getImageManager() {
+		return this.imageManager;
 	}
-	_GroupPhoneAllEmulatorConfigItem.is = is;
-})(GroupPhoneAllEmulatorConfigItem || (GroupPhoneAllEmulatorConfigItem = {}));
-let PCAllEmulatorConfigItem;
-(function(_PCAllEmulatorConfigItem) {
-	function is(value) {
-		return ParentEmulatorConfigItem.is(value);
+	getContent() {
+		return this.content;
 	}
-	_PCAllEmulatorConfigItem.is = is;
-})(PCAllEmulatorConfigItem || (PCAllEmulatorConfigItem = {}));
-let GroupPCAllEmulatorConfigItem;
-(function(_GroupPCAllEmulatorConfigItem) {
-	function is(value) {
-		return BaseEmulatorConfigItem.is(value) && "children" in value && Array.isArray(value.children) && value.children.every(PCAllEmulatorConfigItem.is);
+	toJSON() {
+		return {
+			imageManager: this.getImageManager().toJSON(),
+			content: this.getContent()
+		};
 	}
-	_GroupPCAllEmulatorConfigItem.is = is;
-})(GroupPCAllEmulatorConfigItem || (GroupPCAllEmulatorConfigItem = {}));
+};
 
 //#endregion
-//#region src/errors/deploy-error.ts
-var DeployError = class extends Error {
-	constructor(code, message, cause) {
-		super(message, { cause });
-		this.code = code;
-		this.message = message;
-		this.cause = cause;
+//#region src/common/serializable-file.ts
+var SerializableFileImpl = class extends SerializableContentImpl {
+	constructor(imageManager, content) {
+		super(imageManager, content);
+		this.imageManager = imageManager;
+		this.content = content;
+	}
+	getImageManager() {
+		return this.imageManager;
 	}
-	getCode() {
-		return this.code;
+	async writeToFileSystem(uri) {
+		const { adapter: { fs, dirname } } = this.imageManager.getOptions();
+		const directoryUri = dirname(uri);
+		if (!await fs.exists(directoryUri)) await fs.createDirectory(directoryUri);
+		const serializedContent = await this.serialize();
+		const encodedContent = new TextEncoder().encode(serializedContent);
+		await fs.writeFile(uri, encodedContent);
+	}
+	toJSON() {
+		return {
+			imageManager: this.getImageManager().toJSON(),
+			content: this.getContent()
+		};
 	}
 };
-(function(_DeployError) {
-	_DeployError.Code = /* @__PURE__ */ function(Code) {
-		Code["DEVICE_ALREADY_DEPLOYED"] = "DEVICE_ALREADY_DEPLOYED";
-		Code["LIST_JSON_NOT_AN_ARRAY"] = "LIST_JSON_NOT_AN_ARRAY";
-		Code["CATCHED_ERROR"] = "CATCHED_ERROR";
-		Code["MAYBE_OPENED_DEVICE_MANAGER_IN_DEVECO_STUDIO"] = "MAYBE_OPENED_DEVICE_MANAGER_IN_DEVECO_STUDIO";
-		Code["SYMLINK_SDK_PATH_EXISTS"] = "SYMLINK_SDK_PATH_EXISTS";
-		return Code;
-	}({});
-})(DeployError || (DeployError = {}));
 
 //#endregion
-//#region src/errors/request-url-error.ts
-var RequestUrlError = class extends Error {
-	constructor(message, code, cause) {
-		super(message, { cause });
-		this.message = message;
-		this.code = code;
-		this.cause = cause;
+//#region src/configs/config-ini/config-ini.ts
+let ConfigIniFile;
+(function(_ConfigIniFile) {
+	function is(value) {
+		return value instanceof ConfigIniFileImpl;
+	}
+	_ConfigIniFile.is = is;
+})(ConfigIniFile || (ConfigIniFile = {}));
+var ConfigIniFileImpl = class extends SerializableFileImpl {
+	constructor(device, configIniFilePath, content) {
+		super(device.getImageManager(), content);
+		this.device = device;
+		this.configIniFilePath = configIniFilePath;
+		this.content = content;
+	}
+	getDevice() {
+		return this.device;
+	}
+	static getFileUri(device) {
+		const { deployedPath, adapter: { join } } = device.getImageManager().getOptions();
+		return join(deployedPath, device.getListsFileItem().getContent().name, "config.ini");
+	}
+	static async safeReadAndParse(device) {
+		const { adapter: { fs } } = device.getImageManager().getOptions();
+		try {
+			const configIniFileContent = await fs.readFile(this.getFileUri(device)).then((buffer) => buffer.toString(), () => void 0);
+			if (!configIniFileContent?.length) return;
+			return INI.parse(configIniFileContent);
+		} catch {}
+	}
+	getFileUri() {
+		return this.configIniFilePath;
+	}
+	async serialize() {
+		return INI.stringify(Object.fromEntries(Object.entries(this.getContent()).filter(([key, value]) => {
+			return value !== void 0 && key.length > 0;
+		})));
+	}
+	async write() {
+		return this.writeToFileSystem(this.getFileUri());
+	}
+	toJSON() {
+		return {
+			...super.toJSON(),
+			fileUri: this.getFileUri().toJSON()
+		};
 	}
 };
 
 //#endregion
-//#region src/product-config.ts
-let ProductConfigItem;
-(function(_ProductConfigItem) {
+//#region src/configs/emulator/emulator-basic-item.ts
+let EmulatorBasicItem;
+(function(_EmulatorBasicItem) {
 	function is(value) {
-		return typeof value === "object" && value !== null && "name" in value && "screenWidth" in value && "screenHeight" in value && "screenDiagonal" in value && "screenDensity" in value && typeof value.name === "string" && typeof value.screenWidth === "string" && typeof value.screenHeight === "string" && typeof value.screenDiagonal === "string" && typeof value.screenDensity === "string";
+		return value instanceof EmulatorBasicItemImpl;
 	}
-	_ProductConfigItem.is = is;
-})(ProductConfigItem || (ProductConfigItem = {}));
-
-//#endregion
-//#region src/types.ts
-function isPhoneAllSnakecaseDeviceType(value) {
-	return value === "phone" || value === "triplefold" || value === "widefold" || value === "foldable";
-}
-function isPCAllSnakecaseDeviceType(value) {
-	return value === "2in1_foldable" || value === "2in1";
-}
-
-//#endregion
-//#region src/screens/base-screen.ts
-var BaseScreenImpl = class {
-	constructor(options) {
-		this.options = options;
+	_EmulatorBasicItem.is = is;
+	function isDeviceType(value) {
+		return value === "2in1" || value === "tablet" || value === "tv" || value === "wearable" || value === "phone";
 	}
-	getWidth() {
-		return this.options.width;
+	_EmulatorBasicItem.isDeviceType = isDeviceType;
+	function isContent(value) {
+		return typeof value === "object" && value !== null && "name" in value && "deviceType" in value && isDeviceType(value.deviceType);
 	}
-	setWidth(width) {
-		this.options.width = width;
-		return this;
+	_EmulatorBasicItem.isContent = isContent;
+})(EmulatorBasicItem || (EmulatorBasicItem = {}));
+var EmulatorBasicItemImpl = class extends SerializableContentImpl {
+	constructor(emulatorFile, content) {
+		super(emulatorFile.getImageManager(), content);
+		this.emulatorFile = emulatorFile;
+		this.content = content;
 	}
-	getHeight() {
-		return this.options.height;
+	getEmulatorFile() {
+		return this.emulatorFile;
 	}
-	setHeight(height) {
-		this.options.height = height;
-		return this;
+};
+
+//#endregion
+//#region src/configs/emulator/emulator-fold-item.ts
+let EmulatorFoldItem;
+(function(_EmulatorFoldItem) {
+	function is(value) {
+		return value instanceof EmulatorFoldItemImpl;
 	}
-	getDiagonal() {
-		return this.options.diagonal;
+	_EmulatorFoldItem.is = is;
+	function isDeviceType(value) {
+		return value === "foldable" || value === "2in1_foldable" || value === "triplefold" || value === "widefold";
 	}
-	setDiagonal(diagonal) {
-		this.options.diagonal = diagonal;
-		return this;
+	_EmulatorFoldItem.isDeviceType = isDeviceType;
+	function isContent(value) {
+		return typeof value === "object" && value !== null && "name" in value && "deviceType" in value && isDeviceType(value.deviceType);
 	}
-	toJSON() {
-		return this.options;
+	_EmulatorFoldItem.isContent = isContent;
+})(EmulatorFoldItem || (EmulatorFoldItem = {}));
+var EmulatorFoldItemImpl = class extends SerializableContentImpl {
+	constructor(emulatorFile, content) {
+		super(emulatorFile.getImageManager(), content);
+		this.emulatorFile = emulatorFile;
+		this.content = content;
+	}
+	getEmulatorFile() {
+		return this.emulatorFile;
 	}
 };
 
 //#endregion
-//#region src/screens/cover-screen.ts
-let CoverScreen;
-(function(_CoverScreen) {
+//#region src/configs/emulator/emulator-triplefold-item.ts
+let EmulatorTripleFoldItem;
+(function(_EmulatorTripleFoldItem) {
 	function is(value) {
-		return value instanceof CoverScreenImpl;
+		return value instanceof EmulatorTripleFoldItemImpl;
 	}
-	_CoverScreen.is = is;
-})(CoverScreen || (CoverScreen = {}));
-var CoverScreenImpl = class extends BaseScreenImpl {
-	constructor(options, screen) {
-		super(options);
-		this.options = options;
-		this.screen = screen;
+	_EmulatorTripleFoldItem.is = is;
+	function isDeviceType(value) {
+		return value === "triplefold";
 	}
-	getScreen() {
-		return this.screen;
+	_EmulatorTripleFoldItem.isDeviceType = isDeviceType;
+	function isContent(value) {
+		return typeof value === "object" && value !== null && "name" in value && "deviceType" in value && isDeviceType(value.deviceType);
+	}
+	_EmulatorTripleFoldItem.isContent = isContent;
+})(EmulatorTripleFoldItem || (EmulatorTripleFoldItem = {}));
+var EmulatorTripleFoldItemImpl = class extends SerializableContentImpl {
+	constructor(emulatorFile, content) {
+		super(emulatorFile.getImageManager(), content);
+		this.emulatorFile = emulatorFile;
+		this.content = content;
+	}
+	getEmulatorFile() {
+		return this.emulatorFile;
 	}
 };
-function createCoverScreen(options, screen) {
-	return new CoverScreenImpl(options, screen);
-}
 
 //#endregion
-//#region src/screens/double-screen.ts
-let DoubleScreen;
-(function(_DoubleScreen) {
+//#region src/configs/emulator/group-item.ts
+let EmulatorGroupItem;
+(function(_EmulatorGroupItem) {
 	function is(value) {
-		return value instanceof DoubleScreenImpl;
-	}
-	_DoubleScreen.is = is;
-})(DoubleScreen || (DoubleScreen = {}));
-var DoubleScreenImpl = class extends BaseScreenImpl {
-	constructor(options, screen) {
-		super(options);
-		this.options = options;
-		this.screen = screen;
-	}
-	getScreen() {
-		return this.screen;
+		return value instanceof EmulatorGroupItemImpl;
+	}
+	_EmulatorGroupItem.is = is;
+	function isContent(value) {
+		return typeof value === "object" && value !== null && "name" in value && "deviceType" in value && "api" in value && "children" in value && Array.isArray(value.children) && value.children.every(EmulatorFile.isItemContent);
+	}
+	_EmulatorGroupItem.isContent = isContent;
+})(EmulatorGroupItem || (EmulatorGroupItem = {}));
+var EmulatorGroupItemImpl = class extends SerializableContentImpl {
+	constructor(emulatorFile, content) {
+		super(emulatorFile.getImageManager(), content);
+		this.emulatorFile = emulatorFile;
+		this.content = content;
+	}
+	getEmulatorFile() {
+		return this.emulatorFile;
+	}
+	getChildren() {
+		return this.getContent().children.map((children) => {
+			if (EmulatorBasicItem.isContent(children)) return new EmulatorBasicItemImpl(this.emulatorFile, children);
+			else if (EmulatorFoldItem.isContent(children)) return new EmulatorFoldItemImpl(this.emulatorFile, children);
+			else if (EmulatorTripleFoldItem.isContent(children)) return new EmulatorTripleFoldItemImpl(this.emulatorFile, children);
+		}).filter(Boolean);
 	}
 };
-function createDoubleScreen(options, screen) {
-	return new DoubleScreenImpl(options, screen);
-}
 
 //#endregion
-//#region src/screens/emulator-preset.ts
-var EmulatorPresetImpl = class {
-	constructor(emulatorConfigItem, screenPreset) {
-		this.emulatorConfigItem = emulatorConfigItem;
-		this.screenPreset = screenPreset;
+//#region src/configs/emulator/emulator.ts
+let EmulatorFile;
+(function(_EmulatorFile) {
+	function is(value) {
+		return value instanceof EmulatorFileImpl;
+	}
+	_EmulatorFile.is = is;
+	function isItemContent(value) {
+		return typeof value === "object" && value !== null && (EmulatorBasicItem.isContent(value) || EmulatorFoldItem.isContent(value) || EmulatorTripleFoldItem.isContent(value));
+	}
+	_EmulatorFile.isItemContent = isItemContent;
+	function isContentItem(value) {
+		return typeof value === "object" && value !== null && (EmulatorGroupItem.isContent(value) || EmulatorFile.isItemContent(value));
+	}
+	_EmulatorFile.isContentItem = isContentItem;
+})(EmulatorFile || (EmulatorFile = {}));
+var EmulatorFileImpl = class extends SerializableFileImpl {
+	async serialize() {
+		return JSON.stringify(this.getContent(), null, 2);
+	}
+	async write() {
+		const { emulatorPath, adapter: { join } } = this.getImageManager().getOptions();
+		return this.writeToFileSystem(join(emulatorPath, "emulator.json"));
+	}
+	getItems() {
+		return this.getContent().map((item) => {
+			if (EmulatorGroupItem.isContent(item)) return new EmulatorGroupItemImpl(this, item);
+			else if (EmulatorFile.isItemContent(item)) {
+				if (EmulatorBasicItem.isContent(item)) return new EmulatorBasicItemImpl(this, item);
+				else if (EmulatorFoldItem.isContent(item)) return new EmulatorFoldItemImpl(this, item);
+				else if (EmulatorTripleFoldItem.isContent(item)) return new EmulatorTripleFoldItemImpl(this, item);
+			}
+		}).filter(Boolean);
+	}
+	findDeviceItems(options = {}) {
+		const items = [];
+		const pushDeviceItem = (item) => {
+			if (EmulatorBasicItem.is(item)) {
+				if (options.apiVersion && item.getContent().api === options.apiVersion && options.deviceType && item.getContent().deviceType === options.deviceType) items.push(item);
+			} else if (EmulatorFoldItem.is(item)) {
+				if (options.apiVersion && item.getContent().api === options.apiVersion && options.deviceType && item.getContent().deviceType === options.deviceType) items.push(item);
+			} else if (EmulatorTripleFoldItem.is(item)) {
+				if (options.apiVersion && item.getContent().api === options.apiVersion && options.deviceType && item.getContent().deviceType === options.deviceType) items.push(item);
+			}
+		};
+		for (const item of this.getItems()) if (EmulatorGroupItem.is(item)) for (const child of item.getChildren()) pushDeviceItem(child);
+		else pushDeviceItem(item);
+		return items;
 	}
-	getScreenPreset() {
-		return this.screenPreset;
+	findDeviceItem(options = {}) {
+		return this.findDeviceItems(options)[0];
+	}
+	findItems(options = {}) {
+		return this.getItems().filter((item) => {
+			if (options.apiVersion && item.getContent().api === options.apiVersion && options.fullDeviceType && item.getContent().deviceType === options.fullDeviceType) return true;
+			return false;
+		});
 	}
-	getEmulatorConfig() {
-		return this.emulatorConfigItem;
+	findItem(options = {}) {
+		return this.findItems(options)[0];
 	}
 	toJSON() {
-		return { emulatorConfig: this.emulatorConfigItem };
+		return {
+			...super.toJSON(),
+			items: this.getItems().map((item) => item.toJSON())
+		};
 	}
 };
-function createEmulatorPreset(emulatorConfigItem, screenPreset) {
-	return new EmulatorPresetImpl(emulatorConfigItem, screenPreset);
-}
 
 //#endregion
-//#region src/screens/outer-screen.ts
-let OuterScreen;
-(function(_OuterScreen) {
+//#region src/configs/lists/item.ts
+let ListsFileItem;
+(function(_ListsFileItem) {
 	function is(value) {
-		return value instanceof OuterScreenImpl;
-	}
-	_OuterScreen.is = is;
-})(OuterScreen || (OuterScreen = {}));
-var OuterScreenImpl = class extends BaseScreenImpl {
-	outerDoubleScreen;
-	constructor(options, screen) {
-		super(options);
-		this.options = options;
-		this.screen = screen;
-		if (options.double) this.outerDoubleScreen = OuterDoubleScreen.is(options.double) ? options.double : createOuterDoubleScreen(options.double, this);
+		return value instanceof ListsFileItemImpl;
 	}
-	getScreen() {
-		return this.screen;
+	_ListsFileItem.is = is;
+})(ListsFileItem || (ListsFileItem = {}));
+var ListsFileItemImpl = class extends SerializableContentImpl {
+	constructor(listsFile, content) {
+		super(listsFile.getImageManager(), content);
+		this.listsFile = listsFile;
+		this.content = content;
 	}
-	getOuterDoubleScreen() {
-		return this.outerDoubleScreen;
+	getListsFile() {
+		return this.listsFile;
 	}
-	setOuterDoubleScreen(outerDoubleScreen) {
-		this.outerDoubleScreen = OuterDoubleScreen.is(outerDoubleScreen) ? outerDoubleScreen : createOuterDoubleScreen(outerDoubleScreen, this);
-		return this;
+	getContent() {
+		return this.content;
 	}
 	toJSON() {
 		return {
-			...super.toJSON(),
-			double: this.outerDoubleScreen?.toJSON()
+			imageManager: this.getImageManager().toJSON(),
+			content: this.getContent(),
+			listsFile: this.getListsFile().toJSON()
 		};
 	}
 };
-function createOuterScreen(options, screen) {
-	return new OuterScreenImpl(options, screen);
-}
 
 //#endregion
-//#region src/screens/outer-double-screen.ts
-let OuterDoubleScreen;
-(function(_OuterDoubleScreen) {
+//#region src/configs/lists/lists.ts
+let ListsFile;
+(function(_ListsFile) {
 	function is(value) {
-		return value instanceof OuterDoubleScreenImpl;
+		return value instanceof ListsFileImpl;
+	}
+	_ListsFile.is = is;
+})(ListsFile || (ListsFile = {}));
+var ListsFileImpl = class extends SerializableFileImpl {
+	_isChanged = false;
+	getListsFileItems() {
+		return this.getContent().map((item) => new ListsFileItemImpl(this, item));
+	}
+	removeDuplicateListFileItems(listsFileItems) {
+		this.content = listsFileItems.filter((item, index, self) => index === self.findIndex((t) => t.uuid === item.uuid)).filter((item, index, self) => index === self.findIndex((t) => t.name === item.name));
+	}
+	addListsFileItem(listsFileItem) {
+		this.content.push(listsFileItem);
+		this.removeDuplicateListFileItems(this.content);
+		this._isChanged = true;
+		return new ListsFileItemImpl(this, listsFileItem);
+	}
+	get isChanged() {
+		return this._isChanged;
+	}
+	deleteListsFileItem(listsFileItem) {
+		const index = this.content.findIndex((item) => item.uuid === listsFileItem.getContent().uuid);
+		if (index === -1) return this;
+		this.content.splice(index, 1);
+		this._isChanged = true;
+		return this;
 	}
-	_OuterDoubleScreen.is = is;
-})(OuterDoubleScreen || (OuterDoubleScreen = {}));
-var OuterDoubleScreenImpl = class extends OuterScreenImpl {
-	constructor(options, outerScreen) {
-		super(options, outerScreen.getScreen());
-		this.options = options;
-		this.outerScreen = outerScreen;
+	async serialize() {
+		return JSON.stringify(this.getContent(), null, 2);
+	}
+	async write() {
+		if (!this.isChanged) return;
+		await this.writeToFileSystem(this.getImageManager().getListsFilePath());
+		this._isChanged = false;
 	}
-	getOuterScreen() {
-		return this.outerScreen;
+	toJSON() {
+		return {
+			imageManager: this.getImageManager().toJSON(),
+			content: this.getContent(),
+			listsFileItems: this.getListsFileItems().map((item) => item.toJSON())
+		};
 	}
 };
-function createOuterDoubleScreen(options, outerScreen) {
-	return new OuterDoubleScreenImpl(options, outerScreen);
-}
 
 //#endregion
-//#region src/screens/product-preset.ts
-var ProductPresetImpl = class {
-	constructor(productConfig, deviceType, screenPreset) {
-		this.productConfig = productConfig;
+//#region src/configs/product/item.ts
+let ProductConfigItem;
+(function(_ProductConfigItem) {
+	function is(value) {
+		return value instanceof ProductConfigItemImpl;
+	}
+	_ProductConfigItem.is = is;
+})(ProductConfigItem || (ProductConfigItem = {}));
+var ProductConfigItemImpl = class extends SerializableContentImpl {
+	constructor(productConfigFile, content, deviceType) {
+		super(productConfigFile.getImageManager(), content);
+		this.productConfigFile = productConfigFile;
+		this.content = content;
 		this.deviceType = deviceType;
-		this.screenPreset = screenPreset;
 	}
-	getProductConfig() {
-		return this.productConfig;
+	getProductConfigFile() {
+		return this.productConfigFile;
 	}
 	getDeviceType() {
 		return this.deviceType;
 	}
-	getScreenPreset() {
-		return this.screenPreset;
+	async serialize() {
+		return JSON.stringify(this.getContent(), null, 2);
+	}
+	getDevModel() {
+		switch (this.getDeviceType()) {
+			case "Phone":
+			case "2in1": return "PHEMU-FD00";
+			case "Foldable": return "PHEMU-FD01";
+			case "WideFold": return "PHEMU-FD02";
+			case "TripleFold": return "PHEMU-FD06";
+			case "2in1 Foldable": return "PCEMU-FD05";
+			case "Wearable": return "MCHEMU-AL00CN";
+		}
 	}
 	toJSON() {
 		return {
-			product: this.productConfig,
-			deviceType: this.deviceType
+			imageManager: this.getImageManager().toJSON(),
+			content: this.getContent(),
+			devModel: this.getDevModel(),
+			deviceType: this.getDeviceType(),
+			productConfigFile: this.getProductConfigFile().toJSON()
 		};
 	}
 };
-function createProductPreset(productConfig, deviceType, screenPreset) {
-	return new ProductPresetImpl(productConfig, deviceType, screenPreset);
-}
 
 //#endregion
-//#region src/screens/single-screen.ts
-let SingleScreen;
-(function(_SingleScreen) {
+//#region src/configs/product/product.ts
+let ProductConfigFile;
+(function(_ProductConfigFile) {
 	function is(value) {
-		return value instanceof SingleScreenImpl;
-	}
-	_SingleScreen.is = is;
-})(SingleScreen || (SingleScreen = {}));
-var SingleScreenImpl = class extends BaseScreenImpl {
-	constructor(options, screen) {
-		super(options);
-		this.options = options;
-		this.screen = screen;
+		return value instanceof ProductConfigFileImpl;
+	}
+	_ProductConfigFile.is = is;
+})(ProductConfigFile || (ProductConfigFile = {}));
+var ProductConfigFileImpl = class extends SerializableFileImpl {
+	async serialize() {
+		return JSON.stringify(this.getContent(), null, 2);
+	}
+	async write() {
+		const { imageBasePath, adapter: { join } } = this.getImageManager().getOptions();
+		return this.writeToFileSystem(join(imageBasePath, "productConfig.json"));
+	}
+	findProductConfigItems(options = {}) {
+		const content = this.getContent();
+		const items = [];
+		for (const deviceType of Object.keys(content)) {
+			if (options.deviceType && deviceType !== options.deviceType) continue;
+			for (const item of content[deviceType]) {
+				if (options.name && item.name !== options.name) continue;
+				items.push(new ProductConfigItemImpl(this, item, deviceType));
+			}
+		}
+		return items;
 	}
-	getScreen() {
-		return this.screen;
+	findProductConfigItem(options = {}) {
+		return this.findProductConfigItems(options)[0];
 	}
 };
-function createSingleScreen(options, screen) {
-	return new SingleScreenImpl(options, screen);
-}
 
 //#endregion
-//#region src/screens/screen.ts
-let Screen;
-(function(_Screen) {
+//#region src/devices/device.ts
+let Device;
+(function(_Device) {
 	function is(value) {
-		return value instanceof ScreenImpl;
-	}
-	_Screen.is = is;
-})(Screen || (Screen = {}));
-var ScreenImpl = class extends BaseScreenImpl {
-	outerScreen;
-	coverScreen;
-	singleScreen;
-	doubleScreen;
+		return value instanceof DeviceImpl;
+	}
+	_Device.is = is;
+})(Device || (Device = {}));
+var DeviceImpl = class {
 	constructor(options) {
-		super(options);
 		this.options = options;
-		if (options.outer) this.outerScreen = OuterScreen.is(options.outer) ? options.outer : createOuterScreen(options.outer, this);
-		if (options.cover) this.coverScreen = CoverScreen.is(options.cover) ? options.cover : createCoverScreen(options.cover, this);
-		if (options.single) this.singleScreen = SingleScreen.is(options.single) ? options.single : createSingleScreen(options.single, this);
-		if (options.double) this.doubleScreen = DoubleScreen.is(options.double) ? options.double : createDoubleScreen(options.double, this);
 	}
 	getScreen() {
-		return this;
+		return this.options.screen;
 	}
-	getApiVersion() {
-		return this.options.apiVersion;
+	getListsFile() {
+		return this.options.listsFile;
 	}
-	getSnakecaseDeviceType() {
-		return this.options.deviceType;
+	getListsFileItem() {
+		return this.options.listFileItem;
 	}
-	getOuterScreen() {
-		return this.outerScreen;
+	getImageManager() {
+		return this.options.imageManager;
 	}
-	setOuterScreen(outerScreen) {
-		this.outerScreen = OuterScreen.is(outerScreen) ? outerScreen : createOuterScreen(outerScreen, this);
+	_configIniFile;
+	setConfigIniFile(configIniFile) {
+		this._configIniFile = configIniFile;
 		return this;
 	}
-	getCoverScreen() {
-		return this.coverScreen;
+	getConfigIniFile() {
+		return this._configIniFile;
 	}
-	setCoverScreen(coverScreen) {
-		this.coverScreen = CoverScreen.is(coverScreen) ? coverScreen : createCoverScreen(coverScreen, this);
+	_namedIniFile;
+	getNamedIniFile() {
+		return this._namedIniFile;
+	}
+	setNamedIniFile(namedIniFile) {
+		this._namedIniFile = namedIniFile;
 		return this;
 	}
-	getSingleScreen() {
-		return this.singleScreen;
+	getExecutableUri() {
+		const { emulatorPath, adapter: { join, process } } = this.getImageManager().getOptions();
+		return join(emulatorPath, process.platform === "win32" ? "Emulator.exe" : "Emulator");
 	}
-	setSingleScreen(singleScreen) {
-		this.singleScreen = SingleScreen.is(singleScreen) ? singleScreen : createSingleScreen(singleScreen, this);
-		return this;
+	getSnapshotUri() {
+		const { deployedPath, adapter: { join } } = this.getImageManager().getOptions();
+		return join(deployedPath, this.getListsFileItem().getContent().name, "Snapshot.png");
 	}
-	getDoubleScreen() {
-		return this.doubleScreen;
+	async getSnapshot() {
+		const snapshotUri = this.getSnapshotUri();
+		const { adapter: { fs } } = this.getImageManager().getOptions();
+		return fromByteArray(await fs.readFile(snapshotUri));
 	}
-	setDoubleScreen(doubleScreen) {
-		this.doubleScreen = DoubleScreen.is(doubleScreen) ? doubleScreen : createDoubleScreen(doubleScreen, this);
-		return this;
+	getStartCommand() {
+		const listFileItemContent = this.getListsFileItem().getContent();
+		return [this.getExecutableUri().fsPath, [
+			"-hvd",
+			listFileItemContent.name,
+			"-path",
+			this.getImageManager().getOptions().deployedPath.fsPath,
+			"-imageRoot",
+			this.getImageManager().getOptions().imageBasePath.fsPath
+		]];
+	}
+	async start() {
+		const { emulatorPath, adapter: { child_process } } = this.getImageManager().getOptions();
+		const [executableUri, args] = this.getStartCommand();
+		return child_process.spawn(executableUri, args, {
+			cwd: emulatorPath.fsPath,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+	}
+	getStopCommand() {
+		const listFileItemContent = this.getListsFileItem().getContent();
+		return [this.getExecutableUri().fsPath, ["-stop", listFileItemContent.name]];
+	}
+	async stop() {
+		const { emulatorPath, adapter: { child_process } } = this.getImageManager().getOptions();
+		const [executableUri, args] = this.getStopCommand();
+		return child_process.spawn(executableUri, args, {
+			cwd: emulatorPath.fsPath,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+	}
+	async delete() {
+		const { deployedPath, adapter: { join, fs } } = this.getImageManager().getOptions();
+		await Promise.allSettled([
+			fs.delete(join(deployedPath, this.getListsFileItem().getContent().name), { recursive: true }),
+			fs.delete(join(deployedPath, `${this.getListsFileItem().getContent().name}.ini`), { recursive: false }),
+			this.getImageManager().readListsFile().then(async (listsFile) => {
+				const listsFileItem = listsFile.getListsFileItems().find((item) => {
+					return item.getContent().name === this.getListsFileItem().getContent().name;
+				});
+				if (!listsFileItem) return;
+				await listsFile.deleteListsFileItem(listsFileItem).write();
+			})
+		]);
+	}
+	async getStorageSize() {
+		const { deployedPath, adapter: { join, fs } } = this.getImageManager().getOptions();
+		return (await fs.stat(join(deployedPath, this.getListsFileItem().getContent().name))).size;
+	}
+	_watcher;
+	async getWatcher() {
+		if (this._watcher && !this._watcher.isDisposed) return this._watcher;
+		const { deployedPath, adapter: { fs, join } } = this.getImageManager().getOptions();
+		this._watcher = await fs.createWatcher(new RelativePattern(join(deployedPath, this.getListsFileItem().getContent().name), "**"));
+		return this._watcher;
+	}
+	toJSON() {
+		return {
+			screen: this.getScreen(),
+			listsFile: this.getListsFile().toJSON(),
+			listsFileItem: this.getListsFileItem().toJSON(),
+			configIniFile: this.getConfigIniFile().toJSON(),
+			namedIniFile: this.getNamedIniFile().toJSON(),
+			executableUri: this.getExecutableUri().toJSON(),
+			snapshotUri: this.getSnapshotUri().toJSON(),
+			startCommand: this.getStartCommand(),
+			stopCommand: this.getStopCommand()
+		};
+	}
+};
+
+//#endregion
+//#region src/configs/named-ini/named-ini.ts
+let NamedIniFile;
+(function(_NamedIniFile) {
+	function is(value) {
+		return value instanceof NamedIniFileImpl;
+	}
+	_NamedIniFile.is = is;
+})(NamedIniFile || (NamedIniFile = {}));
+var NamedIniFileImpl = class extends SerializableFileImpl {
+	constructor(device, namedIniFilePath, content) {
+		super(device.getImageManager(), content);
+		this.device = device;
+		this.namedIniFilePath = namedIniFilePath;
+		this.content = content;
+	}
+	getDevice() {
+		return this.device;
+	}
+	static getFileUri(device) {
+		const { deployedPath, adapter: { join } } = device.getImageManager().getOptions();
+		return join(deployedPath, `${device.getListsFileItem().getContent().name}.ini`);
+	}
+	getFileUri() {
+		return this.namedIniFilePath;
+	}
+	static async safeReadAndParse(device) {
+		try {
+			const { adapter: { fs } } = device.getImageManager().getOptions();
+			const namedIniFileUri = this.getFileUri(device);
+			const namedIniFileContent = await fs.readFile(namedIniFileUri).then((buffer) => buffer.toString(), () => void 0);
+			if (!namedIniFileContent?.length) return;
+			return INI.parse(namedIniFileContent);
+		} catch {}
+	}
+	async serialize() {
+		return INI.stringify(this.getContent());
+	}
+	async write() {
+		const { deployedPath, adapter: { join } } = this.getImageManager().getOptions();
+		return this.writeToFileSystem(join(deployedPath, `${this.getDevice().getListsFileItem().getContent().name}.ini`));
+	}
+	toJSON() {
+		return {
+			imageManager: this.getImageManager().toJSON(),
+			content: this.getContent(),
+			fileUri: this.getFileUri().toJSON()
+		};
+	}
+};
+
+//#endregion
+//#region src/screens/customize-screen.ts
+let CustomizeScreen;
+(function(_CustomizeScreen) {
+	function is(value) {
+		return value instanceof CustomizeScreenImpl;
+	}
+	_CustomizeScreen.is = is;
+})(CustomizeScreen || (CustomizeScreen = {}));
+var CustomizeScreenImpl = class {
+	constructor(screenPreset, options) {
+		this.screenPreset = screenPreset;
+		this.options = options;
+	}
+	getConfigName() {
+		return this.options?.configName ?? "Customize_01";
+	}
+	getDiagonalSize() {
+		return this.options?.diagonalSize ?? 0;
+	}
+	getResolutionWidth() {
+		return this.options?.resolutionWidth ?? 0;
+	}
+	getResolutionHeight() {
+		return this.options?.resolutionHeight ?? 0;
 	}
 	getDensity() {
-		return this.options.density;
+		return this.options?.density ?? 0;
 	}
-	setDensity(density) {
-		this.options.density = density;
-		return this;
+	getScreenPreset() {
+		return this.screenPreset;
+	}
+	toJSON() {
+		return {
+			configName: this.getConfigName(),
+			diagonalSize: this.getDiagonalSize(),
+			resolutionWidth: this.getResolutionWidth(),
+			resolutionHeight: this.getResolutionHeight(),
+			density: this.getDensity()
+		};
+	}
+};
+
+//#endregion
+//#region src/screens/customize-foldable-screen.ts
+let CustomizeFoldableScreen;
+(function(_CustomizeFoldableScreen) {
+	function is(value) {
+		return value instanceof CustomizeFoldableScreenImpl;
+	}
+	_CustomizeFoldableScreen.is = is;
+})(CustomizeFoldableScreen || (CustomizeFoldableScreen = {}));
+var CustomizeFoldableScreenImpl = class extends CustomizeScreenImpl {
+	constructor(screenPreset, options, foldableOptions) {
+		super(screenPreset, options);
+		this.screenPreset = screenPreset;
+		this.options = options;
+		this.foldableOptions = foldableOptions;
+	}
+	getCoverResolutionWidth() {
+		return this.foldableOptions?.coverResolutionWidth ?? 0;
+	}
+	getCoverResolutionHeight() {
+		return this.foldableOptions?.coverResolutionHeight ?? 0;
+	}
+	getCoverDiagonalSize() {
+		return this.foldableOptions?.coverDiagonalSize ?? 0;
 	}
 	toJSON() {
 		return {
 			...super.toJSON(),
-			density: this.options.density,
-			apiVersion: this.options.apiVersion,
-			deviceType: this.options.deviceType,
-			outer: this.outerScreen?.toJSON(),
-			cover: this.coverScreen?.toJSON(),
-			single: this.singleScreen?.toJSON()
+			coverResolutionWidth: this.getCoverResolutionWidth(),
+			coverResolutionHeight: this.getCoverResolutionHeight(),
+			coverDiagonalSize: this.getCoverDiagonalSize()
 		};
 	}
 };
-function createScreen(options) {
-	return new ScreenImpl(options);
-}
 
 //#endregion
 //#region src/screens/screen-preset.ts
 let ScreenPreset;
 (function(_ScreenPreset) {
-	let ScreenOptions;
-	(function(_ScreenOptions) {
-		function is(value) {
-			return typeof value === "object" && value !== null && "screen" in value && Screen.is(value.screen);
-		}
-		_ScreenOptions.is = is;
-	})(ScreenOptions || (ScreenOptions = _ScreenPreset.ScreenOptions || (_ScreenPreset.ScreenOptions = {})));
-	let ProductOptions;
-	(function(_ProductOptions) {
-		function is(value) {
-			return typeof value === "object" && value !== null && "image" in value && "productConfig" in value && ProductConfigItem.is(value.productConfig);
-		}
-		_ProductOptions.is = is;
-	})(ProductOptions || (ProductOptions = _ScreenPreset.ProductOptions || (_ScreenPreset.ProductOptions = {})));
-	let EmulatorOptions;
-	(function(_EmulatorOptions) {
-		function is(value) {
-			return typeof value === "object" && value !== null && "image" in value && "emulatorConfig" in value;
-		}
-		_EmulatorOptions.is = is;
-	})(EmulatorOptions || (EmulatorOptions = _ScreenPreset.EmulatorOptions || (_ScreenPreset.EmulatorOptions = {})));
 	function is(value) {
 		return value instanceof ScreenPresetImpl;
 	}
 	_ScreenPreset.is = is;
 })(ScreenPreset || (ScreenPreset = {}));
 var ScreenPresetImpl = class {
-	emulatorPreset;
-	productPreset;
 	constructor(options) {
 		this.options = options;
-		this._screen = this.getScreen();
-		this.setEmulatorPreset();
-		this.setProductPreset();
 	}
-	_screen;
-	getScreen() {
-		if (ScreenPreset.ScreenOptions.is(this.options)) return this.options.screen;
-		if (this._screen) return this._screen;
-		if (ScreenPreset.ProductOptions.is(this.options)) {
-			this._screen = createScreen({
-				width: Number(this.options.productConfig.screenWidth),
-				height: Number(this.options.productConfig.screenHeight),
-				diagonal: Number(this.options.productConfig.screenDiagonal),
-				density: Number(this.options.productConfig.screenDensity),
-				apiVersion: Number.parseInt(this.options.image.getApiVersion()),
-				deviceType: this.options.image.getSnakecaseDeviceType()
-			});
-			if (this.options.productConfig.outerScreenWidth && this.options.productConfig.outerScreenHeight && this.options.productConfig.outerScreenDiagonal) this._screen.setOuterScreen(createOuterScreen({
-				width: Number(this.options.productConfig.outerScreenWidth),
-				height: Number(this.options.productConfig.outerScreenHeight),
-				diagonal: Number(this.options.productConfig.outerScreenDiagonal)
-			}, this._screen));
-			if (this.options.productConfig.outerDoubleScreenWidth && this.options.productConfig.outerDoubleScreenHeight && this.options.productConfig.outerDoubleScreenDiagonal) this._screen.getOuterScreen()?.setOuterDoubleScreen(createOuterDoubleScreen({
-				width: Number(this.options.productConfig.outerDoubleScreenWidth),
-				height: Number(this.options.productConfig.outerDoubleScreenHeight),
-				diagonal: Number(this.options.productConfig.outerDoubleScreenDiagonal)
-			}, this._screen.getOuterScreen()));
-			return this._screen;
-		}
-		if (ScreenPreset.EmulatorOptions.is(this.options)) {
-			this._screen = createScreen({
-				width: this.options.emulatorConfig.resolutionWidth,
-				height: this.options.emulatorConfig.resolutionHeight,
-				diagonal: this.options.emulatorConfig.diagonalSize,
-				density: this.options.emulatorConfig.density,
-				apiVersion: Number.parseInt(this.options.image.getApiVersion()),
-				deviceType: this.options.image.getSnakecaseDeviceType()
-			});
-			if (this.options.emulatorConfig.coverResolutionWidth && this.options.emulatorConfig.coverResolutionHeight && this.options.emulatorConfig.coverDiagonalSize) this._screen.setCoverScreen(createCoverScreen({
-				width: this.options.emulatorConfig.coverResolutionWidth,
-				height: this.options.emulatorConfig.coverResolutionHeight,
-				diagonal: this.options.emulatorConfig.coverDiagonalSize
-			}, this._screen));
-			if (PhoneAllEmulatorConfigItem.is(this.options.emulatorConfig)) {
-				if (this.options.emulatorConfig.singleResolutionWidth && this.options.emulatorConfig.singleResolutionHeight && this.options.emulatorConfig.singleDiagonalSize) this._screen.setSingleScreen(createSingleScreen({
-					width: this.options.emulatorConfig.singleResolutionWidth,
-					height: this.options.emulatorConfig.singleResolutionHeight,
-					diagonal: this.options.emulatorConfig.singleDiagonalSize
-				}, this._screen));
-				if (this.options.emulatorConfig.doubleResolutionWidth && this.options.emulatorConfig.doubleResolutionHeight && this.options.emulatorConfig.doubleDiagonalSize) this._screen.setDoubleScreen(createDoubleScreen({
-					width: this.options.emulatorConfig.doubleResolutionWidth,
-					height: this.options.emulatorConfig.doubleResolutionHeight,
-					diagonal: this.options.emulatorConfig.doubleDiagonalSize
-				}, this._screen));
-			}
-			return this._screen;
-		}
-		throw new Error("Invalid createScreenPreset options.");
-	}
-	getProductConfigItemsByScreenOptions() {
-		if (!ScreenPreset.ScreenOptions.is(this.options)) return;
-		for (const [pascalCaseDeviceType, productConfigItem] of Object.entries(this.options.productConfig ?? {})) if (pascalCaseDeviceType === "2in1" && this.getScreen().getSnakecaseDeviceType() === "2in1") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "2in1 Foldable" && this.getScreen().getSnakecaseDeviceType() === "2in1_foldable") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "Foldable" && this.getScreen().getSnakecaseDeviceType() === "foldable") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "Phone" && this.getScreen().getSnakecaseDeviceType() === "phone") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "TV" && this.getScreen().getSnakecaseDeviceType() === "tv") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "Tablet" && this.getScreen().getSnakecaseDeviceType() === "tablet") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "TripleFold" && this.getScreen().getSnakecaseDeviceType() === "triplefold") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "Wearable" && this.getScreen().getSnakecaseDeviceType() === "wearable") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType === "WideFold" && this.getScreen().getSnakecaseDeviceType() === "widefold") return [productConfigItem, pascalCaseDeviceType];
-		else if (pascalCaseDeviceType.toLowerCase() === this.getScreen().getSnakecaseDeviceType().toLowerCase()) return [productConfigItem, pascalCaseDeviceType];
-	}
-	setProductPreset() {
-		if (ScreenPreset.ScreenOptions.is(this.options)) {
-			const [productConfigItems = [], pascalCaseDeviceType] = this.getProductConfigItemsByScreenOptions() ?? [];
-			if (!pascalCaseDeviceType || !productConfigItems.length) return;
-			for (const productConfigItem of productConfigItems) {
-				if (this.getScreen().getWidth() !== Number(productConfigItem.screenWidth) || this.getScreen().getHeight() !== Number(productConfigItem.screenHeight) || this.getScreen().getDiagonal() !== Number(productConfigItem.screenDiagonal) || this.getScreen().getDensity() !== Number(productConfigItem.screenDensity)) continue;
-				if (productConfigItem.outerScreenWidth && productConfigItem.outerScreenHeight && productConfigItem.outerScreenDiagonal) {
-					const outerScreen = this.getScreen().getOuterScreen();
-					if (!outerScreen) continue;
-					if (outerScreen.getWidth() !== Number(productConfigItem.outerScreenWidth) || outerScreen.getHeight() !== Number(productConfigItem.outerScreenHeight) || outerScreen.getDiagonal() !== Number(productConfigItem.outerScreenDiagonal)) continue;
-				}
-				if (productConfigItem.outerDoubleScreenWidth && productConfigItem.outerDoubleScreenHeight && productConfigItem.outerDoubleScreenDiagonal) {
-					const outerDoubleScreen = this.getScreen().getOuterScreen()?.getOuterDoubleScreen();
-					if (!outerDoubleScreen) continue;
-					if (outerDoubleScreen.getWidth() !== Number(productConfigItem.outerDoubleScreenWidth) || outerDoubleScreen.getHeight() !== Number(productConfigItem.outerDoubleScreenHeight) || outerDoubleScreen.getDiagonal() !== Number(productConfigItem.outerDoubleScreenDiagonal)) continue;
-				}
-				this.productPreset = createProductPreset(productConfigItem, pascalCaseDeviceType, this);
-				return;
-			}
-		} else if (ScreenPreset.ProductOptions.is(this.options)) this.productPreset = createProductPreset(this.options.productConfig, this.options.pascalCaseDeviceType, this);
-		else if (ScreenPreset.EmulatorOptions.is(this.options)) this.emulatorPreset = createEmulatorPreset(this.options.emulatorConfig, this);
-	}
-	setEmulatorPreset() {
-		if (ScreenPreset.ScreenOptions.is(this.options)) {
-			if (!this.options.emulatorConfig) return;
-			for (const parentConfigItem of this.options.emulatorConfig) {
-				if (parentConfigItem.api !== this.options.screen.getApiVersion()) continue;
-				if (ParentEmulatorConfigItem.is(parentConfigItem) && parentConfigItem.deviceType === this.options.screen.getSnakecaseDeviceType()) {
-					this.emulatorPreset = createEmulatorPreset(parentConfigItem, this);
-					return;
-				}
-				if (GroupPhoneAllEmulatorConfigItem.is(parentConfigItem) && isPhoneAllSnakecaseDeviceType(this.options.screen.getSnakecaseDeviceType())) {
-					for (const childrenConfigItem of parentConfigItem.children) if (PhoneAllEmulatorConfigItem.is(childrenConfigItem) && childrenConfigItem.deviceType === this.options.screen.getSnakecaseDeviceType()) {
-						this.emulatorPreset = createEmulatorPreset(childrenConfigItem, this);
-						return;
-					}
-				}
-				if (GroupPCAllEmulatorConfigItem.is(parentConfigItem) && isPCAllSnakecaseDeviceType(this.options.screen.getSnakecaseDeviceType())) {
-					for (const childrenConfigItem of parentConfigItem.children) if (PCAllEmulatorConfigItem.is(childrenConfigItem) && childrenConfigItem.deviceType === this.options.screen.getSnakecaseDeviceType()) {
-						this.emulatorPreset = createEmulatorPreset(childrenConfigItem, this);
-						return;
-					}
-				}
-			}
-		} else if (ScreenPreset.EmulatorOptions.is(this.options)) this.emulatorPreset = createEmulatorPreset(this.options.emulatorConfig, this);
+	getEmulatorDeviceItem() {
+		return this.options.emulatorDeviceItem;
 	}
-	getEmulatorPreset() {
-		return this.emulatorPreset;
+	getProductConfigItem() {
+		return this.options.productConfigItem;
 	}
-	getProductPreset() {
-		return this.productPreset;
+	_customizeScreen;
+	getCustomizeScreenConfig() {
+		if (this._customizeScreen) return this._customizeScreen;
+		if (this.getEmulatorDeviceItem().getContent().deviceType === "foldable" && this.options.productConfigItem.getContent().name === "Customize" && "customizeScreen" in this.options && "customizeFoldableScreen" in this.options) this._customizeScreen = new CustomizeFoldableScreenImpl(this, this.options.customizeScreen, this.options.customizeFoldableScreen);
+		else if (this.options.productConfigItem.getContent().name === "Customize" && "customizeScreen" in this.options) this._customizeScreen = new CustomizeScreenImpl(this, this.options.customizeScreen);
+		return this._customizeScreen;
 	}
 	toJSON() {
 		return {
-			emulatorPreset: this.emulatorPreset?.toJSON(),
-			productPreset: this.productPreset?.toJSON()
+			customizeScreenConfig: this.getCustomizeScreenConfig()?.toJSON(),
+			emulatorDeviceItem: this.getEmulatorDeviceItem().toJSON(),
+			productConfigItem: this.getProductConfigItem().toJSON()
 		};
 	}
 };
-function createScreenPreset(options) {
-	return new ScreenPresetImpl(options);
-}
 
 //#endregion
-//#region src/devices/device.ts
-var DeviceImpl = class {
-	uuid;
-	constructor(image, options) {
-		this.image = image;
-		this.options = options;
-		this.uuid = image.getImageManager().getOptions().crypto.randomUUID();
-	}
-	getOptions() {
-		return this.options;
-	}
-	getImage() {
-		return this.image;
-	}
-	getScreen() {
-		if (this.options.screen instanceof ScreenPresetImpl) return this.options.screen.getScreen();
-		return this.options.screen;
+//#region src/images/base-image.ts
+let BaseImage;
+(function(_BaseImage) {
+	function is(value) {
+		return value instanceof BaseImageImpl;
 	}
-	getScreenPreset() {
-		if (this.options.screen instanceof ScreenPresetImpl) return this.options.screen;
+	_BaseImage.is = is;
+})(BaseImage || (BaseImage = {}));
+var BaseImageImpl = class {
+	constructor(options) {
+		this.options = options;
 	}
-	setUuid(uuid) {
-		this.uuid = uuid;
-		return this;
+	getImageManager() {
+		return this.options.imageManager;
 	}
-	getUuid() {
-		return this.uuid;
+	getRelativePath() {
+		return this.options.relativePath;
 	}
-	cachedList = null;
-	setCachedList(list) {
-		this.cachedList = list;
-		return this;
+	getFullPath() {
+		const { imageBasePath, adapter: { join } } = this.getImageManager().getOptions();
+		return join(imageBasePath, this.getRelativePath());
 	}
-	cachedIni = null;
-	setCachedIni(ini) {
-		this.cachedIni = ini;
-		return this;
+	getApiVersion() {
+		return this.options.apiVersion;
 	}
-	buildList() {
-		if (this.cachedList) return this.cachedList;
-		const { path, deployedPath, imageBasePath, configPath, logPath } = this.image.getImageManager().getOptions();
-		const screen = this.getScreen();
-		const list = {
-			"name": this.options.name,
-			"apiVersion": this.image.getApiVersion(),
-			"cpuNumber": this.options.cpuNumber.toFixed(),
-			"diagonalSize": screen.getDiagonal().toFixed(2),
-			"resolutionHeight": screen.getHeight().toFixed(),
-			"resolutionWidth": screen.getWidth().toFixed(),
-			"density": screen.getDensity().toFixed(),
-			"memoryRamSize": this.options.memorySize.toFixed(),
-			"dataDiskSize": this.options.diskSize.toFixed(),
-			"path": path.resolve(deployedPath, this.options.name),
-			"type": this.image.getSnakecaseDeviceType(),
-			"uuid": this.uuid,
-			"version": this.image.getVersion(),
-			"imageDir": this.image.getPath().split(",").join(path.sep) + path.sep,
-			"showVersion": `${this.image.getTargetOS()} ${this.image.getTargetVersion()}(${this.image.getApiVersion()})`,
-			"harmonyos.sdk.path": imageBasePath,
-			"harmonyos.config.path": configPath,
-			"harmonyos.log.path": logPath,
-			"hw.apiName": this.image.getTargetVersion(),
-			"abi": this.image.getArch(),
-			"harmonyOSVersion": `${this.image.getTargetOS()}-${this.image.getTargetVersion()}`,
-			"guestVersion": `${this.image.getTargetOS()} ${this.image.getVersion()}(${this.image.getReleaseType()})`
-		};
-		if (this.options.screen instanceof ScreenPresetImpl) {
-			const productConfig = this.options.screen.getProductPreset()?.getProductConfig();
-			if (productConfig?.devModel) list.devModel = productConfig.devModel;
-			if (productConfig?.name) list.model = productConfig.name;
-		}
-		return list;
-	}
-	buildIni(options = {}) {
-		if (this.cachedIni) return this.cachedIni;
-		const listConfig = this.buildList();
-		const screen = this.getScreen();
-		const is2in1Foldable = listConfig.type === "2in1_foldable";
-		const screenPreset = this.options.screen instanceof ScreenPresetImpl ? this.options.screen.getProductPreset() : null;
-		const productConfig = screenPreset?.getProductConfig();
-		const useDualScreen = is2in1Foldable && productConfig?.outerScreenWidth != null && productConfig?.outerScreenHeight != null && productConfig?.outerScreenDiagonal != null;
-		const singleDiagonal = useDualScreen ? productConfig.outerScreenDiagonal : screen.getDiagonal().toString();
-		const singleHeight = useDualScreen ? productConfig.outerScreenHeight : screen.getHeight().toString();
-		const singleWidth = useDualScreen ? productConfig.outerScreenWidth : screen.getWidth().toString();
-		const doubleDiagonal = useDualScreen ? productConfig.screenDiagonal : void 0;
-		const doubleHeight = useDualScreen ? productConfig.screenHeight : void 0;
-		const doubleWidth = useDualScreen ? productConfig.screenWidth : void 0;
-		const ini = {
-			"name": listConfig.name,
-			"deviceType": listConfig.type,
-			"deviceModel": listConfig.devModel,
-			"productModel": listConfig.model,
-			"vendorCountry": options.vendorCountry ?? "CN",
-			"uuid": this.uuid,
-			"configPath": listConfig["harmonyos.config.path"],
-			"logPath": listConfig["harmonyos.log.path"],
-			"sdkPath": listConfig["harmonyos.sdk.path"],
-			"imageSubPath": listConfig.imageDir,
-			"instancePath": listConfig.path,
-			"os.osVersion": `${this.image.getTargetOS()} ${this.image.getTargetVersion()}(${this.image.getApiVersion()})`,
-			"os.apiVersion": this.image.getApiVersion(),
-			"os.softwareVersion": this.image.getVersion(),
-			"os.isPublic": options.isPublic ?? true ? "true" : "false",
-			"hw.cpu.arch": listConfig.abi,
-			"hw.cpu.ncore": listConfig.cpuNumber,
-			"hw.lcd.density": screen.getDensity().toFixed(),
-			"hw.lcd.single.diagonalSize": singleDiagonal,
-			"hw.lcd.single.height": singleHeight,
-			"hw.lcd.single.width": singleWidth,
-			"hw.lcd.number": useDualScreen ? "2" : "1",
-			"hw.ramSize": listConfig.memoryRamSize,
-			"hw.dataPartitionSize": listConfig.dataDiskSize,
-			"isCustomize": screenPreset ? "false" : "true",
-			"hw.hdc.port": "notset",
-			...options.overrides
-		};
-		if (useDualScreen && doubleDiagonal != null && doubleHeight != null && doubleWidth != null) {
-			ini["hw.lcd.double.diagonalSize"] = doubleDiagonal;
-			ini["hw.lcd.double.height"] = doubleHeight;
-			ini["hw.lcd.double.width"] = doubleWidth;
-		}
-		if (screenPreset && productConfig && !useDualScreen) {
-			if (productConfig.outerScreenHeight) ini["hw.phy.height"] = productConfig.outerScreenHeight;
-			if (productConfig.outerScreenWidth) ini["hw.phy.width"] = productConfig.outerScreenWidth;
+	async isDownloaded() {
+		try {
+			return (await this.getImageManager().getLocalImages()).some((localImage) => localImage.getFullPath().toString() === this.getFullPath().toString());
+		} catch {
+			return false;
 		}
-		return ini;
 	}
-	toIniString() {
-		return `${Object.entries(this.buildIni()).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
-	}
-	buildDeviceIni() {
+	toJSON() {
 		return {
-			"hvd.ini.encoding": "UTF-8",
-			"path": this.buildList().path
+			imageType: this.imageType,
+			imageManager: this.getImageManager().toJSON(),
+			relativePath: this.getRelativePath(),
+			fullPath: this.getFullPath().toJSON(),
+			apiVersion: this.getApiVersion(),
+			fullDeviceType: this.getFullDeviceType()
 		};
 	}
-	buildDeviceIniString() {
-		return `${Object.entries(this.buildDeviceIni()).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
-	}
-	async deploy() {
-		if (await this.isDeployed()) throw new DeployError(DeployError.Code.DEVICE_ALREADY_DEPLOYED, `Image ${this.options.name} already deployed`);
-		const { fs, path, deployedPath } = this.image.getImageManager().getOptions();
-		if (!fs.existsSync(deployedPath)) fs.mkdirSync(deployedPath, { recursive: true });
-		const listsPath = path.join(deployedPath, "lists.json");
-		const listConfig = this.buildList();
-		if (!fs.existsSync(listsPath)) return fs.writeFileSync(listsPath, JSON.stringify([listConfig], null, 2));
-		const lists = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
-		if (!Array.isArray(lists)) throw new DeployError(DeployError.Code.LIST_JSON_NOT_AN_ARRAY, "Lists is not an array");
-		if (lists.find((item) => item.name === listConfig.name)) throw new DeployError(DeployError.Code.DEVICE_ALREADY_DEPLOYED, `Image ${listConfig.name} already deployed in lists.json`);
-		lists.push(listConfig);
-		fs.mkdirSync(listConfig.path, { recursive: true });
-		fs.writeFileSync(path.join(listConfig.path, "config.ini"), this.toIniString());
-		fs.writeFileSync(path.join(deployedPath, `${this.options.name}.ini`), this.buildDeviceIniString());
-		fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2));
+};
+
+//#endregion
+//#region src/images/local-image.ts
+let LocalImage;
+(function(_LocalImage) {
+	function is(value) {
+		return value instanceof LocalImageImpl;
 	}
-	async delete() {
-		const { fs, path, deployedPath } = this.image.getImageManager().getOptions();
-		const listsPath = path.join(deployedPath, "lists.json");
-		if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile()) throw new Error("Lists file not found");
-		const lists = JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? [];
-		const index = lists.findIndex((item) => item.name === this.options.name);
-		if (index === -1) throw new Error(`Device ${this.options.name} not found`);
-		lists.splice(index, 1);
-		fs.writeFileSync(listsPath, JSON.stringify(lists, null, 2));
-		fs.rmSync(path.resolve(this.buildList().path), { recursive: true });
-		fs.rmSync(path.resolve(deployedPath, `${this.options.name}.ini`));
-	}
-	async isDeployed() {
-		const { fs, path, deployedPath } = this.image.getImageManager().getOptions();
-		const listsPath = path.join(deployedPath, "lists.json");
-		if (!fs.existsSync(listsPath) || !fs.statSync(listsPath).isFile()) return false;
-		return (JSON.parse(fs.readFileSync(listsPath, "utf-8")) ?? []).some((item) => item.name === this.options.name && fs.existsSync(path.resolve(item.path, "config.ini")));
+	_LocalImage.is = is;
+})(LocalImage || (LocalImage = {}));
+var LocalImageImpl = class extends BaseImageImpl {
+	imageType = "local";
+	constructor(imageManager, sdkPkgFile, infoFile) {
+		super({
+			imageManager,
+			apiVersion: Number.parseInt(sdkPkgFile?.data?.apiVersion ?? "0"),
+			relativePath: sdkPkgFile?.data?.path?.split(",").join("/")
+		});
+		this.imageManager = imageManager;
+		this.sdkPkgFile = sdkPkgFile;
+		this.infoFile = infoFile;
+	}
+	getSdkPkgFile() {
+		return this.sdkPkgFile;
+	}
+	getFullDeviceType() {
+		const name = this.getSdkPkgFile().data?.displayName?.split("-");
+		return name?.[name.length - 1];
+	}
+	async createDevice(options) {
+		const { deployedPath, imageBasePath, configPath, logPath, adapter: { join } } = this.getImageManager().getOptions();
+		const screen = new ScreenPresetImpl(options.screen);
+		const emulatorDeviceItem = screen.getEmulatorDeviceItem();
+		const productConfigItem = screen.getProductConfigItem();
+		const listsFile = await this.getImageManager().readListsFile();
+		const uuid = crypto.randomUUID();
+		const deviceFolderPath = join(deployedPath, options.name);
+		const listFileItem = listsFile.addListsFileItem({
+			uuid,
+			"name": options.name,
+			"apiVersion": this.getApiVersion().toString(),
+			"cpuNumber": options.cpuNumber.toString(),
+			"path": deviceFolderPath.fsPath,
+			"memoryRamSize": options.memoryRamSize.toString(),
+			"dataDiskSize": options.dataDiskSize.toString(),
+			"version": this.getSdkPkgFile().data?.version ?? "",
+			"imageDir": this.getRelativePath(),
+			"showVersion": this.getSdkPkgFile().data?.guestVersion ?? "",
+			"harmonyos.sdk.path": imageBasePath.fsPath,
+			"harmonyos.config.path": configPath.fsPath,
+			"harmonyos.log.path": logPath.fsPath,
+			"hw.apiName": this.getSdkPkgFile().data?.platformVersion ?? "",
+			"abi": this.infoFile.abi,
+			"harmonyOSVersion": `${this.getSdkPkgFile().data?.guestVersion?.split(" ")[0]}-${this.getSdkPkgFile().data?.platformVersion}`,
+			"guestVersion": this.getSdkPkgFile().data?.guestVersion ?? "",
+			"diagonalSize": emulatorDeviceItem.getContent().diagonalSize.toString(),
+			"density": emulatorDeviceItem.getContent().density.toString(),
+			"resolutionWidth": emulatorDeviceItem.getContent().resolutionWidth.toString(),
+			"resolutionHeight": emulatorDeviceItem.getContent().resolutionHeight.toString(),
+			"coverResolutionWidth": EmulatorFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().coverResolutionWidth.toString() : void 0,
+			"coverResolutionHeight": EmulatorFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().coverResolutionHeight.toString() : void 0,
+			"coverDiagonalSize": EmulatorFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().coverDiagonalSize.toString() : void 0,
+			"type": emulatorDeviceItem.getContent().deviceType,
+			"devModel": productConfigItem.getDevModel(),
+			"model": productConfigItem.getContent().name
+		});
+		const device = new DeviceImpl({
+			imageManager: this.getImageManager(),
+			listsFile,
+			listFileItem,
+			screen
+		});
+		const deviceIniFile = new ConfigIniFileImpl(device, ConfigIniFileImpl.getFileUri(device), {
+			"name": listFileItem.getContent().name,
+			"deviceType": listFileItem.getContent().type,
+			"deviceModel": listFileItem.getContent().devModel,
+			"productModel": listFileItem.getContent().model,
+			"vendorCountry": options.vendorCountry ?? "CN",
+			"uuid": listFileItem.getContent().uuid,
+			"configPath": listFileItem.getContent()["harmonyos.config.path"],
+			"logPath": listFileItem.getContent()["harmonyos.log.path"],
+			"sdkPath": listFileItem.getContent()["harmonyos.sdk.path"],
+			"imageSubPath": listFileItem.getContent().imageDir,
+			"instancePath": listFileItem.getContent().path,
+			"os.osVersion": `${this.getSdkPkgFile().data?.guestVersion?.split(" ")[0]} ${this.getSdkPkgFile().data?.platformVersion}(${this.getApiVersion()})`,
+			"os.apiVersion": this.getApiVersion().toString(),
+			"os.softwareVersion": this.getSdkPkgFile().data?.version ?? "",
+			"os.isPublic": options.isPublic ?? true ? "true" : "false",
+			"hw.cpu.arch": listFileItem.getContent().abi,
+			"hw.cpu.ncore": listFileItem.getContent().cpuNumber,
+			"hw.lcd.density": emulatorDeviceItem.getContent().density.toFixed(),
+			"hw.lcd.single.diagonalSize": EmulatorTripleFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().singleDiagonalSize.toString() : void 0,
+			"hw.lcd.single.height": EmulatorTripleFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().singleResolutionHeight.toString() : void 0,
+			"hw.lcd.single.width": EmulatorTripleFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().singleResolutionWidth.toString() : void 0,
+			"hw.lcd.double.diagonalSize": EmulatorTripleFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().doubleDiagonalSize.toString() : void 0,
+			"hw.lcd.double.height": EmulatorTripleFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().doubleResolutionHeight.toString() : void 0,
+			"hw.lcd.double.width": EmulatorTripleFoldItem.is(emulatorDeviceItem) ? emulatorDeviceItem.getContent().doubleResolutionWidth.toString() : void 0,
+			"hw.lcd.phy.height": emulatorDeviceItem.getContent().physicalHeight.toString(),
+			"hw.lcd.phy.width": emulatorDeviceItem.getContent().physicalWidth.toString(),
+			"hw.lcd.number": EmulatorTripleFoldItem.is(emulatorDeviceItem) || EmulatorFoldItem.is(emulatorDeviceItem) ? "2" : "1",
+			"hw.ramSize": listFileItem.getContent().memoryRamSize,
+			"hw.dataPartitionSize": listFileItem.getContent().dataDiskSize,
+			"isCustomize": "true",
+			"hw.hdc.port": "notset"
+		});
+		device.setConfigIniFile(deviceIniFile);
+		const namedIniFile = new NamedIniFileImpl(device, NamedIniFileImpl.getFileUri(device), {
+			"hvd.ini.encoding": "UTF-8",
+			"path": listFileItem.getContent().path
+		});
+		device.setNamedIniFile(namedIniFile);
+		await namedIniFile.write();
+		await deviceIniFile.write();
+		await listsFile.write();
+		return device;
 	}
 	toJSON() {
 		return {
-			...this.options,
-			list: this.buildList(),
-			ini: this.buildIni()
+			...super.toJSON(),
+			sdkPkgFile: this.getSdkPkgFile()
 		};
 	}
 };
-function createDevice(image, options) {
-	return new DeviceImpl(image, options);
-}
 
 //#endregion
-//#region src/image-downloader.ts
-var ImageDownloaderImpl = class {
-	emitter = mitt();
-	all = this.emitter.all;
-	on(type, handler) {
-		this.emitter.on(type, handler);
+//#region src/errors/request-error.ts
+var RemoteImageRequestError = class extends Error {
+	constructor(message, code, cause) {
+		super(message, { cause });
+		this.message = message;
+		this.code = code;
+		this.cause = cause;
 	}
-	off(type, handler) {
-		this.emitter.off(type, handler);
+};
+
+//#endregion
+//#region src/event-emitter.ts
+var EventEmitter = class {
+	_listeners = [];
+	/**
+	* The event listeners can subscribe to.
+	*/
+	event = (listener, thisArgs, disposables) => {
+		this._listeners.push([
+			listener,
+			thisArgs,
+			disposables
+		]);
+		return { dispose: () => {
+			this._listeners = this._listeners.filter((l) => l[0] !== listener && l[1] !== thisArgs && l[2] !== disposables);
+			disposables?.forEach((disposable) => disposable.dispose());
+		} };
+	};
+	/**
+	* Notify all subscribers of the {@link EventEmitter.event event}. Failure
+	* of one or more listener will not fail this function call.
+	*
+	* @param data The event object.
+	*/
+	fire(data) {
+		this._listeners.forEach((listener) => {
+			if (listener[1] !== void 0) listener[1].call(listener[2], data);
+			else listener[0](data);
+		});
 	}
-	emit(type, event) {
-		this.emitter.emit(type, event);
+	/**
+	* Dispose this object and free resources.
+	*/
+	dispose() {
+		this._listeners.forEach((listener) => listener[2]?.forEach((disposable) => disposable.dispose()));
+		this._listeners = [];
 	}
-	constructor(image, url) {
-		this.image = image;
+};
+
+//#endregion
+//#region src/image-downloader.ts
+var ImageDownloaderImpl = class {
+	constructor(remoteImage, url, abortController = new AbortController()) {
+		this.remoteImage = remoteImage;
 		this.url = url;
+		this.abortController = abortController;
 	}
-	getImage() {
-		return this.image;
+	downloadProgressEmitter = new EventEmitter();
+	extractProgressEmitter = new EventEmitter();
+	checksumProgressEmitter = new EventEmitter();
+	onDownloadProgress = this.downloadProgressEmitter.event;
+	onExtractProgress = this.extractProgressEmitter.event;
+	onChecksumProgress = this.checksumProgressEmitter.event;
+	getRemoteImage() {
+		return this.remoteImage;
 	}
 	getUrl() {
 		return this.url;
 	}
-	getCacheFsPath() {
-		const { path, cachePath } = this.image.getImageManager().getOptions();
-		return path.resolve(cachePath, path.basename(this.url));
+	getCacheUri() {
+		const { cachePath, adapter: { URI, join, basename } } = this.remoteImage.getImageManager().getOptions();
+		return join(cachePath, basename(URI.parse(this.url)));
 	}
-	async makeRequest(signal, startByte = 0, retried416 = false) {
-		const { fs } = this.image.getImageManager().getOptions();
-		const cacheFsPath = this.getCacheFsPath();
-		const transformProgress = this.createProgressTransformer(startByte);
+	async makeRequest(startByte = 0, retried416 = false) {
+		const { adapter: { fs, axios, isAxiosError } } = this.remoteImage.getImageManager().getOptions();
+		const cacheUri = this.getCacheUri();
 		try {
 			return await axios.get(this.url, {
 				headers: startByte > 0 ? { Range: `bytes=${startByte}-` } : {},
 				responseType: "stream",
 				validateStatus: (status) => status === 200 || status === 206,
-				onDownloadProgress: (progress) => this.emit("download-progress", transformProgress(progress)),
-				signal
+				signal: this.abortController.signal
 			});
 		} catch (err) {
-			if (err instanceof AxiosError && err.response?.status === 416 && !retried416) {
-				if (fs.existsSync(cacheFsPath)) fs.rmSync(cacheFsPath, { force: true });
-				return this.makeRequest(signal, startByte, true);
+			if (isAxiosError(err) && err.response?.status === 416 && !retried416) {
+				if (await fs.exists(cacheUri)) await fs.delete(cacheUri, { recursive: true });
+				return this.makeRequest(startByte, true);
 			}
 			throw err;
 		}
 	}
-	async startDownload(signal, retried416 = false) {
-		const { fs, cachePath } = this.image.getImageManager().getOptions();
-		const cacheFsPath = this.getCacheFsPath();
-		if (!fs.existsSync(cachePath)) fs.mkdirSync(cachePath, { recursive: true });
-		const startByte = fs.existsSync(cacheFsPath) ? fs.statSync(cacheFsPath).size : 0;
-		const response = await this.makeRequest(signal, startByte, retried416);
-		const isPartialContent = response.status === 206;
-		const start = startByte > 0 && isPartialContent ? startByte : 0;
-		const flags = start > 0 ? "a" : "w";
-		if (startByte > 0 && !isPartialContent) fs.rmSync(cacheFsPath, { force: true });
-		const writeStream = fs.createWriteStream(cacheFsPath, {
-			flags,
-			start
-		});
-		response.data.pipe(writeStream);
-		await new Promise((resolve, reject) => {
-			let settled = false;
-			const onError = (err) => {
-				if (settled) return;
-				settled = true;
-				response.data.destroy();
-				writeStream.destroy();
-				reject(err);
-			};
-			const onFinish = () => {
-				if (settled) return;
-				settled = true;
-				resolve();
-			};
-			response.data.on("error", onError);
-			writeStream.on("error", onError);
-			response.data.on("end", () => writeStream.end());
-			writeStream.on("finish", onFinish);
+	/** 获取文件总大小。206 时从 Content-Range 取 total，200 时从 Content-Length 取。 */
+	parseTotalBytes(response) {
+		const contentRange = response.headers["content-range"];
+		if (contentRange) {
+			const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+			if (match) return Number.parseInt(match[1], 10);
+		}
+		const contentLength = response.headers["content-length"];
+		if (contentLength) return Number.parseInt(contentLength, 10);
+		return null;
+	}
+	createDownloadProgressTransformer(startByte, totalBytes) {
+		let receivedBytes = startByte;
+		let lastReportedBytes = startByte;
+		let lastReportedProgress = totalBytes != null && totalBytes > 0 ? Math.round(startByte / totalBytes * 1e4) / 100 : 0;
+		let lastReportTime = performance.now();
+		const reportThreshold = 64 * 1024;
+		const report = () => {
+			const now = performance.now();
+			const bytesSinceLastReport = receivedBytes - lastReportedBytes;
+			const timeDeltaSec = (now - lastReportTime) / 1e3;
+			lastReportedBytes = receivedBytes;
+			lastReportTime = now;
+			const progress = totalBytes != null && totalBytes > 0 ? Math.min(100, Math.round(receivedBytes / totalBytes * 1e4) / 100) : 0;
+			const increment = Math.round((progress - lastReportedProgress) * 100) / 100;
+			lastReportedProgress = progress;
+			const speedKBps = timeDeltaSec > 0 && bytesSinceLastReport > 0 ? bytesSinceLastReport / 1024 / timeDeltaSec : 0;
+			const unit = speedKBps >= 1024 ? "MB" : "KB";
+			const network = unit === "MB" ? speedKBps / 1024 : speedKBps;
+			const roundedProgress = Math.round(progress * 100) / 100;
+			const clampedIncrement = Math.max(0, Math.min(100, increment));
+			if (clampedIncrement > 0) this.downloadProgressEmitter.fire({
+				progressType: "download",
+				increment: clampedIncrement,
+				progress: roundedProgress,
+				network: Math.round(network * 100) / 100,
+				unit
+			});
+		};
+		return new TransformStream({
+			transform: (chunk, controller) => {
+				receivedBytes += chunk.length;
+				controller.enqueue(chunk);
+				if (receivedBytes - lastReportedBytes >= reportThreshold) report();
+			},
+			flush: () => {
+				if (receivedBytes !== lastReportedBytes) report();
+			}
 		});
 	}
-	async checkChecksum(signal) {
-		const { crypto, fs } = this.image.getImageManager().getOptions();
-		const checksum = this.image.getChecksum();
-		const hash = crypto.createHash("sha256", { signal });
-		const stream = fs.createReadStream(this.getCacheFsPath(), { signal });
-		stream.on("data", (chunk) => hash.update(chunk));
-		await new Promise((resolve, reject) => stream.on("end", resolve).on("error", reject));
-		return hash.digest("hex") === checksum;
-	}
-	async extract(signal, symlinkOpenHarmonySdk = true) {
-		const unzipper = await import("unzipper");
-		const { fs, path, imageBasePath, sdkPath } = this.image.getImageManager().getOptions();
-		const cacheFsPath = this.getCacheFsPath();
-		const stream = fs.createReadStream(cacheFsPath, { signal });
-		const progressStream = progress({ length: fs.statSync(cacheFsPath).size });
-		const extractStream = unzipper.Extract({ path: this.image.getFsPath() });
-		progressStream.on("progress", (progress) => this.emitter.emit("extract-progress", progress));
-		stream.pipe(progressStream).pipe(extractStream);
-		await extractStream.promise();
-		if (symlinkOpenHarmonySdk) {
-			const symlinkSdkPath = path.resolve(imageBasePath, "default", "openharmony");
-			if (!fs.existsSync(path.dirname(symlinkSdkPath))) fs.mkdirSync(path.dirname(symlinkSdkPath), { recursive: true });
-			if (!fs.existsSync(symlinkSdkPath)) fs.symlinkSync(sdkPath, symlinkSdkPath, "dir");
+	async startDownload(retried416 = false) {
+		const { adapter: { fs, toWeb, dirname } } = this.remoteImage.getImageManager().getOptions();
+		const cacheUri = this.getCacheUri();
+		if (!await fs.exists(dirname(cacheUri))) await fs.createDirectory(dirname(cacheUri));
+		const startByte = await fs.stat(cacheUri).then((stat) => stat.size ?? 0, () => 0);
+		const response = await this.makeRequest(startByte, retried416);
+		const totalBytes = this.parseTotalBytes(response);
+		if (startByte > 0 && totalBytes != null && totalBytes > 0) {
+			const startProgress = Math.round(startByte / totalBytes * 1e4) / 100;
+			this.downloadProgressEmitter.fire({
+				progressType: "download",
+				increment: 0,
+				progress: Math.min(100, startProgress),
+				network: 0,
+				unit: "KB",
+				reset: true
+			});
 		}
-	}
-	async clean() {
-		const { fs } = this.image.getImageManager().getOptions();
-		const cacheFsPath = this.getCacheFsPath();
-		if (fs.existsSync(cacheFsPath)) fs.rmSync(cacheFsPath, { recursive: true });
-	}
-	createProgressTransformer(startByte) {
-		let previousPercentage = 0;
-		const bytesPerKB = 1024;
-		const bytesPerMB = bytesPerKB * 1024;
-		return (progress) => {
-			const rangeTotal = progress.total ?? 0;
-			const rangeLoaded = progress.loaded ?? 0;
-			const total = startByte + rangeTotal;
-			const loaded = startByte + rangeLoaded;
-			const percentage = total > 0 ? loaded / total * 100 : 0;
-			const increment = Math.max(0, percentage - previousPercentage);
-			previousPercentage = percentage;
-			const rate = progress.rate ?? 0;
-			const unit = rate >= bytesPerMB ? "MB" : "KB";
-			const network = unit === "MB" ? rate / bytesPerMB : rate / bytesPerKB;
-			return {
-				...progress,
-				total,
-				loaded,
-				network,
-				unit,
-				increment
-			};
+		const writableStream = await fs.createWritableStream(cacheUri, startByte > 0 ? { flags: WriteableFlags.Append } : void 0);
+		const webReadable = toWeb(response.data);
+		const progressTransform = this.createDownloadProgressTransformer(startByte, totalBytes);
+		await webReadable.pipeThrough(progressTransform).pipeTo(writableStream);
+	}
+	createChecksumProgressTransformer(totalBytes, hash) {
+		let readBytes = 0;
+		let lastReportedBytes = 0;
+		let lastReportedProgress = 0;
+		const reportThreshold = 64 * 1024;
+		const report = () => {
+			const progress = totalBytes > 0 ? Math.min(100, Math.round(readBytes / totalBytes * 1e4) / 100) : 0;
+			const increment = Math.round((progress - lastReportedProgress) * 100) / 100;
+			lastReportedBytes = readBytes;
+			lastReportedProgress = progress;
+			const clampedIncrement = Math.max(0, Math.min(100, increment));
+			if (clampedIncrement > 0) this.checksumProgressEmitter.fire({
+				progressType: "checksum",
+				increment: clampedIncrement,
+				progress: Math.round(progress * 100) / 100
+			});
 		};
+		return new TransformStream({
+			transform: (chunk, controller) => {
+				const chunkLength = chunk ? chunk.byteLength ?? chunk.length ?? 0 : 0;
+				if (chunk) hash.update(chunk);
+				readBytes += chunkLength;
+				controller.enqueue(chunk);
+				if (readBytes - lastReportedBytes >= reportThreshold) report();
+			},
+			flush: () => {
+				if (readBytes !== lastReportedBytes) report();
+			}
+		});
+	}
+	async checkChecksum() {
+		const { adapter: { fs, crypto } } = this.remoteImage.getImageManager().getOptions();
+		const cacheUri = this.getCacheUri();
+		const totalBytes = await fs.stat(cacheUri).then((stat) => stat.size ?? 0, () => 0);
+		const readableStream = await fs.createReadableStream(cacheUri);
+		const hash = crypto.createHash("sha256");
+		const progressTransform = this.createChecksumProgressTransformer(totalBytes, hash);
+		await readableStream.pipeThrough(progressTransform).pipeTo(new WritableStream(), { signal: this.abortController.signal });
+		return hash.digest("hex") === this.getRemoteImage().getRemoteImageSDK().archive?.complete?.checksum;
+	}
+	async extract() {
+		const { adapter: { fs, unzipper, fromWeb } } = this.remoteImage.getImageManager().getOptions();
+		const cacheUri = this.getCacheUri();
+		const totalBytes = await fs.stat(cacheUri).then((stat) => stat.size ?? 0, () => 0);
+		const extract = unzipper.Extract({ path: this.getRemoteImage().getFullPath().fsPath });
+		const webReadable = await fs.createReadableStream(cacheUri);
+		let readBytes = 0;
+		let lastReportedBytes = 0;
+		let lastReportedProgress = 0;
+		const reportThreshold = 64 * 1024;
+		const copyAndProgressTransform = new TransformStream({
+			transform: (chunk, controller) => {
+				const chunkLength = chunk?.length ?? 0;
+				if (chunkLength <= 0) return;
+				readBytes += chunkLength;
+				if (readBytes - lastReportedBytes >= reportThreshold) {
+					const progress = totalBytes > 0 ? Math.min(100, Math.round(readBytes / totalBytes * 1e4) / 100) : 0;
+					const increment = Math.round((progress - lastReportedProgress) * 100) / 100;
+					lastReportedBytes = readBytes;
+					lastReportedProgress = progress;
+					const clampedIncrement = Math.max(0, Math.min(100, increment));
+					if (clampedIncrement > 0) this.extractProgressEmitter.fire({
+						progressType: "extract",
+						increment: clampedIncrement,
+						progress: Math.round(progress * 100) / 100
+					});
+				}
+				controller.enqueue(chunk.slice(0));
+			},
+			flush: () => {
+				if (readBytes !== lastReportedBytes) {
+					const increment = Math.round((100 - lastReportedProgress) * 100) / 100;
+					const clampedIncrement = Math.max(0, Math.min(100, increment));
+					if (clampedIncrement > 0) this.extractProgressEmitter.fire({
+						progressType: "extract",
+						increment: clampedIncrement,
+						progress: 100
+					});
+				}
+			}
+		});
+		const readable = fromWeb(webReadable.pipeThrough(copyAndProgressTransform));
+		const abortHandler = () => readable.destroy(new DOMException("Aborted", "AbortError"));
+		this.abortController.signal.addEventListener("abort", abortHandler);
+		readable.pipe(extract);
+		await extract.promise().finally(() => this.abortController.signal.removeEventListener("abort", abortHandler));
 	}
 };
-function createImageDownloader(image, url) {
-	return new ImageDownloaderImpl(image, url);
-}
 
 //#endregion
-//#region src/images/image.ts
-var ImageBase = class {
-	constructor(response, imageManager, resolvedFsPath) {
-		this.response = response;
-		this.imageManager = imageManager;
-		this.resolvedFsPath = resolvedFsPath;
-	}
-	getImageManager() {
-		return this.imageManager;
-	}
-	getArch() {
-		const [, , deviceTypeWithArch] = this.getPath()?.split(",") ?? [];
-		const split = deviceTypeWithArch?.split("_") ?? [];
-		return split[split.length - 1];
-	}
-	getPath() {
-		return this.response?.path;
-	}
-	getChecksum() {
-		return this.response?.archive?.complete?.checksum;
-	}
-	getReleaseType() {
-		return this.response?.releaseType;
-	}
-	getFsPath() {
-		return this.resolvedFsPath;
-	}
-	async isDownloaded() {
-		return this.imageManager.getOptions().fs.existsSync(this.getFsPath()) && this.imageManager.getOptions().fs.statSync(this.getFsPath()).isDirectory();
-	}
-	getVersion() {
-		return this.response?.version;
-	}
-	getApiVersion() {
-		return this.response?.apiVersion;
-	}
-	getTargetOS() {
-		const [, systemNameWithVersion] = this.getPath()?.split(",") ?? [];
-		const [systemName] = systemNameWithVersion?.split("-") ?? [];
-		return systemName ?? "";
+//#region src/images/remote-image.ts
+let RemoteImage;
+(function(_RemoteImage) {
+	function is(value) {
+		return value instanceof RemoteImageImpl;
 	}
-	getTargetVersion() {
-		const [, systemNameWithVersion] = this.getPath()?.split(",") ?? [];
-		const [, version] = systemNameWithVersion?.split("-") ?? [];
-		return version ?? "";
+	_RemoteImage.is = is;
+})(RemoteImage || (RemoteImage = {}));
+var RemoteImageImpl = class extends BaseImageImpl {
+	imageType = "remote";
+	constructor(imageManager, remoteImageSDK = {}) {
+		super({
+			imageManager,
+			relativePath: remoteImageSDK.path?.split(",").join("/") ?? "",
+			apiVersion: remoteImageSDK.apiVersion ? Number.parseInt(remoteImageSDK.apiVersion) : 0
+		});
+		this.imageManager = imageManager;
+		this.remoteImageSDK = remoteImageSDK;
 	}
-	getDeviceType() {
-		const [, , deviceTypeWithArch] = this.getPath()?.split(",") ?? [];
-		const [deviceType] = deviceTypeWithArch?.split("_") ?? [];
-		return deviceType ?? "";
+	getRemoteImageSDK() {
+		return this.remoteImageSDK;
 	}
-	getSnakecaseDeviceType() {
-		const deviceType = this.getDeviceType();
-		if (deviceType === "pc") return "2in1_foldable";
-		return deviceType.toLowerCase();
+	getFullDeviceType() {
+		const name = this.getRemoteImageSDK().displayName?.split("-");
+		return name?.[name.length - 1];
 	}
-	async createDownloader() {
-		const url = await this.getUrl();
-		if (url instanceof RequestUrlError) return url;
-		return createImageDownloader(this, url);
+	_localImage;
+	async getLocalImage(force = false) {
+		if (!force && this._localImage) return this._localImage;
+		this._localImage = (await this.getImageManager().getLocalImages()).find((localImage) => localImage.getFullPath().toString() === this.getFullPath().toString());
+		return this._localImage;
 	}
-	async getUrl() {
+	async createDownloader(signals) {
+		const { adapter: { axios, isAxiosError } } = this.imageManager.getOptions();
 		try {
 			const response = await axios.post("https://devecostudio-drcn.deveco.dbankcloud.com/sdkmanager/v7/hos/download", {
-				osArch: this.imageManager.getArch(),
-				osType: this.imageManager.getOS(),
+				osArch: this.getImageManager().getArch(),
+				osType: this.getImageManager().getOperatingSystem(),
 				path: {
-					path: this.getPath(),
-					version: this.getVersion()
+					path: this.getRemoteImageSDK().path,
+					version: this.getRemoteImageSDK().version
 				},
 				imei: "d490a470-8719-4baf-9cc4-9c78d40d"
 			});
-			if (typeof response.data?.url !== "string") return new RequestUrlError(response.data?.body, response.data?.code);
-			return response.data.url;
+			if (typeof response.data?.url !== "string") throw new RemoteImageRequestError(response.data?.body, response.data?.code);
+			return new ImageDownloaderImpl(this, response.data.url, signals);
 		} catch (error) {
-			return new RequestUrlError(error.message, error.code, error);
+			if (isAxiosError(error)) throw new RemoteImageRequestError(error.message, Number(error.code), error);
+			if (error instanceof Error) throw new RemoteImageRequestError(error.message, -1, error);
+			throw new RemoteImageRequestError("Unknown request error.", -1, error);
 		}
 	}
 	toJSON() {
 		return {
-			imageType: this.imageType,
-			arch: this.getArch(),
-			path: this.getPath(),
-			checksum: this.getChecksum(),
-			fsPath: this.getFsPath(),
-			version: this.getVersion(),
-			apiVersion: this.getApiVersion(),
-			targetOS: this.getTargetOS(),
-			targetVersion: this.getTargetVersion(),
-			deviceType: this.getDeviceType(),
-			snakecaseDeviceType: this.getSnakecaseDeviceType()
+			...super.toJSON(),
+			remoteImageSDK: this.getRemoteImageSDK()
 		};
 	}
 };
 
 //#endregion
-//#region src/images/local-image.ts
-var LocalImageImpl = class extends ImageBase {
-	imageType = "local";
-	createDevice(options) {
-		return createDevice(this, options);
-	}
-	async getPascalCaseDeviceType() {
-		const deviceType = this.getDeviceType().toLowerCase();
-		if (!deviceType) return;
-		if (deviceType === "pc") return "2in1 Foldable";
-		const key = [
-			"phone",
-			"tablet",
-			"2in1",
-			"foldable",
-			"widefold",
-			"triplefold",
-			"2in1 foldable",
-			"tv",
-			"wearable"
-		].find((key) => key === deviceType);
-		if (key) return key;
-	}
-	async getProductConfig(usingDefaultProductConfig = false) {
-		const productConfig = usingDefaultProductConfig ? (await import("./default-product-config.mjs")).default : await this.getImageManager().getProductConfig();
-		const deviceType = this.getDeviceType().toLowerCase();
-		if (!deviceType) return [];
-		if (deviceType === "pc") return productConfig["2in1 Foldable"] ?? [];
-		const key = Object.keys(productConfig).find((key) => key.toLowerCase() === deviceType);
-		if (key) return productConfig[key] ?? [];
-		return [];
-	}
-	async delete() {
-		const { fs } = this.getImageManager().getOptions();
-		const path = this.getFsPath();
-		if (!fs.existsSync(path) || !fs.statSync(path).isDirectory()) return /* @__PURE__ */ new Error("Image path does not exist");
-		fs.rmSync(path, { recursive: true });
-		const devices = await this.getDevices();
-		const error = await Promise.allSettled(devices.map((device) => device.delete())).then((results) => results.find((result) => result.status === "rejected"));
-		if (error) return error.reason;
-	}
-	getExecutablePath() {
-		const { emulatorPath, process, path } = this.getImageManager().getOptions();
-		return process.platform === "win32" ? path.join(emulatorPath, "Emulator.exe") : path.join(emulatorPath, "Emulator");
-	}
-	async buildStartCommand(device) {
-		const config = device.buildList();
-		return `${this.getExecutablePath()} ${[
-			"-hvd",
-			`"${config.name.replace(/"/g, "\\\"")}"`,
-			"-path",
-			`"${this.getImageManager().getOptions().deployedPath.replace(/"/g, "\\\"")}"`,
-			"-imageRoot",
-			`"${this.getImageManager().getOptions().imageBasePath.replace(/"/g, "\\\"")}"`
-		].join(" ")}`;
-	}
-	async start(deployer) {
-		const { child_process, emulatorPath } = this.getImageManager().getOptions();
-		return child_process.exec(await this.buildStartCommand(deployer), { cwd: emulatorPath });
-	}
-	async buildStopCommand(device) {
-		const config = device.buildList();
-		return `${this.getExecutablePath()} ${["-stop", `"${config.name.replace(/"/g, "\\\"")}"`].join(" ")}`;
-	}
-	async stop(device) {
-		const { child_process, emulatorPath } = this.getImageManager().getOptions();
-		return child_process.exec(await this.buildStopCommand(device), { cwd: emulatorPath });
-	}
-	async createScreenLike(listsJsonItem) {
-		const productConfig = await this.getImageManager().getProductConfig();
-		const pascalCaseDeviceType = await this.getPascalCaseDeviceType();
-		const screen = createScreen({
-			diagonal: Number(listsJsonItem.diagonalSize),
-			height: Number(listsJsonItem.resolutionHeight),
-			width: Number(listsJsonItem.resolutionWidth),
-			density: Number(listsJsonItem.density),
-			deviceType: listsJsonItem.type,
-			apiVersion: Number(listsJsonItem.apiVersion),
-			cover: listsJsonItem.coverResolutionWidth && listsJsonItem.coverResolutionHeight && listsJsonItem.coverDiagonalSize ? {
-				height: Number(listsJsonItem.coverResolutionHeight),
-				width: Number(listsJsonItem.coverResolutionWidth),
-				diagonal: Number(listsJsonItem.coverDiagonalSize)
-			} : void 0
-		});
-		if (pascalCaseDeviceType) {
-			const productConfigItem = productConfig[pascalCaseDeviceType]?.find((item) => item.name === listsJsonItem.model);
-			if (productConfigItem && productConfigItem.outerScreenWidth && productConfigItem.outerScreenHeight && productConfigItem.outerScreenDiagonal) screen.setOuterScreen(createOuterScreen({
-				width: Number(productConfigItem.outerScreenWidth),
-				height: Number(productConfigItem.outerScreenHeight),
-				diagonal: Number(productConfigItem.outerScreenDiagonal)
-			}, screen));
-			if (productConfigItem && productConfigItem.outerDoubleScreenWidth && productConfigItem.outerDoubleScreenHeight && productConfigItem.outerDoubleScreenDiagonal) screen.getOuterScreen()?.setOuterDoubleScreen(createOuterDoubleScreen({
-				width: Number(productConfigItem.outerDoubleScreenWidth),
-				height: Number(productConfigItem.outerDoubleScreenHeight),
-				diagonal: Number(productConfigItem.outerDoubleScreenDiagonal)
-			}, screen.getOuterScreen()));
+//#region src/options.ts
+let OptionsResolver;
+(function(_OptionsResolver) {
+	async function resolveAdapter(adapter) {
+		const mergedAdapter = {
+			os: adapter?.os ?? await import("node:os"),
+			process: adapter?.process ?? await import("node:process"),
+			crypto: adapter?.crypto ?? await import("node:crypto"),
+			child_process: adapter?.child_process ?? await import("node:child_process"),
+			axios: adapter?.axios ?? (await import("axios")).default,
+			fs: adapter?.fs ?? await createNodeFileSystem(),
+			join: adapter?.join ?? (await import("vscode-uri")).Utils.joinPath,
+			URI: adapter?.URI ?? (await import("vscode-uri")).URI,
+			dirname: adapter?.dirname ?? (await import("vscode-uri")).Utils.dirname,
+			basename: adapter?.basename ?? (await import("vscode-uri")).Utils.basename,
+			toWeb: adapter?.toWeb ?? (await import("node:stream")).Readable.toWeb,
+			fromWeb: adapter?.fromWeb ?? (await import("node:stream")).Readable.fromWeb,
+			unzipper: adapter?.unzipper ?? await import("unzipper")
+		};
+		if (adapter?.isAxiosError) mergedAdapter.isAxiosError = adapter.isAxiosError;
+		else {
+			const axios = await import("axios");
+			mergedAdapter.isAxiosError = (error) => axios.isAxiosError(error);
 		}
-		const screenPreset = new ScreenPresetImpl({
-			screen,
-			productConfig,
-			emulatorConfig: await this.getImageManager().getEmulatorConfig()
-		});
-		if (screenPreset.getProductPreset() || screenPreset.getEmulatorPreset()) return screenPreset;
-		else return screen;
-	}
-	async getDevices() {
-		const { path, fs, deployedPath, imageBasePath } = this.getImageManager().getOptions();
-		const listsJsonPath = path.resolve(deployedPath, "lists.json");
-		if (!fs.existsSync(listsJsonPath) || !fs.statSync(listsJsonPath).isFile()) return [];
-		const listsJson = JSON.parse(fs.readFileSync(listsJsonPath, "utf-8"));
-		if (!Array.isArray(listsJson) || this.imageType !== "local") return [];
-		const devices = [];
-		for (const listsJsonItem of listsJson) {
-			if (path.resolve(imageBasePath, listsJsonItem.imageDir) !== this.getFsPath()) continue;
-			const iniFilePath = path.resolve(listsJsonItem.path, "config.ini");
-			if (!fs.existsSync(iniFilePath) || !fs.statSync(iniFilePath).isFile()) continue;
-			const device = this.createDevice({
-				name: listsJsonItem.name,
-				cpuNumber: Number(listsJsonItem.cpuNumber),
-				diskSize: Number(listsJsonItem.dataDiskSize),
-				memorySize: Number(listsJsonItem.memoryRamSize),
-				screen: await this.createScreenLike(listsJsonItem)
-			});
-			device.setUuid(listsJsonItem.uuid).setCachedList(listsJsonItem).setCachedIni(INI.parse(fs.readFileSync(iniFilePath, "utf-8")));
-			if (!fs.existsSync(listsJsonItem.path) || !fs.statSync(listsJsonItem.path).isDirectory()) continue;
-			devices.push(device);
+		return mergedAdapter;
+	}
+	_OptionsResolver.resolveAdapter = resolveAdapter;
+	async function resolveImageManagerOptions(options) {
+		const adapter = await resolveAdapter(options.adapter);
+		const { os, join, process, URI } = adapter;
+		function resolveDefaultImageBasePath() {
+			switch (process.platform) {
+				case "win32": return typeof process.env.APPDATA === "string" && process.env.APPDATA.length > 0 ? join(URI.file(process.env.APPDATA), "Local", "Huawei", "Sdk") : join(URI.file(os.homedir()), "AppData", "Local", "Huawei", "Sdk");
+				case "darwin": return join(URI.file(os.homedir()), "Library", "Huawei", "Sdk");
+				default: return join(URI.file(os.homedir()), ".huawei", "Sdk");
+			}
 		}
-		return devices;
-	}
-	toJSON() {
+		function resolveDefaultDeployedPath() {
+			switch (process.platform) {
+				case "win32": return typeof process.env.APPDATA === "string" && process.env.APPDATA.length > 0 ? join(URI.file(process.env.APPDATA), "Local", "Huawei", "Emulator", "deployed") : join(URI.file(os.homedir()), "AppData", "Local", "Huawei", "Emulator", "deployed");
+				default: return join(URI.file(os.homedir()), ".huawei", "Emulator", "deployed");
+			}
+		}
+		function resolveDefaultSdkPath() {
+			switch (process.platform) {
+				case "darwin": return URI.file("/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony");
+				case "win32": return URI.file("C:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\openharmony");
+				default: return join(URI.file(os.homedir()), ".huawei", "Sdk", "default", "openharmony");
+			}
+		}
+		function resolveDefaultConfigPath() {
+			switch (process.platform) {
+				case "darwin": return join(URI.file(os.homedir()), "Library", "Application Support", "Huawei", "DevEcoStudio6.0");
+				case "win32": return join(URI.file(process.env.APPDATA ?? os.homedir()), "Roaming", "Huawei", "DevEcoStudio6.0");
+				default: return join(URI.file(os.homedir()), ".huawei", "DevEcoStudio6.0");
+			}
+		}
+		function resolveDefaultLogPath() {
+			switch (process.platform) {
+				case "darwin": return join(URI.file(os.homedir()), "Library", "Logs", "Huawei", "DevEcoStudio6.0");
+				case "win32": return join(URI.file(process.env.APPDATA ?? os.homedir()), "Local", "Huawei", "DevEcoStudio6.0", "log");
+				default: return join(URI.file(os.homedir()), ".huawei", "DevEcoStudio6.0", "log");
+			}
+		}
+		function resolveDefaultEmulatorPath() {
+			switch (process.platform) {
+				case "darwin": return URI.file("/Applications/DevEco-Studio.app/Contents/tools/emulator");
+				case "win32": return URI.file("C:\\Program Files\\Huawei\\DevEco Studio\\tools\\emulator");
+				default: return join(URI.file(os.homedir()), ".huawei", "Emulator");
+			}
+		}
+		const imageBasePath = typeof options.imageBasePath === "string" ? URI.file(options.imageBasePath) : options.imageBasePath || resolveDefaultImageBasePath();
+		const cachePath = typeof options.cachePath === "string" ? URI.file(options.cachePath) : options.cachePath || join(imageBasePath, "cache");
 		return {
-			...super.toJSON(),
-			executablePath: this.getExecutablePath()
+			imageBasePath,
+			deployedPath: typeof options.deployedPath === "string" ? URI.file(options.deployedPath) : options.deployedPath || resolveDefaultDeployedPath(),
+			cachePath,
+			sdkPath: typeof options.sdkPath === "string" ? URI.file(options.sdkPath) : options.sdkPath || resolveDefaultSdkPath(),
+			configPath: typeof options.configPath === "string" ? URI.file(options.configPath) : options.configPath || resolveDefaultConfigPath(),
+			logPath: typeof options.logPath === "string" ? URI.file(options.logPath) : options.logPath || resolveDefaultLogPath(),
+			emulatorPath: typeof options.emulatorPath === "string" ? URI.file(options.emulatorPath) : options.emulatorPath || resolveDefaultEmulatorPath(),
+			adapter
 		};
 	}
-};
+	_OptionsResolver.resolveImageManagerOptions = resolveImageManagerOptions;
+})(OptionsResolver || (OptionsResolver = {}));
 
 //#endregion
-//#region src/images/remote-image.ts
-var RemoteImageImpl = class extends ImageBase {
-	imageType = "remote";
-	toJSON() {
-		return super.toJSON();
+//#region src/sdk-list.ts
+let SDKList;
+(function(_SDKList) {
+	function isOKResponse(result) {
+		return "data" in result && Array.isArray(result.data);
+	}
+	_SDKList.isOKResponse = isOKResponse;
+	class SDKListError extends Error {
+		constructor(code, message, cause) {
+			super(message);
+			this.code = code;
+			this.message = message;
+			this.cause = cause;
+		}
 	}
-};
+	_SDKList.SDKListError = SDKListError;
+	(function(_SDKListError) {
+		_SDKListError.Code = /* @__PURE__ */ function(Code) {
+			Code[Code["VALIDATION_ERROR"] = 400] = "VALIDATION_ERROR";
+			Code[Code["REQUEST_ERROR"] = 500] = "REQUEST_ERROR";
+			return Code;
+		}({});
+	})(SDKListError || (SDKListError = _SDKList.SDKListError || (_SDKList.SDKListError = {})));
+})(SDKList || (SDKList = {}));
 
 //#endregion
-//#region src/options.ts
-async function resolveImageManagerOptions(options) {
-	const os = options.os ?? await import("node:os");
-	const path = options.path ?? await import("node:path");
-	const process = options.process ?? await import("node:process");
-	function resolveDefaultImageBasePath() {
-		switch (process.platform) {
-			case "win32": return typeof process.env.APPDATA === "string" && process.env.APPDATA.length > 0 ? path.resolve(process.env.APPDATA, "Local", "Huawei", "Sdk") : path.resolve(os.homedir(), "AppData", "Local", "Huawei", "Sdk");
-			case "darwin": return path.resolve(os.homedir(), "Library", "Huawei", "Sdk");
-			default: return path.resolve(os.homedir(), ".huawei", "Sdk");
-		}
-	}
-	function resolveDefaultDeployedPath() {
-		switch (process.platform) {
-			case "win32": return typeof process.env.APPDATA === "string" && process.env.APPDATA.length > 0 ? path.resolve(process.env.APPDATA, "Local", "Huawei", "Emulator", "deployed") : path.resolve(os.homedir(), "AppData", "Local", "Huawei", "Emulator", "deployed");
-			default: return path.resolve(os.homedir(), ".huawei", "Emulator", "deployed");
-		}
-	}
-	function resolveDefaultSdkPath() {
-		switch (process.platform) {
-			case "darwin": return "/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony";
-			case "win32": return "C:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\openharmony";
-			default: return path.resolve(os.homedir(), ".huawei", "Sdk", "default", "openharmony");
-		}
-	}
-	function resolveDefaultConfigPath() {
-		switch (process.platform) {
-			case "darwin": return path.resolve(os.homedir(), "Library", "Application Support", "Huawei", "DevEcoStudio6.0");
-			case "win32": return path.resolve(process.env.APPDATA ?? os.homedir(), "Roaming", "Huawei", "DevEcoStudio6.0");
-			default: return path.resolve(os.homedir(), ".huawei", "DevEcoStudio6.0");
+//#region src/utils/devicetype-converter.ts
+let DeviceTypeConverter;
+(function(_DeviceTypeConverter) {
+	function snakecaseToCamelcase(snakecaseDeviceType) {
+		switch (snakecaseDeviceType) {
+			case "phone": return "Phone";
+			case "2in1": return "2in1";
+			case "2in1_foldable": return "2in1 Foldable";
+			case "foldable": return "Foldable";
+			case "tablet": return "Tablet";
+			case "triplefold": return "TripleFold";
+			case "tv": return "TV";
+			case "wearable": return "Wearable";
+			case "widefold": return "WideFold";
+			default: return snakecaseDeviceType.toLowerCase().split("_").join(" ");
 		}
 	}
-	function resolveDefaultLogPath() {
-		switch (process.platform) {
-			case "darwin": return path.resolve(os.homedir(), "Library", "Logs", "Huawei", "DevEcoStudio6.0");
-			case "win32": return path.resolve(process.env.APPDATA ?? os.homedir(), "Local", "Huawei", "DevEcoStudio6.0", "log");
-			default: return path.resolve(os.homedir(), ".huawei", "DevEcoStudio6.0", "log");
-		}
-	}
-	function resolveDefaultEmulatorPath() {
-		switch (process.platform) {
-			case "darwin": return "/Applications/DevEco-Studio.app/Contents/tools/emulator";
-			case "win32": return "C:\\Program Files\\Huawei\\DevEco Studio\\tools\\emulator";
-			default: return path.resolve(os.homedir(), ".huawei", "Emulator");
-		}
-	}
-	const imageBasePath = options.imageBasePath || resolveDefaultImageBasePath();
-	const cachePath = options.cachePath || path.resolve(imageBasePath, "cache");
-	return {
-		imageBasePath,
-		deployedPath: options.deployedPath || resolveDefaultDeployedPath(),
-		cachePath,
-		sdkPath: options.sdkPath || resolveDefaultSdkPath(),
-		configPath: options.configPath || resolveDefaultConfigPath(),
-		logPath: options.logPath || resolveDefaultLogPath(),
-		emulatorPath: options.emulatorPath || resolveDefaultEmulatorPath(),
-		path,
-		os,
-		fs: options.fs ?? await import("node:fs"),
-		process: options.process ?? await import("node:process"),
-		crypto: options.crypto ?? await import("node:crypto"),
-		child_process: options.child_process ?? await import("node:child_process")
-	};
-}
+	_DeviceTypeConverter.snakecaseToCamelcase = snakecaseToCamelcase;
+})(DeviceTypeConverter || (DeviceTypeConverter = {}));
 
 //#endregion
 //#region src/image-manager.ts
 var ImageManagerImpl = class {
-	constructor(resolvedOptions) {
-		this.resolvedOptions = resolvedOptions;
+	constructor(options) {
+		this.options = options;
 	}
 	getOptions() {
-		return this.resolvedOptions;
+		return this.options;
 	}
-	getOS() {
-		switch (this.resolvedOptions.process.platform) {
+	getOperatingSystem() {
+		switch (this.options.adapter.process.platform) {
 			case "win32": return "windows";
 			case "darwin": return "mac";
 			default: return "linux";
 		}
 	}
 	getArch() {
-		if (this.resolvedOptions.process.arch.toLowerCase().includes("arm")) return "arm64";
+		if (this.options.adapter.process.arch.toLowerCase().includes("arm")) return "arm64";
 		return "x86";
 	}
-	async getImages(supportVersion = "6.0-hos-single-9") {
-		const response = await axios.post("https://devecostudio-drcn.deveco.dbankcloud.com/sdkmanager/v8/hos/getSdkList", {
-			osArch: this.getArch(),
-			osType: this.getOS(),
-			supportVersion
-		});
-		if (!Array.isArray(response.data)) return [];
-		const images = [];
-		for (const responseItem of response.data) {
-			const resolvedFsPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, ...responseItem.path.split(","));
-			if (this.resolvedOptions.fs.existsSync(resolvedFsPath) && this.resolvedOptions.fs.statSync(resolvedFsPath).isDirectory()) images.push(new LocalImageImpl(responseItem, this, resolvedFsPath));
-			else images.push(new RemoteImageImpl(responseItem, this, resolvedFsPath));
+	async requestSdkList(supportVersion = "6.0-hos-single-9") {
+		const { adapter: { axios } } = this.getOptions();
+		try {
+			return await axios.post("https://devecostudio-drcn.deveco.dbankcloud.com/sdkmanager/v8/hos/getSdkList", {
+				osArch: this.getArch(),
+				osType: this.getOperatingSystem(),
+				supportVersion
+			});
+		} catch (error) {
+			return error;
+		}
+	}
+	async safeReadAndParseSdkPkgFile(sdkPkgFileUri) {
+		const { adapter: { fs } } = this.getOptions();
+		try {
+			const sdkPkgFileContent = await fs.readFile(sdkPkgFileUri).then((buffer) => buffer.toString());
+			if (!sdkPkgFileContent.length) return void 0;
+			return JSON.parse(sdkPkgFileContent);
+		} catch {
+			return;
+		}
+	}
+	async safeReadAndParseInfoFile(infoFileUri) {
+		const { adapter: { fs } } = this.getOptions();
+		try {
+			const infoFileContent = await fs.readFile(infoFileUri).then((buffer) => buffer.toString());
+			if (!infoFileContent.length) return void 0;
+			return JSON.parse(infoFileContent);
+		} catch {
+			return;
 		}
-		return images;
 	}
-	async getProductConfig() {
-		const productConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, "productConfig.json");
-		if (!this.resolvedOptions.fs.existsSync(productConfigPath) || !this.resolvedOptions.fs.statSync(productConfigPath).isFile()) return (await import("./default-product-config.mjs")).default;
-		return JSON.parse(this.resolvedOptions.fs.readFileSync(productConfigPath, "utf-8"));
+	async getLocalImages() {
+		const { adapter: { fs, join } } = this.getOptions();
+		const localImages = [];
+		const systemImagePath = join(this.options.imageBasePath, "system-image");
+		const sdkPkgFiles = await fs.glob(new RelativePattern(systemImagePath, "**/sdk-pkg.json"), { deep: 3 });
+		for (const sdkPkgFileUri of sdkPkgFiles) {
+			const sdkPkgFile = await this.safeReadAndParseSdkPkgFile(sdkPkgFileUri);
+			if (!sdkPkgFile) continue;
+			const infoFile = await this.safeReadAndParseInfoFile(sdkPkgFileUri.with({ path: sdkPkgFileUri.path.replace("sdk-pkg.json", "info.json") }));
+			if (!infoFile) continue;
+			localImages.push(new LocalImageImpl(this, sdkPkgFile, infoFile));
+		}
+		return localImages;
+	}
+	async getRemoteImages(supportVersion = "6.0-hos-single-9") {
+		const remoteImages = [];
+		const { adapter: { isAxiosError } } = this.getOptions();
+		const resultOrError = await this.requestSdkList(supportVersion);
+		if (isAxiosError(resultOrError)) return new SDKList.SDKListError(SDKList.SDKListError.Code.REQUEST_ERROR, "Request failed with image sdk list.", resultOrError);
+		if (!Array.isArray(resultOrError.data)) return new SDKList.SDKListError(SDKList.SDKListError.Code.REQUEST_ERROR, "Request failed with image sdk list.", resultOrError);
+		for (const item of resultOrError.data) {
+			if (typeof item !== "object" || item === null || Array.isArray(item)) continue;
+			remoteImages.push(new RemoteImageImpl(this, item));
+		}
+		return remoteImages;
+	}
+	async getDownloadedRemoteImages(supportVersion) {
+		const remoteImages = await this.getRemoteImages(supportVersion);
+		if (remoteImages instanceof SDKList.SDKListError) return remoteImages;
+		const downloadedRemoteImages = [];
+		for (const remoteImage of remoteImages) {
+			if (!await remoteImage.getLocalImage()) continue;
+			downloadedRemoteImages.push(remoteImage);
+		}
+		return downloadedRemoteImages;
 	}
-	async getEmulatorConfig() {
-		const emulatorConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.emulatorPath, "emulator.json");
-		if (!this.resolvedOptions.fs.existsSync(emulatorConfigPath) || !this.resolvedOptions.fs.statSync(emulatorConfigPath).isFile()) return (await import("./default-emulator-config.mjs")).default;
-		return JSON.parse(this.resolvedOptions.fs.readFileSync(emulatorConfigPath, "utf-8"));
+	getListsFilePath() {
+		const { deployedPath, adapter: { join } } = this.getOptions();
+		return join(deployedPath, "lists.json");
+	}
+	async readListsFile() {
+		try {
+			const { adapter: { fs } } = this.getOptions();
+			const listsFilePath = this.getListsFilePath();
+			const listsFileContent = await fs.readFile(listsFilePath).then((buffer) => buffer.toString());
+			if (!listsFileContent.length) return new ListsFileImpl(this, []);
+			return new ListsFileImpl(this, JSON.parse(listsFileContent));
+		} catch {
+			return new ListsFileImpl(this, []);
+		}
+	}
+	async readEmulatorFile() {
+		try {
+			const { adapter: { fs, join } } = this.getOptions();
+			const emulatorFilePath = join(this.options.emulatorPath, "emulator.json");
+			const emulatorFileContent = await fs.readFile(emulatorFilePath).then((buffer) => buffer.toString());
+			if (!emulatorFileContent.length) return new EmulatorFileImpl(this, (await import("./default-emulator-config.mjs")).default);
+			return new EmulatorFileImpl(this, JSON.parse(emulatorFileContent));
+		} catch {
+			return new EmulatorFileImpl(this, (await import("./default-emulator-config.mjs")).default);
+		}
+	}
+	async readProductConfigFile() {
+		try {
+			const { adapter: { fs, join } } = this.getOptions();
+			const productConfigFilePath = join(this.options.emulatorPath, "product-config.json");
+			const productConfigFileContent = await fs.readFile(productConfigFilePath).then((buffer) => buffer.toString());
+			if (!productConfigFileContent.length) return new ProductConfigFileImpl(this, (await import("./default-product-config.mjs")).default);
+			return new ProductConfigFileImpl(this, JSON.parse(productConfigFileContent));
+		} catch {
+			return new ProductConfigFileImpl(this, (await import("./default-product-config.mjs")).default);
+		}
 	}
-	async writeDefaultProductConfig(existSkip = false) {
-		const productConfigPath = this.resolvedOptions.path.resolve(this.resolvedOptions.imageBasePath, "productConfig.json");
-		if (existSkip && this.resolvedOptions.fs.existsSync(productConfigPath)) return;
-		this.resolvedOptions.fs.writeFileSync(productConfigPath, JSON.stringify((await import("./default-product-config.mjs")).default, null, 2));
+	async getDeployedDevices() {
+		const deployedDevices = [];
+		const listsFile = await this.readListsFile();
+		const productConfigFile = await this.readProductConfigFile();
+		const emulatorFile = await this.readEmulatorFile();
+		for (const listFileItem of listsFile.getListsFileItems()) {
+			const productConfigItem = productConfigFile.findProductConfigItem({
+				deviceType: DeviceTypeConverter.snakecaseToCamelcase(listFileItem.getContent().type),
+				name: listFileItem.getContent().model
+			});
+			if (!productConfigItem) continue;
+			const emulatorDeviceItem = emulatorFile.findDeviceItem({
+				deviceType: listFileItem.getContent().type,
+				apiVersion: Number(listFileItem.getContent().apiVersion)
+			});
+			if (!emulatorDeviceItem) continue;
+			const screen = new ScreenPresetImpl({
+				productConfigItem,
+				emulatorDeviceItem
+			});
+			const device = new DeviceImpl({
+				imageManager: this,
+				listsFile,
+				listFileItem,
+				screen
+			});
+			const configIniFileUri = ConfigIniFileImpl.getFileUri(device);
+			const parsedConfigIniFile = await ConfigIniFileImpl.safeReadAndParse(device);
+			if (!parsedConfigIniFile) {
+				listsFile.deleteListsFileItem(listFileItem);
+				continue;
+			}
+			device.setConfigIniFile(new ConfigIniFileImpl(device, configIniFileUri, parsedConfigIniFile));
+			const namedIniFileUri = NamedIniFileImpl.getFileUri(device);
+			const parsedNamedIniFile = await NamedIniFileImpl.safeReadAndParse(device);
+			if (!parsedNamedIniFile) {
+				listsFile.deleteListsFileItem(listFileItem);
+				continue;
+			}
+			device.setNamedIniFile(new NamedIniFileImpl(device, namedIniFileUri, parsedNamedIniFile));
+			deployedDevices.push(device);
+		}
+		if (listsFile.isChanged) listsFile.write();
+		return deployedDevices;
+	}
+	toJSON() {
+		return {
+			options: this.getOptions(),
+			operatingSystem: this.getOperatingSystem(),
+			arch: this.getArch(),
+			listsFilePath: this.getListsFilePath()
+		};
 	}
 	async isCompatible() {
-		const { fs, path, emulatorPath } = this.resolvedOptions;
-		const sdkPkgPath = path.resolve(emulatorPath, "sdk-pkg.json");
-		if (!fs.existsSync(sdkPkgPath) || !fs.statSync(sdkPkgPath).isFile()) return false;
-		const sdkPkg = JSON.parse(fs.readFileSync(sdkPkgPath, "utf-8"));
+		const { emulatorPath, adapter: { fs, join, URI } } = this.getOptions();
+		const sdkPkgPath = join(emulatorPath, "sdk-pkg.json").fsPath;
+		if (!await fs.isFile(URI.file(sdkPkgPath))) return false;
+		const sdkPkg = JSON.parse(await fs.readFile(URI.file(sdkPkgPath)).then((buffer) => buffer.toString()));
 		if (!sdkPkg?.data?.version || typeof sdkPkg.data.version !== "string") return false;
 		const [major, minor, patch] = sdkPkg.data.version.split(".").map(Number);
+		const satisfies = (await import("semver/functions/satisfies")).default;
 		return satisfies(`${major}.${minor}.${patch}`, ">=6.0.2");
 	}
 };
-async function createImageManager(options = {}) {
-	return new ImageManagerImpl(await resolveImageManagerOptions(options));
+async function createImageManager(options) {
+	return new ImageManagerImpl(await OptionsResolver.resolveImageManagerOptions(options));
 }
 
 //#endregion
-export { BaseEmulatorConfigItem, DeployError, DevModel, GroupPCAllEmulatorConfigItem, GroupPhoneAllEmulatorConfigItem, PCAllEmulatorConfigItem, ParentEmulatorConfigItem, PhoneAllEmulatorConfigItem, ProductConfigItem, RequestUrlError, createCoverScreen, createDoubleScreen, createImageManager, createOuterDoubleScreen, createOuterScreen, createScreen, createScreenPreset, createSingleScreen, version };
+export { BaseImage, ConfigIniFile, CustomizeFoldableScreen, CustomizeScreen, Device, EmulatorBasicItem, EmulatorFile, EmulatorFoldItem, EmulatorGroupItem, EmulatorTripleFoldItem, ListsFile, ListsFileItem, LocalImage, ProductConfigFile, ProductConfigItem, RemoteImage, SDKList, ScreenPreset, createImageManager, version };