@weapp-vite/miniprogram-automator 1.0.1 → 1.0.2

package/dist/{launch-IFPMxQYb.mjs → launch-Bd3TZy1I.mjs}

@@ -28,6 +28,8 @@ function createAppInstance(definition) {
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/componentInstance.ts
+const ARRAY_INDEX_PATH_RE$1 = /\[(\d+)\]/g;
+const ARRAY_INDEX_SEGMENT_RE$1 = /^\d+$/;
 function bindFunction$1(target, key, value) {
 	if (typeof value !== "function") {
 		target[key] = value;
@@ -44,10 +46,10 @@ function cloneValue$1(value) {
 	return value;
 }
 function parseDataPath$1(path) {
-	return path.replace(/\[(\d+)\]/g, ".$1").split(".").map((segment) => segment.trim()).filter(Boolean);
+	return path.replace(ARRAY_INDEX_PATH_RE$1, ".$1").split(".").map((segment) => segment.trim()).filter(Boolean);
 }
 function isArrayIndexSegment$1(segment) {
-	return /^\d+$/.test(segment);
+	return ARRAY_INDEX_SEGMENT_RE$1.test(segment);
 }
 function createContainerByNextSegment$1(nextSegment) {
 	return isArrayIndexSegment$1(nextSegment ?? "") ? [] : {};
@@ -64,7 +66,7 @@ function assignByPath$1(target, path, value) {
 		if (!next || typeof next !== "object") current[normalizedSegment] = createContainerByNextSegment$1(nextSegment);
 		current = current[normalizedSegment];
 	}
-	const leafSegment = segments[segments.length - 1];
+	const leafSegment = segments.at(-1);
 	const normalizedLeafSegment = isArrayIndexSegment$1(leafSegment) ? Number(leafSegment) : leafSegment;
 	current[normalizedLeafSegment] = value;
 }
@@ -184,7 +186,7 @@ function resolveInitialProperties(definition, properties) {
 	const resolved = {};
 	const propOptions = definition.properties;
 	if (propOptions && typeof propOptions === "object" && !Array.isArray(propOptions)) for (const [key, option] of Object.entries(propOptions)) {
-		if (Object.prototype.hasOwnProperty.call(properties, key)) {
+		if (Object.hasOwn(properties, key)) {
 			resolved[key] = coerceComponentPropertyValue(properties[key], option);
 			continue;
 		}
@@ -220,7 +222,7 @@ function resolveObservedValue(instance, pattern) {
 	const segments = parseDataPath$1(pattern);
 	if (segments.length === 0) return;
 	const [rootSegment, ...restSegments] = segments;
-	let current = (Object.prototype.hasOwnProperty.call(instance.properties, rootSegment) ? instance.properties : instance.data)?.[rootSegment];
+	let current = (Object.hasOwn(instance.properties, rootSegment) ? instance.properties : instance.data)?.[rootSegment];
 	for (const segment of restSegments) {
 		const normalizedSegment = isArrayIndexSegment$1(segment) ? Number(segment) : segment;
 		current = current?.[normalizedSegment];
@@ -2853,7 +2855,7 @@ const STRUCTURAL_ATTRS = [
 	"wx:key"
 ];
 const WX_ELSE_ATTRS = new Set(["wx:elif", "wx:else"]);
-const DATASET_NAME_RE$2 = /-([a-z])/g;
+const DATASET_NAME_RE$3 = /-([a-z])/g;
 const BRACKET_INDEX_RE = /\[(\d+)\]/g;
 const CLASS_SPLIT_RE = /\s+/;
 const JS_FILE_RE = /\.js$/;
@@ -2861,14 +2863,14 @@ function isMustacheOnly(value) {
 	const trimmed = value.trim();
 	return trimmed.startsWith("{{") && trimmed.endsWith("}}") && !trimmed.includes("{{", 2);
 }
-function toDatasetKey$2(attributeName) {
-	return attributeName.slice(5).replace(DATASET_NAME_RE$2, (_match, char) => char.toUpperCase());
+function toDatasetKey$3(attributeName) {
+	return attributeName.slice(5).replace(DATASET_NAME_RE$3, (_match, char) => char.toUpperCase());
 }
-function collectDataset$2(node) {
+function collectDataset$3(node) {
 	const dataset = {};
 	for (const [key, value] of Object.entries(node.attribs ?? {})) {
 		if (!key.startsWith("data-") || key === "data-sim-scope" || key === "data-sim-tap" || key === "data-sim-component") continue;
-		dataset[toDatasetKey$2(key)] = String(value);
+		dataset[toDatasetKey$3(key)] = String(value);
 	}
 	return dataset;
 }
@@ -3006,7 +3008,7 @@ function collectComponentEventBindings(hostNode) {
 	return eventBindings;
 }
 function buildComponentTrigger(componentScopeId, context, hostNode) {
-	const hostDataset = collectDataset$2(hostNode);
+	const hostDataset = collectDataset$3(hostNode);
 	const hostId = hostNode.attribs?.id ?? "";
 	return (instance, eventName, detail, triggerOptions) => {
 		const interactionTarget = instance.__lastInteractionEvent__?.target;
@@ -3187,6 +3189,8 @@ function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, inst
 				properties: nextProperties,
 				triggerEvent: buildComponentTrigger(componentScopeId, context, clonedNode)
 			});
+			componentInstance.createIntersectionObserver = (options) => context.session.createIntersectionObserver(componentInstance, options);
+			componentInstance.createMediaQueryObserver = () => context.session.createMediaQueryObserver(componentInstance);
 			componentInstance.selectComponent = (selector) => context.session.selectComponentWithin(componentScopeId, selector);
 			componentInstance.selectAllComponents = (selector) => context.session.selectAllComponentsWithin(componentScopeId, selector);
 			componentInstance.selectOwnerComponent = () => ownerScopeId ? context.session.selectOwnerComponent(componentScopeId) : null;
@@ -3201,7 +3205,7 @@ function renderNodeTree(node, scope, context, ownerJsonPath, ownerFilePath, inst
 			alias: clonedNode.name,
 			classList: String(clonedNode.attribs?.class ?? "").split(CLASS_SPLIT_RE).map((item) => item.trim()).filter(Boolean),
 			data: createMergedScopeData(scope.data, componentInstance.properties, componentInstance.data),
-			dataset: collectDataset$2(clonedNode),
+			dataset: collectDataset$3(clonedNode),
 			eventBindings: collectComponentEventBindings(clonedNode),
 			getMethod: (methodName) => {
 				const method = componentInstance?.[methodName];
@@ -3312,9 +3316,65 @@ function resolveCapabilityValue(source, schema) {
 function createHeadlessWx(driver) {
 	const capabilityTree = {
 		canIUse: true,
+		canvasToTempFilePath: true,
+		chooseImage: { return: {
+			errMsg: true,
+			tempFilePaths: true,
+			tempFiles: true
+		} },
+		chooseMessageFile: { return: {
+			errMsg: true,
+			tempFiles: true
+		} },
+		chooseMedia: { return: {
+			errMsg: true,
+			tempFiles: true,
+			type: true
+		} },
+		chooseVideo: { return: {
+			duration: true,
+			errMsg: true,
+			height: true,
+			size: true,
+			tempFilePath: true,
+			width: true
+		} },
+		compressImage: { return: {
+			errMsg: true,
+			tempFilePath: true
+		} },
 		clearStorage: true,
 		clearStorageSync: true,
+		createAnimation: true,
+		createCanvasContext: true,
+		createIntersectionObserver: true,
+		createVideoContext: true,
 		createSelectorQuery: true,
+		getImageInfo: { return: {
+			errMsg: true,
+			height: true,
+			orientation: true,
+			path: true,
+			type: true,
+			width: true
+		} },
+		getFileInfo: { return: {
+			digest: true,
+			errMsg: true,
+			size: true
+		} },
+		openDocument: { return: { errMsg: true } },
+		getVideoInfo: { return: {
+			bitrate: true,
+			duration: true,
+			errMsg: true,
+			fps: true,
+			height: true,
+			orientation: true,
+			size: true,
+			type: true,
+			width: true
+		} },
 		getFileSystemManager: true,
 		getSavedFileInfo: true,
 		getSavedFileList: true,
@@ -3352,6 +3412,10 @@ function createHeadlessWx(driver) {
 			},
 			scene: true
 		} },
+		getClipboardData: { return: {
+			data: true,
+			errMsg: true
+		} },
 		getMenuButtonBoundingClientRect: { return: {
 			bottom: true,
 			height: true,
@@ -3426,14 +3490,18 @@ function createHeadlessWx(driver) {
 		offNetworkStatusChange: true,
 		onNetworkStatusChange: true,
 		pageScrollTo: true,
+		previewImage: true,
 		reLaunch: true,
 		redirectTo: true,
+		saveImageToPhotosAlbum: true,
+		saveVideoToPhotosAlbum: true,
 		removeStorage: true,
 		removeStorageSync: true,
 		request: true,
 		saveFile: true,
 		setBackgroundColor: true,
 		setBackgroundTextStyle: true,
+		setClipboardData: true,
 		setStorage: true,
 		setStorageSync: true,
 		setNavigationBarColor: true,
@@ -3450,6 +3518,7 @@ function createHeadlessWx(driver) {
 		showLoading: true,
 		showModal: true,
 		showToast: true,
+		startPullDownRefresh: true,
 		stopPullDownRefresh: true,
 		switchTab: true,
 		uploadFile: true,
@@ -3459,11 +3528,21 @@ function createHeadlessWx(driver) {
 	};
 	return {
 		canIUse: (schema) => typeof schema === "string" && schema.trim() !== "" && resolveCapabilityValue(capabilityTree, schema.trim()) != null,
+		canvasToTempFilePath: (option) => invokeWxApi(() => driver.canvasToTempFilePath(option), option),
+		chooseImage: (option) => invokeWxApi(() => driver.chooseImage(option ?? {}), option),
+		chooseMessageFile: (option) => invokeWxApi(() => driver.chooseMessageFile(option ?? {}), option),
+		chooseMedia: (option) => invokeWxApi(() => driver.chooseMedia(option ?? {}), option),
+		chooseVideo: (option) => invokeWxApi(() => driver.chooseVideo(option ?? {}), option),
+		compressImage: (option) => invokeWxApi(() => driver.compressImage(option), option),
 		clearStorage: (option) => invokeWxApi(() => {
 			driver.clearStorageSync();
 			return { errMsg: "clearStorage:ok" };
 		}, option),
 		clearStorageSync: () => driver.clearStorageSync(),
+		createAnimation: (option) => driver.createAnimation(option),
+		createCanvasContext: (canvasId, component) => driver.createCanvasContext(canvasId, component),
+		createIntersectionObserver: (component, options) => driver.createIntersectionObserver(component, options),
+		createVideoContext: (videoId, component) => driver.createVideoContext(videoId, component),
 		createSelectorQuery: () => {
 			const requests = [];
 			let scope;
@@ -3522,12 +3601,16 @@ function createHeadlessWx(driver) {
 			return query;
 		},
 		getEnterOptionsSync: () => driver.getEnterOptionsSync(),
+		getFileInfo: (option) => invokeWxApi(() => driver.getFileInfo(option), option),
+		getImageInfo: (option) => invokeWxApi(() => driver.getImageInfo(option), option),
+		getVideoInfo: (option) => invokeWxApi(() => driver.getVideoInfo(option), option),
 		getFileSystemManager: () => driver.getFileSystemManager(),
 		getSavedFileInfo: (option) => invokeWxApi(() => driver.getSavedFileInfo(option), option),
 		getSavedFileList: (option) => invokeWxApi(() => driver.getSavedFileList(option), option),
 		getAppBaseInfo: (option) => invokeWxApi(() => driver.getAppBaseInfoSync(), option),
 		getAppBaseInfoSync: () => driver.getAppBaseInfoSync(),
 		getLaunchOptionsSync: () => driver.getLaunchOptionsSync(),
+		getClipboardData: (option) => invokeWxApi(() => driver.getClipboardData(), option),
 		getMenuButtonBoundingClientRect: () => driver.getMenuButtonBoundingClientRect(),
 		getNetworkType: (option) => invokeWxApi(() => driver.getNetworkType(), option),
 		getStorageInfo: (option) => invokeWxApi(() => driver.getStorageInfoSync(), option),
@@ -3553,9 +3636,11 @@ function createHeadlessWx(driver) {
 		nextTick: (callback) => driver.nextTick(callback),
 		offNetworkStatusChange: (callback) => driver.offNetworkStatusChange(callback),
 		onNetworkStatusChange: (callback) => driver.onNetworkStatusChange(callback),
+		openDocument: (option) => invokeWxApi(() => driver.openDocument(option), option),
 		pageScrollTo: (option) => invokeWxApi(() => {
 			driver.pageScrollTo(option);
 		}, option),
+		previewImage: (option) => invokeWxApi(() => driver.previewImage(option), option),
 		reLaunch: (option) => invokeWxApi(() => {
 			driver.reLaunch(option);
 		}, option),
@@ -3563,6 +3648,8 @@ function createHeadlessWx(driver) {
 			driver.redirectTo(option);
 		}, option),
 		removeSavedFile: (option) => invokeWxApi(() => driver.removeSavedFile(option), option),
+		saveImageToPhotosAlbum: (option) => invokeWxApi(() => driver.saveImageToPhotosAlbum(option), option),
+		saveVideoToPhotosAlbum: (option) => invokeWxApi(() => driver.saveVideoToPhotosAlbum(option), option),
 		removeStorage: (option) => invokeWxApi(() => {
 			driver.removeStorageSync(option.key);
 			return { errMsg: "removeStorage:ok" };
@@ -3572,6 +3659,7 @@ function createHeadlessWx(driver) {
 		saveFile: (option) => invokeWxApi(() => driver.saveFile(option), option),
 		setBackgroundColor: (option) => invokeWxApi(() => driver.setBackgroundColor(option), option),
 		setBackgroundTextStyle: (option) => invokeWxApi(() => driver.setBackgroundTextStyle(option), option),
+		setClipboardData: (option) => invokeWxApi(() => driver.setClipboardData(option), option),
 		setStorage: (option) => invokeWxApi(() => {
 			driver.setStorageSync(option.key, option.data);
 			return { errMsg: "setStorage:ok" };
@@ -3591,6 +3679,7 @@ function createHeadlessWx(driver) {
 		showLoading: (option) => invokeWxApi(() => driver.showLoading(option), option),
 		showModal: (option) => invokeWxApi(() => driver.showModal(option), option),
 		showToast: (option) => invokeWxApi(() => driver.showToast(option), option),
+		startPullDownRefresh: (option) => invokeWxApi(() => driver.startPullDownRefresh(), option),
 		stopPullDownRefresh: () => driver.stopPullDownRefresh(),
 		switchTab: (option) => invokeWxApi(() => {
 			driver.switchTab(option);
@@ -3802,10 +3891,11 @@ function loadProject(projectPath) {
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/selectors.ts
-const WHITESPACE_RE = /\s+/;
+const WHITESPACE_RE$1 = /\s+/;
 const DATA_ATTR_SELECTOR_RE$1 = /^\[data-([^=\]]+)="([^"]*)"\]$/;
+const COMPOUND_SELECTOR_PART_RE$1 = /#[\w-]+|\.[\w-]+|\[data-[^=\]]+="[^"]*"\]|[A-Za-z][\w-]*/g;
 function getClassList(node) {
-	return String(node.attribs?.class ?? "").split(WHITESPACE_RE).map((item) => item.trim()).filter(Boolean);
+	return String(node.attribs?.class ?? "").split(WHITESPACE_RE$1).map((item) => item.trim()).filter(Boolean);
 }
 function matchesSimpleSelector(node, selector) {
 	if (node.type !== "tag") return false;
@@ -3819,6 +3909,15 @@ function matchesSimpleSelector(node, selector) {
 	}
 	return node.name === selector;
 }
+function parseCompoundSelector$1(selector) {
+	const parts = selector.match(COMPOUND_SELECTOR_PART_RE$1) ?? [];
+	return parts.join("") === selector ? parts : [];
+}
+function matchesSelectorToken(node, selector) {
+	const simpleSelectors = parseCompoundSelector$1(selector);
+	if (simpleSelectors.length === 0) return false;
+	return simpleSelectors.every((simpleSelector) => matchesSimpleSelector(node, simpleSelector));
+}
 function collectDescendants(node, into) {
 	for (const child of node.children ?? []) {
 		into.push(child);
@@ -3826,7 +3925,7 @@ function collectDescendants(node, into) {
 	}
 }
 function querySelectorAll(root, selector) {
-	const parts = selector.trim().split(WHITESPACE_RE).filter(Boolean);
+	const parts = selector.trim().split(WHITESPACE_RE$1).filter(Boolean);
 	if (parts.length === 0) return [];
 	let current = [root];
 	for (const part of parts) {
@@ -3835,7 +3934,7 @@ function querySelectorAll(root, selector) {
 			const candidates = [];
 			if (part === "page" && node.type === "tag" && node.name === "page") candidates.push(node);
 			collectDescendants(node, candidates);
-			for (const candidate of candidates) if (matchesSimpleSelector(candidate, part)) next.push(candidate);
+			for (const candidate of candidates) if (matchesSelectorToken(candidate, part)) next.push(candidate);
 		}
 		current = next;
 	}
@@ -3843,22 +3942,22 @@ function querySelectorAll(root, selector) {
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/nodeHandle.ts
-const DATASET_NAME_RE$1 = /-([a-z])/g;
+const DATASET_NAME_RE$2 = /-([a-z])/g;
 function escapeText$1(text) {
 	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-function toDatasetKey$1(attributeName) {
-	return attributeName.slice(5).replace(DATASET_NAME_RE$1, (_match, char) => char.toUpperCase());
+function toDatasetKey$2(attributeName) {
+	return attributeName.slice(5).replace(DATASET_NAME_RE$2, (_match, char) => char.toUpperCase());
 }
-function collectDataset$1(node) {
+function collectDataset$2(node) {
 	const dataset = {};
 	for (const [key, value] of Object.entries(node.attribs ?? {})) {
 		if (!key.startsWith("data-") || key.startsWith("data-sim-")) continue;
-		dataset[toDatasetKey$1(key)] = value;
+		dataset[toDatasetKey$2(key)] = value;
 	}
 	return dataset;
 }
-function resolveEventBinding(node, eventName) {
+function resolveEventBinding$1(node, eventName) {
 	const normalizedEventName = eventName.trim();
 	if (!normalizedEventName) return null;
 	const bindingAttrs = [
@@ -3873,8 +3972,8 @@ function resolveEventBinding(node, eventName) {
 	}
 	return null;
 }
-function createEventPayload(node, eventName, event) {
-	const dataset = collectDataset$1(node);
+function createEventPayload$1(node, eventName, event) {
+	const dataset = collectDataset$2(node);
 	const nodeId = node.attribs?.id ?? "";
 	return {
 		bubbles: false,
@@ -3939,7 +4038,7 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 		return this.node.attribs?.[name];
 	}
 	async dataset() {
-		return collectDataset$1(this.node);
+		return collectDataset$2(this.node);
 	}
 	async scope() {
 		if (!this.interactions) throw new Error("Node interactions are not available for this headless testing node.");
@@ -3969,9 +4068,9 @@ var HeadlessTestingNodeHandle = class HeadlessTestingNodeHandle {
 		if (!this.interactions) throw new Error("Node interactions are not available for this headless testing node.");
 		const normalizedEventName = eventName.trim();
 		if (!normalizedEventName) throw new Error("Event name must be a non-empty string in headless testing runtime.");
-		const methodName = resolveEventBinding(this.node, normalizedEventName);
+		const methodName = resolveEventBinding$1(this.node, normalizedEventName);
 		if (!methodName) throw new Error(`No ${normalizedEventName} binding was found on <${this.node.name ?? "unknown"}> in headless testing runtime.`);
-		return await this.interactions.callMethod(this.node.attribs?.["data-sim-scope"] ?? null, methodName, createEventPayload(this.node, normalizedEventName, event));
+		return await this.interactions.callMethod(this.node.attribs?.["data-sim-scope"] ?? null, methodName, createEventPayload$1(this.node, normalizedEventName, event));
 	}
 	async tap(event = {}) {
 		return await this.trigger("tap", event);
@@ -4055,18 +4154,18 @@ function renderPageTree(project, page) {
 }
 //#endregion
 //#region ../../mpcore/packages/simulator/src/view/selectorQuery.ts
-const DATASET_NAME_RE = /-([a-z])/g;
+const DATASET_NAME_RE$1 = /-([a-z])/g;
 const LEADING_MARK_PREFIX_RE = /^mark[:\-]?/;
 const MARK_NAME_RE = /[:\-]([a-z])/g;
-const NUMERIC_LIKE_VALUE_RE = /-?\d+(?:\.\d+)?/;
-function toDatasetKey(attributeName) {
-	return attributeName.slice(5).replace(DATASET_NAME_RE, (_match, char) => char.toUpperCase());
+const NUMERIC_LIKE_VALUE_RE$1 = /-?\d+(?:\.\d+)?/;
+function toDatasetKey$1(attributeName) {
+	return attributeName.slice(5).replace(DATASET_NAME_RE$1, (_match, char) => char.toUpperCase());
 }
-function collectDataset(node) {
+function collectDataset$1(node) {
 	const dataset = {};
 	for (const [key, value] of Object.entries(node.attribs ?? {})) {
 		if (!key.startsWith("data-") || key.startsWith("data-sim-")) continue;
-		dataset[toDatasetKey(key)] = value;
+		dataset[toDatasetKey$1(key)] = value;
 	}
 	return dataset;
 }
@@ -4095,7 +4194,7 @@ function findNodeByScopeId(root, scopeId) {
 	}
 	return null;
 }
-function parseStyleDeclarations(styleValue) {
+function parseStyleDeclarations$1(styleValue) {
 	const declarations = {};
 	if (!styleValue) return declarations;
 	for (const declaration of styleValue.split(";")) {
@@ -4106,17 +4205,17 @@ function parseStyleDeclarations(styleValue) {
 	}
 	return declarations;
 }
-function parseNumericLikeValue(value) {
+function parseNumericLikeValue$1(value) {
 	if (!value) return 0;
-	const match = value.match(NUMERIC_LIKE_VALUE_RE);
+	const match = value.match(NUMERIC_LIKE_VALUE_RE$1);
 	return match ? Number(match[0]) : 0;
 }
-function resolveRect(node) {
-	const style = parseStyleDeclarations(node.attribs?.style);
-	const left = parseNumericLikeValue(node.attribs?.["data-sim-left"] ?? style.left);
-	const top = parseNumericLikeValue(node.attribs?.["data-sim-top"] ?? style.top);
-	const width = parseNumericLikeValue(node.attribs?.["data-sim-width"] ?? style.width);
-	const height = parseNumericLikeValue(node.attribs?.["data-sim-height"] ?? style.height);
+function resolveRect$1(node) {
+	const style = parseStyleDeclarations$1(node.attribs?.style);
+	const left = parseNumericLikeValue$1(node.attribs?.["data-sim-left"] ?? style.left);
+	const top = parseNumericLikeValue$1(node.attribs?.["data-sim-top"] ?? style.top);
+	const width = parseNumericLikeValue$1(node.attribs?.["data-sim-width"] ?? style.width);
+	const height = parseNumericLikeValue$1(node.attribs?.["data-sim-height"] ?? style.height);
 	return {
 		bottom: top + height,
 		height,
@@ -4126,10 +4225,16 @@ function resolveRect(node) {
 		width
 	};
 }
+function resolveSelectorScrollTop(root, selector) {
+	const normalizedSelector = selector?.trim();
+	if (!normalizedSelector) return null;
+	const match = querySelectorAll(root, normalizedSelector)[0];
+	return match ? resolveRect$1(match).top : null;
+}
 function resolveScrollOffset(node) {
 	return {
-		scrollLeft: parseNumericLikeValue(node.attribs?.["data-sim-scroll-left"]),
-		scrollTop: parseNumericLikeValue(node.attribs?.["data-sim-scroll-top"])
+		scrollLeft: parseNumericLikeValue$1(node.attribs?.["data-sim-scroll-left"]),
+		scrollTop: parseNumericLikeValue$1(node.attribs?.["data-sim-scroll-top"])
 	};
 }
 function resolvePropertyValue(node, propertyName) {
@@ -4137,7 +4242,7 @@ function resolvePropertyValue(node, propertyName) {
 	if (!normalizedPropertyName) return;
 	if (normalizedPropertyName === "id") return node.attribs?.id ?? "";
 	if (normalizedPropertyName === "class") return node.attribs?.class ?? "";
-	if (normalizedPropertyName === "dataset") return collectDataset(node);
+	if (normalizedPropertyName === "dataset") return collectDataset$1(node);
 	return node.attribs?.[normalizedPropertyName];
 }
 function pickProperties(node, propertyNames) {
@@ -4146,18 +4251,18 @@ function pickProperties(node, propertyNames) {
 	return result;
 }
 function pickComputedStyle(node, propertyNames) {
-	const style = parseStyleDeclarations(node.attribs?.style);
+	const style = parseStyleDeclarations$1(node.attribs?.style);
 	const result = {};
 	for (const propertyName of propertyNames) result[propertyName] = style[propertyName] ?? "";
 	return result;
 }
-function resolveFieldsResult(node, fields, _options) {
+function resolveFieldsResult(node, fields, options) {
 	const result = {};
 	if (fields.id) result.id = node.attribs?.id ?? "";
-	if (fields.dataset) result.dataset = collectDataset(node);
+	if (fields.dataset) result.dataset = collectDataset$1(node);
 	if (fields.mark) result.mark = collectMark(node);
 	if (fields.rect || fields.size) {
-		const rect = resolveRect(node);
+		const rect = resolveRect$1(node);
 		if (fields.rect) Object.assign(result, rect);
 		if (fields.size) {
 			result.width = rect.width;
@@ -4167,7 +4272,7 @@ function resolveFieldsResult(node, fields, _options) {
 	if (fields.scrollOffset) Object.assign(result, resolveScrollOffset(node));
 	if (Array.isArray(fields.properties) && fields.properties.length > 0) Object.assign(result, pickProperties(node, fields.properties));
 	if (Array.isArray(fields.computedStyle) && fields.computedStyle.length > 0) Object.assign(result, pickComputedStyle(node, fields.computedStyle));
-	if (fields.context) result.context = { type: "unsupported-context" };
+	if (fields.context) result.context = options.resolveContext?.(node) ?? { type: "unsupported-context" };
 	if (fields.node) result.node = { type: node.name ?? "unknown" };
 	return result;
 }
@@ -4210,6 +4315,749 @@ function resolveSelectorQueryScopeRoot(root, scopeId) {
 	return scopedNode ? createScopedRoot(scopedNode) : root;
 }
 //#endregion
+//#region ../../mpcore/packages/simulator/src/view/animation.ts
+const DEFAULT_STEP_OPTION = {
+	delay: 0,
+	duration: 400,
+	timingFunction: "linear",
+	transformOrigin: "50% 50% 0"
+};
+function normalizeStepOption(option) {
+	return {
+		delay: option?.delay ?? DEFAULT_STEP_OPTION.delay,
+		duration: option?.duration ?? DEFAULT_STEP_OPTION.duration,
+		timingFunction: option?.timingFunction ?? DEFAULT_STEP_OPTION.timingFunction,
+		transformOrigin: option?.transformOrigin ?? DEFAULT_STEP_OPTION.transformOrigin
+	};
+}
+function normalizeLength(value) {
+	if (typeof value === "number") return `${value}px`;
+	return value ?? "0px";
+}
+function createAction(type, args) {
+	return {
+		args,
+		type
+	};
+}
+function createHeadlessAnimation(defaultOption) {
+	const baseOption = normalizeStepOption(defaultOption);
+	let currentActions = [];
+	let queue = [];
+	let animation;
+	const append = (type, args) => {
+		currentActions.push(createAction(type, args));
+		return animation;
+	};
+	animation = {
+		backgroundColor(value) {
+			return append("backgroundColor", [value]);
+		},
+		bottom(value) {
+			return append("bottom", [normalizeLength(value)]);
+		},
+		export() {
+			const exported = queue.map((item) => ({
+				animates: item.animates.map((action) => ({
+					args: [...action.args],
+					type: action.type
+				})),
+				option: { ...item.option }
+			}));
+			queue = [];
+			currentActions = [];
+			return { actions: exported };
+		},
+		height(value) {
+			return append("height", [normalizeLength(value)]);
+		},
+		left(value) {
+			return append("left", [normalizeLength(value)]);
+		},
+		opacity(value) {
+			return append("opacity", [value]);
+		},
+		right(value) {
+			return append("right", [normalizeLength(value)]);
+		},
+		rotate(angle) {
+			return append("rotate", [`${angle}deg`]);
+		},
+		scale(sx, sy) {
+			return append("scale", [sx, sy ?? sx]);
+		},
+		step(option) {
+			queue.push({
+				animates: currentActions.map((action) => ({
+					args: [...action.args],
+					type: action.type
+				})),
+				option: {
+					...baseOption,
+					...option ?? {}
+				}
+			});
+			currentActions = [];
+			return animation;
+		},
+		top(value) {
+			return append("top", [normalizeLength(value)]);
+		},
+		translate(tx, ty) {
+			return append("translate", [normalizeLength(tx), normalizeLength(ty)]);
+		},
+		translate3d(tx, ty, tz) {
+			return append("translate3d", [
+				normalizeLength(tx),
+				normalizeLength(ty),
+				normalizeLength(tz)
+			]);
+		},
+		translateX(translation) {
+			return append("translateX", [normalizeLength(translation)]);
+		},
+		translateY(translation) {
+			return append("translateY", [normalizeLength(translation)]);
+		},
+		translateZ(translation) {
+			return append("translateZ", [normalizeLength(translation)]);
+		},
+		width(value) {
+			return append("width", [normalizeLength(value)]);
+		}
+	};
+	return animation;
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/canvasContext.ts
+function findCanvasNode(root, canvasId) {
+	if (root.type === "tag" && root.name === "canvas" && root.attribs?.["canvas-id"] === canvasId) return root;
+	for (const child of root.children ?? []) {
+		const match = findCanvasNode(child, canvasId);
+		if (match) return match;
+	}
+	return null;
+}
+function cloneCall(call) {
+	return {
+		args: call.args.map((arg) => Array.isArray(arg) ? [...arg] : arg),
+		type: call.type
+	};
+}
+function createHeadlessCanvasContext(driver, canvasId, scope) {
+	const defaultState = {
+		fillStyle: "#000000",
+		fontSize: 16,
+		globalAlpha: 1,
+		lineCap: "butt",
+		lineDash: [],
+		lineDashOffset: 0,
+		lineJoin: "miter",
+		miterLimit: 10,
+		lineWidth: 1,
+		shadowBlur: 0,
+		shadowColor: "#000000",
+		shadowOffsetX: 0,
+		shadowOffsetY: 0,
+		strokeStyle: "#000000",
+		textAlign: "start",
+		textBaseline: "alphabetic"
+	};
+	let state = { ...defaultState };
+	let stateStack = [];
+	let drawCalls = [];
+	let snapshot = {
+		canvasId,
+		drawCalls: [],
+		fillStyle: state.fillStyle,
+		fontSize: state.fontSize,
+		globalAlpha: state.globalAlpha,
+		lineCap: state.lineCap,
+		lineDash: [...state.lineDash],
+		lineDashOffset: state.lineDashOffset,
+		lineJoin: state.lineJoin,
+		miterLimit: state.miterLimit,
+		lineWidth: state.lineWidth,
+		reserve: false,
+		shadowBlur: state.shadowBlur,
+		shadowColor: state.shadowColor,
+		shadowOffsetX: state.shadowOffsetX,
+		shadowOffsetY: state.shadowOffsetY,
+		strokeStyle: state.strokeStyle,
+		textAlign: state.textAlign,
+		textBaseline: state.textBaseline
+	};
+	const resolveCanvas = () => {
+		const scopeResolution = driver.resolveScope(scope);
+		if (scopeResolution.kind === "missing") return null;
+		const rendered = driver.renderCurrentPage();
+		const root = scopeResolution.kind === "component" ? resolveSelectorQueryScopeRoot(rendered.root, scopeResolution.scopeId) : rendered.root;
+		return root ? findCanvasNode(root, canvasId) : null;
+	};
+	const ensureCanvas = () => {
+		const node = resolveCanvas();
+		if (!node) throw new Error(`Canvas with canvas-id "${canvasId}" was not found in headless runtime.`);
+		return node;
+	};
+	const record = (type, args) => {
+		ensureCanvas();
+		drawCalls.push({
+			args,
+			type
+		});
+	};
+	return {
+		arc(x, y, r, sAngle, eAngle, counterclockwise) {
+			record("arc", [
+				x,
+				y,
+				r,
+				sAngle,
+				eAngle,
+				Boolean(counterclockwise)
+			]);
+		},
+		arcTo(x1, y1, x2, y2, radius) {
+			record("arcTo", [
+				x1,
+				y1,
+				x2,
+				y2,
+				radius
+			]);
+		},
+		bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
+			record("bezierCurveTo", [
+				cp1x,
+				cp1y,
+				cp2x,
+				cp2y,
+				x,
+				y
+			]);
+		},
+		__getSnapshot() {
+			return {
+				canvasId: snapshot.canvasId,
+				drawCalls: snapshot.drawCalls.map(cloneCall),
+				fillStyle: snapshot.fillStyle,
+				fontSize: snapshot.fontSize,
+				globalAlpha: snapshot.globalAlpha,
+				lineCap: snapshot.lineCap,
+				lineDash: [...snapshot.lineDash],
+				lineDashOffset: snapshot.lineDashOffset,
+				lineJoin: snapshot.lineJoin,
+				miterLimit: snapshot.miterLimit,
+				lineWidth: snapshot.lineWidth,
+				reserve: snapshot.reserve,
+				shadowBlur: snapshot.shadowBlur,
+				shadowColor: snapshot.shadowColor,
+				shadowOffsetX: snapshot.shadowOffsetX,
+				shadowOffsetY: snapshot.shadowOffsetY,
+				strokeStyle: snapshot.strokeStyle,
+				textAlign: snapshot.textAlign,
+				textBaseline: snapshot.textBaseline
+			};
+		},
+		beginPath() {
+			record("beginPath", []);
+		},
+		clearRect(x, y, width, height) {
+			record("clearRect", [
+				x,
+				y,
+				width,
+				height
+			]);
+		},
+		clip(fillRule) {
+			record("clip", fillRule == null ? [] : [fillRule]);
+		},
+		closePath() {
+			record("closePath", []);
+		},
+		draw(reserve, callback) {
+			ensureCanvas();
+			snapshot = {
+				canvasId,
+				drawCalls: reserve ? [...snapshot.drawCalls.map(cloneCall), ...drawCalls.map(cloneCall)] : drawCalls.map(cloneCall),
+				fillStyle: state.fillStyle,
+				fontSize: state.fontSize,
+				globalAlpha: state.globalAlpha,
+				lineCap: state.lineCap,
+				lineDash: [...state.lineDash],
+				lineDashOffset: state.lineDashOffset,
+				lineJoin: state.lineJoin,
+				miterLimit: state.miterLimit,
+				lineWidth: state.lineWidth,
+				reserve: Boolean(reserve),
+				shadowBlur: state.shadowBlur,
+				shadowColor: state.shadowColor,
+				shadowOffsetX: state.shadowOffsetX,
+				shadowOffsetY: state.shadowOffsetY,
+				strokeStyle: state.strokeStyle,
+				textAlign: state.textAlign,
+				textBaseline: state.textBaseline
+			};
+			drawCalls = [];
+			state = { ...defaultState };
+			stateStack = [];
+			callback?.();
+		},
+		drawImage(image, ...args) {
+			record("drawImage", [image, ...args]);
+		},
+		fill(fillRule) {
+			record("fill", fillRule == null ? [] : [fillRule]);
+		},
+		fillRect(x, y, width, height) {
+			record("fillRect", [
+				x,
+				y,
+				width,
+				height
+			]);
+		},
+		fillText(text, x, y, maxWidth) {
+			record("fillText", maxWidth == null ? [
+				text,
+				x,
+				y
+			] : [
+				text,
+				x,
+				y,
+				maxWidth
+			]);
+		},
+		lineTo(x, y) {
+			record("lineTo", [x, y]);
+		},
+		measureText(text) {
+			return { width: text.length * state.fontSize * .5 };
+		},
+		moveTo(x, y) {
+			record("moveTo", [x, y]);
+		},
+		quadraticCurveTo(cpx, cpy, x, y) {
+			record("quadraticCurveTo", [
+				cpx,
+				cpy,
+				x,
+				y
+			]);
+		},
+		rect(x, y, width, height) {
+			record("rect", [
+				x,
+				y,
+				width,
+				height
+			]);
+		},
+		restore() {
+			state = stateStack.pop() ?? { ...defaultState };
+			record("restore", []);
+		},
+		rotate(rotate) {
+			record("rotate", [rotate]);
+		},
+		save() {
+			stateStack.push({ ...state });
+			record("save", []);
+		},
+		scale(scaleWidth, scaleHeight) {
+			record("scale", [scaleWidth, scaleHeight]);
+		},
+		setFillStyle(value) {
+			state.fillStyle = String(value);
+			record("setFillStyle", [value]);
+		},
+		setFontSize(fontSize) {
+			state.fontSize = Number(fontSize);
+			record("setFontSize", [fontSize]);
+		},
+		setGlobalAlpha(value) {
+			state.globalAlpha = Number(value);
+			record("setGlobalAlpha", [value]);
+		},
+		setLineCap(value) {
+			state.lineCap = String(value);
+			record("setLineCap", [value]);
+		},
+		setLineDash(pattern, offset) {
+			state.lineDash = pattern.map((item) => Number(item));
+			state.lineDashOffset = offset == null ? 0 : Number(offset);
+			record("setLineDash", offset == null ? [pattern.map((item) => Number(item))] : [pattern.map((item) => Number(item)), Number(offset)]);
+		},
+		setLineJoin(value) {
+			state.lineJoin = String(value);
+			record("setLineJoin", [value]);
+		},
+		setMiterLimit(value) {
+			state.miterLimit = Number(value);
+			record("setMiterLimit", [value]);
+		},
+		setLineWidth(value) {
+			state.lineWidth = Number(value);
+			record("setLineWidth", [value]);
+		},
+		setShadow(offsetX, offsetY, blur, color) {
+			state.shadowOffsetX = Number(offsetX);
+			state.shadowOffsetY = Number(offsetY);
+			state.shadowBlur = Number(blur);
+			state.shadowColor = String(color);
+			record("setShadow", [
+				offsetX,
+				offsetY,
+				blur,
+				color
+			]);
+		},
+		setStrokeStyle(value) {
+			state.strokeStyle = String(value);
+			record("setStrokeStyle", [value]);
+		},
+		setTextAlign(value) {
+			state.textAlign = String(value);
+			record("setTextAlign", [value]);
+		},
+		setTextBaseline(value) {
+			state.textBaseline = String(value);
+			record("setTextBaseline", [value]);
+		},
+		stroke() {
+			record("stroke", []);
+		},
+		strokeRect(x, y, width, height) {
+			record("strokeRect", [
+				x,
+				y,
+				width,
+				height
+			]);
+		},
+		strokeText(text, x, y, maxWidth) {
+			record("strokeText", maxWidth == null ? [
+				text,
+				x,
+				y
+			] : [
+				text,
+				x,
+				y,
+				maxWidth
+			]);
+		},
+		translate(x, y) {
+			record("translate", [x, y]);
+		}
+	};
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/intersectionObserver.ts
+const NUMERIC_LIKE_VALUE_RE = /-?\d+(?:\.\d+)?/;
+function normalizeMargins(margins) {
+	return {
+		bottom: Number(margins?.bottom) || 0,
+		left: Number(margins?.left) || 0,
+		right: Number(margins?.right) || 0,
+		top: Number(margins?.top) || 0
+	};
+}
+function parseStyleDeclarations(styleValue) {
+	const declarations = {};
+	if (!styleValue) return declarations;
+	for (const declaration of styleValue.split(";")) {
+		const [rawProperty, ...rawValueParts] = declaration.split(":");
+		const property = rawProperty?.trim();
+		if (!property) continue;
+		declarations[property] = rawValueParts.join(":").trim();
+	}
+	return declarations;
+}
+function parseNumericLikeValue(value) {
+	if (!value) return 0;
+	const match = value.match(NUMERIC_LIKE_VALUE_RE);
+	return match ? Number(match[0]) : 0;
+}
+function resolveRect(node) {
+	const style = parseStyleDeclarations(node.attribs?.style);
+	const left = parseNumericLikeValue(node.attribs?.["data-sim-left"] ?? style.left);
+	const top = parseNumericLikeValue(node.attribs?.["data-sim-top"] ?? style.top);
+	const width = parseNumericLikeValue(node.attribs?.["data-sim-width"] ?? style.width);
+	const height = parseNumericLikeValue(node.attribs?.["data-sim-height"] ?? style.height);
+	return {
+		bottom: top + height,
+		height,
+		left,
+		right: left + width,
+		top,
+		width
+	};
+}
+function applyMargins(rect, margins) {
+	const top = rect.top - (margins.top ?? 0);
+	const left = rect.left - (margins.left ?? 0);
+	const right = rect.right + (margins.right ?? 0);
+	const bottom = rect.bottom + (margins.bottom ?? 0);
+	return {
+		bottom,
+		height: Math.max(0, bottom - top),
+		left,
+		right,
+		top,
+		width: Math.max(0, right - left)
+	};
+}
+function intersectRects(source, target) {
+	const left = Math.max(source.left, target.left);
+	const top = Math.max(source.top, target.top);
+	const right = Math.min(source.right, target.right);
+	const bottom = Math.min(source.bottom, target.bottom);
+	if (right <= left || bottom <= top) return {
+		bottom: top,
+		height: 0,
+		left,
+		right: left,
+		top,
+		width: 0
+	};
+	return {
+		bottom,
+		height: bottom - top,
+		left,
+		right,
+		top,
+		width: right - left
+	};
+}
+function resolveViewportRect(windowInfo) {
+	return {
+		bottom: windowInfo.windowHeight,
+		height: windowInfo.windowHeight,
+		left: 0,
+		right: windowInfo.windowWidth,
+		top: 0,
+		width: windowInfo.windowWidth
+	};
+}
+function createHeadlessIntersectionObserver(driver, scope, _options) {
+	let active = true;
+	let relativeTarget = {
+		kind: "viewport",
+		margins: normalizeMargins()
+	};
+	const resolveScopedRoot = () => {
+		const scopeResolution = driver.resolveScope(scope);
+		if (scopeResolution.kind === "missing") return null;
+		const rendered = driver.renderCurrentPage();
+		return scopeResolution.kind === "component" ? resolveSelectorQueryScopeRoot(rendered.root, scopeResolution.scopeId) : rendered.root;
+	};
+	const resolveTargetNode = (selector) => {
+		const scopedRoot = resolveScopedRoot();
+		if (!scopedRoot) return null;
+		return querySelectorAll(scopedRoot, selector)[0] ?? null;
+	};
+	const resolveRelativeRect = () => {
+		if (relativeTarget.kind === "viewport") return applyMargins(resolveViewportRect(driver.getWindowInfo()), relativeTarget.margins);
+		const relativeNode = resolveTargetNode(relativeTarget.selector);
+		if (!relativeNode) return null;
+		return applyMargins(resolveRect(relativeNode), relativeTarget.margins);
+	};
+	return {
+		disconnect() {
+			active = false;
+		},
+		observe(selector, callback) {
+			if (!active) return;
+			const targetNode = resolveTargetNode(selector);
+			const relativeRect = resolveRelativeRect();
+			if (!targetNode || !relativeRect) return;
+			const boundingClientRect = resolveRect(targetNode);
+			const intersectionRect = intersectRects(boundingClientRect, relativeRect);
+			const targetArea = boundingClientRect.width * boundingClientRect.height;
+			const intersectionArea = intersectionRect.width * intersectionRect.height;
+			callback({
+				boundingClientRect,
+				id: targetNode.attribs?.id ?? "",
+				intersectionRatio: targetArea > 0 ? intersectionArea / targetArea : 0,
+				intersectionRect,
+				relativeRect
+			});
+		},
+		relativeTo(selector, margins) {
+			relativeTarget = {
+				kind: "selector",
+				margins: normalizeMargins(margins),
+				selector
+			};
+			return this;
+		},
+		relativeToViewport(margins) {
+			relativeTarget = {
+				kind: "viewport",
+				margins: normalizeMargins(margins)
+			};
+			return this;
+		}
+	};
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/mediaQueryObserver.ts
+function resolveOrientation(windowInfo) {
+	return windowInfo.windowWidth >= windowInfo.windowHeight ? "landscape" : "portrait";
+}
+function resolveMatches(descriptor, windowInfo) {
+	if (descriptor.width != null && windowInfo.windowWidth !== descriptor.width) return false;
+	if (descriptor.minWidth != null && windowInfo.windowWidth < descriptor.minWidth) return false;
+	if (descriptor.maxWidth != null && windowInfo.windowWidth > descriptor.maxWidth) return false;
+	if (descriptor.height != null && windowInfo.windowHeight !== descriptor.height) return false;
+	if (descriptor.minHeight != null && windowInfo.windowHeight < descriptor.minHeight) return false;
+	if (descriptor.maxHeight != null && windowInfo.windowHeight > descriptor.maxHeight) return false;
+	if (descriptor.orientation != null && resolveOrientation(windowInfo) !== descriptor.orientation) return false;
+	return true;
+}
+function createHeadlessMediaQueryObserver(driver, onDisconnect) {
+	let active = true;
+	let callback;
+	let descriptor;
+	let hasObserved = false;
+	let lastMatches;
+	const emit = (force) => {
+		if (!active || !hasObserved || !callback || !descriptor) return;
+		const matches = resolveMatches(descriptor, driver.getWindowInfo());
+		if (!force && lastMatches === matches) return;
+		lastMatches = matches;
+		callback({ matches });
+	};
+	const observer = {
+		disconnect() {
+			if (!active) return;
+			active = false;
+			hasObserved = false;
+			callback = void 0;
+			descriptor = void 0;
+			onDisconnect?.();
+		},
+		observe(nextDescriptor, nextCallback) {
+			if (!active) return;
+			descriptor = { ...nextDescriptor };
+			callback = nextCallback;
+			hasObserved = true;
+			emit(true);
+		}
+	};
+	return {
+		disconnect: observer.disconnect,
+		notify() {
+			emit(false);
+		},
+		observer
+	};
+}
+//#endregion
+//#region ../../mpcore/packages/simulator/src/view/videoContext.ts
+const DATASET_NAME_RE = /-([a-z])/g;
+function toDatasetKey(attributeName) {
+	return attributeName.slice(5).replace(DATASET_NAME_RE, (_match, char) => char.toUpperCase());
+}
+function collectDataset(node) {
+	const dataset = {};
+	for (const [key, value] of Object.entries(node.attribs ?? {})) {
+		if (!key.startsWith("data-") || key.startsWith("data-sim-")) continue;
+		dataset[toDatasetKey(key)] = value;
+	}
+	return dataset;
+}
+function resolveEventBinding(node, eventName) {
+	const normalizedEventName = eventName.trim();
+	if (!normalizedEventName) return null;
+	const bindingAttrs = [
+		`bind${normalizedEventName}`,
+		`bind:${normalizedEventName}`,
+		`catch${normalizedEventName}`,
+		`catch:${normalizedEventName}`
+	];
+	for (const attributeName of bindingAttrs) {
+		const methodName = node.attribs?.[attributeName]?.trim();
+		if (methodName) return methodName;
+	}
+	return null;
+}
+function createEventPayload(node, eventName, detail) {
+	const dataset = collectDataset(node);
+	const nodeId = node.attribs?.id ?? "";
+	return {
+		bubbles: false,
+		capturePhase: false,
+		composed: false,
+		currentTarget: {
+			dataset,
+			id: nodeId
+		},
+		detail,
+		mark: void 0,
+		target: {
+			dataset,
+			id: nodeId
+		},
+		type: eventName
+	};
+}
+function createHeadlessVideoContext(driver, videoId, scope) {
+	const state = {
+		currentTime: 0,
+		fullScreen: false,
+		paused: true
+	};
+	const resolveNode = () => {
+		const scopeResolution = driver.resolveScope(scope);
+		if (scopeResolution.kind === "missing") return null;
+		const rendered = driver.renderCurrentPage();
+		return querySelectorAll(scopeResolution.kind === "component" ? resolveSelectorQueryScopeRoot(rendered.root, scopeResolution.scopeId) : rendered.root, `#${videoId}`)[0] ?? null;
+	};
+	const dispatch = (eventName, detail) => {
+		const node = resolveNode();
+		if (!node) return;
+		const methodName = resolveEventBinding(node, eventName);
+		if (!methodName) return;
+		driver.callScopeMethod(node.attribs?.["data-sim-scope"] ?? null, methodName, createEventPayload(node, eventName, detail));
+	};
+	return {
+		exitFullScreen() {
+			state.fullScreen = false;
+			dispatch("fullscreenchange", {
+				currentTime: state.currentTime,
+				fullScreen: false
+			});
+		},
+		pause() {
+			state.paused = true;
+			dispatch("pause", { currentTime: state.currentTime });
+		},
+		play() {
+			state.paused = false;
+			dispatch("play", { currentTime: state.currentTime });
+		},
+		requestFullScreen() {
+			state.fullScreen = true;
+			dispatch("fullscreenchange", {
+				currentTime: state.currentTime,
+				fullScreen: true
+			});
+		},
+		seek(position) {
+			state.currentTime = Number.isFinite(position) ? Number(position) : 0;
+		},
+		stop() {
+			state.currentTime = 0;
+			state.paused = true;
+			dispatch("pause", { currentTime: state.currentTime });
+		}
+	};
+}
+//#endregion
 //#region ../../mpcore/packages/simulator/src/runtime/moduleLoader.ts
 function createRequireNotFoundError(request, importer) {
 	return /* @__PURE__ */ new Error(`Cannot resolve require("${request}") from ${normalize(importer)} in headless runtime.`);
@@ -4387,9 +5235,228 @@ const DEFAULT_MODAL_CONFIRM_TEXT = "确定";
 const TRAILING_SLASH_RE = /\/+$/;
 const SAVED_FILE_PREFIXES = ["headless://saved/", "headless://wxfile/saved/"];
 const textEncoder = new TextEncoder();
+const IMAGE_EXTENSION_RE = /\.([^.?#/]+)(?:[?#].*)?$/;
+const LEADING_DOT_RE = /^\.+/;
+const IMAGE_FILE_EXTENSIONS = new Set([
+	"bmp",
+	"gif",
+	"heic",
+	"jpeg",
+	"jpg",
+	"png",
+	"webp"
+]);
+const VIDEO_FILE_EXTENSIONS = new Set([
+	"avi",
+	"m4v",
+	"mov",
+	"mp4",
+	"mpeg",
+	"mpg",
+	"webm"
+]);
 function byteLength(input) {
 	return textEncoder.encode(input).byteLength;
 }
+function rotateLeft(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function toHexWordLittleEndian(value) {
+	let output = "";
+	for (let index = 0; index < 4; index += 1) output += (value >>> index * 8 & 255).toString(16).padStart(2, "0");
+	return output;
+}
+function toHexWordBigEndian(value) {
+	return value.toString(16).padStart(8, "0");
+}
+function computeMd5Digest(input) {
+	const bytes = Array.from(textEncoder.encode(input));
+	const bitLength = bytes.length * 8;
+	const lowBits = bitLength >>> 0;
+	const highBits = Math.floor(bitLength / 4294967296) >>> 0;
+	bytes.push(128);
+	while (bytes.length % 64 !== 56) bytes.push(0);
+	for (let index = 0; index < 4; index += 1) bytes.push(lowBits >>> index * 8 & 255);
+	for (let index = 0; index < 4; index += 1) bytes.push(highBits >>> index * 8 & 255);
+	const shifts = [
+		7,
+		12,
+		17,
+		22,
+		7,
+		12,
+		17,
+		22,
+		7,
+		12,
+		17,
+		22,
+		7,
+		12,
+		17,
+		22,
+		5,
+		9,
+		14,
+		20,
+		5,
+		9,
+		14,
+		20,
+		5,
+		9,
+		14,
+		20,
+		5,
+		9,
+		14,
+		20,
+		4,
+		11,
+		16,
+		23,
+		4,
+		11,
+		16,
+		23,
+		4,
+		11,
+		16,
+		23,
+		4,
+		11,
+		16,
+		23,
+		6,
+		10,
+		15,
+		21,
+		6,
+		10,
+		15,
+		21,
+		6,
+		10,
+		15,
+		21,
+		6,
+		10,
+		15,
+		21
+	];
+	const table = Array.from({ length: 64 }, (_, index) => Math.floor(Math.abs(Math.sin(index + 1)) * 4294967296) >>> 0);
+	let a0 = 1732584193;
+	let b0 = 4023233417;
+	let c0 = 2562383102;
+	let d0 = 271733878;
+	for (let chunkOffset = 0; chunkOffset < bytes.length; chunkOffset += 64) {
+		const words = Array.from({ length: 16 }, (_, index) => {
+			const wordOffset = chunkOffset + index * 4;
+			return (bytes[wordOffset] | bytes[wordOffset + 1] << 8 | bytes[wordOffset + 2] << 16 | bytes[wordOffset + 3] << 24) >>> 0;
+		});
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		for (let index = 0; index < 64; index += 1) {
+			let f = 0;
+			let g = 0;
+			if (index < 16) {
+				f = (b & c | ~b & d) >>> 0;
+				g = index;
+			} else if (index < 32) {
+				f = (d & b | ~d & c) >>> 0;
+				g = (5 * index + 1) % 16;
+			} else if (index < 48) {
+				f = (b ^ c ^ d) >>> 0;
+				g = (3 * index + 5) % 16;
+			} else {
+				f = (c ^ (b | ~d)) >>> 0;
+				g = 7 * index % 16;
+			}
+			const next = a + f + table[index] + words[g] >>> 0;
+			a = d;
+			d = c;
+			c = b;
+			b = b + rotateLeft(next, shifts[index]) >>> 0;
+		}
+		a0 = a0 + a >>> 0;
+		b0 = b0 + b >>> 0;
+		c0 = c0 + c >>> 0;
+		d0 = d0 + d >>> 0;
+	}
+	return [
+		toHexWordLittleEndian(a0),
+		toHexWordLittleEndian(b0),
+		toHexWordLittleEndian(c0),
+		toHexWordLittleEndian(d0)
+	].join("");
+}
+function computeSha1Digest(input) {
+	const bytes = Array.from(textEncoder.encode(input));
+	const bitLength = bytes.length * 8;
+	const lowBits = bitLength >>> 0;
+	const highBits = Math.floor(bitLength / 4294967296) >>> 0;
+	bytes.push(128);
+	while (bytes.length % 64 !== 56) bytes.push(0);
+	for (let index = 3; index >= 0; index -= 1) bytes.push(highBits >>> index * 8 & 255);
+	for (let index = 3; index >= 0; index -= 1) bytes.push(lowBits >>> index * 8 & 255);
+	let h0 = 1732584193;
+	let h1 = 4023233417;
+	let h2 = 2562383102;
+	let h3 = 271733878;
+	let h4 = 3285377520;
+	for (let chunkOffset = 0; chunkOffset < bytes.length; chunkOffset += 64) {
+		const words = Array.from({ length: 80 }, (_, index) => {
+			if (index < 16) {
+				const wordOffset = chunkOffset + index * 4;
+				return (bytes[wordOffset] << 24 | bytes[wordOffset + 1] << 16 | bytes[wordOffset + 2] << 8 | bytes[wordOffset + 3]) >>> 0;
+			}
+			return 0;
+		});
+		for (let index = 16; index < 80; index += 1) words[index] = rotateLeft(words[index - 3] ^ words[index - 8] ^ words[index - 14] ^ words[index - 16], 1);
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		for (let index = 0; index < 80; index += 1) {
+			let f = 0;
+			let k = 0;
+			if (index < 20) {
+				f = (b & c | ~b & d) >>> 0;
+				k = 1518500249;
+			} else if (index < 40) {
+				f = (b ^ c ^ d) >>> 0;
+				k = 1859775393;
+			} else if (index < 60) {
+				f = (b & c | b & d | c & d) >>> 0;
+				k = 2400959708;
+			} else {
+				f = (b ^ c ^ d) >>> 0;
+				k = 3395469782;
+			}
+			const next = rotateLeft(a, 5) + f + e + k + words[index] >>> 0;
+			e = d;
+			d = c;
+			c = rotateLeft(b, 30);
+			b = a;
+			a = next;
+		}
+		h0 = h0 + a >>> 0;
+		h1 = h1 + b >>> 0;
+		h2 = h2 + c >>> 0;
+		h3 = h3 + d >>> 0;
+		h4 = h4 + e >>> 0;
+	}
+	return [
+		toHexWordBigEndian(h0),
+		toHexWordBigEndian(h1),
+		toHexWordBigEndian(h2),
+		toHexWordBigEndian(h3),
+		toHexWordBigEndian(h4)
+	].join("");
+}
 function cloneShareMenuSnapshot(snapshot) {
 	return {
 		isUpdatableMessage: snapshot.isUpdatableMessage,
@@ -4398,6 +5465,116 @@ function cloneShareMenuSnapshot(snapshot) {
 		withShareTicket: snapshot.withShareTicket
 	};
 }
+function normalizeImageType(type) {
+	const normalized = (type ?? "").trim().toLowerCase();
+	if (normalized === "jpg") return "jpeg";
+	return normalized;
+}
+function normalizeFileExtension(extension) {
+	return extension.trim().replace(LEADING_DOT_RE, "").toLowerCase();
+}
+function inferDocumentFileType(filePath) {
+	const extensionMatch = filePath.match(IMAGE_EXTENSION_RE);
+	return extensionMatch ? normalizeFileExtension(extensionMatch[1]) : "unknown";
+}
+function isImageFileExtension(extension) {
+	return IMAGE_FILE_EXTENSIONS.has(normalizeFileExtension(extension));
+}
+function isVideoFileExtension(extension) {
+	return VIDEO_FILE_EXTENSIONS.has(normalizeFileExtension(extension));
+}
+function resolveMessageFileExtensions(option) {
+	const filteredExtensions = (Array.isArray(option.extension) ? option.extension.filter((item) => typeof item === "string").map(normalizeFileExtension).filter(Boolean) : []).filter((extension) => {
+		if (option.type === "image") return isImageFileExtension(extension);
+		if (option.type === "video") return isVideoFileExtension(extension);
+		if (option.type === "file") return !isImageFileExtension(extension) && !isVideoFileExtension(extension);
+		return true;
+	});
+	if (filteredExtensions.length > 0) return filteredExtensions;
+	if (option.type === "image") return ["png", "jpg"];
+	if (option.type === "video") return ["mp4"];
+	if (option.type === "file") return [
+		"txt",
+		"pdf",
+		"doc"
+	];
+	return [
+		"png",
+		"pdf",
+		"mp4"
+	];
+}
+function inferImageType(filePath, fileContent) {
+	const extensionMatch = filePath.match(IMAGE_EXTENSION_RE);
+	if (extensionMatch) return normalizeImageType(extensionMatch[1]);
+	try {
+		return normalizeImageType(JSON.parse(fileContent)?.config?.fileType) || "png";
+	} catch {
+		return "unknown";
+	}
+}
+function inferImageSize(fileContent) {
+	try {
+		const payload = JSON.parse(fileContent);
+		return {
+			height: payload?.config?.destHeight ?? payload?.config?.height ?? 0,
+			width: payload?.config?.destWidth ?? payload?.config?.width ?? 0
+		};
+	} catch {
+		return {
+			height: 0,
+			width: 0
+		};
+	}
+}
+function buildImageTempFilePayload(fileType, width, height, metadata = {}) {
+	return JSON.stringify({ config: {
+		fileType,
+		height,
+		quality: metadata.quality,
+		sizeType: metadata.sizeType ?? [],
+		sourceType: metadata.sourceType ?? [],
+		width
+	} });
+}
+function buildVideoTempFilePayload(width, height, duration, metadata = {}) {
+	return JSON.stringify({ config: {
+		bitrate: metadata.bitrate ?? 1500,
+		compressed: metadata.compressed ?? true,
+		duration,
+		fps: metadata.fps ?? 30,
+		height,
+		maxDuration: metadata.maxDuration ?? duration,
+		sourceType: metadata.sourceType ?? [],
+		width
+	} });
+}
+function inferVideoInfo(filePath, fileContent) {
+	const size = byteLength(fileContent);
+	const type = filePath.match(IMAGE_EXTENSION_RE)?.[1]?.toLowerCase() ?? "mp4";
+	try {
+		const payload = JSON.parse(fileContent);
+		return {
+			bitrate: payload.config.bitrate ?? 1500,
+			duration: payload.config.duration ?? 0,
+			fps: payload.config.fps ?? 30,
+			height: payload.config.height ?? 0,
+			size,
+			type,
+			width: payload.config.width ?? 0
+		};
+	} catch {
+		return {
+			bitrate: 1500,
+			duration: 0,
+			fps: 30,
+			height: 0,
+			size,
+			type,
+			width: 0
+		};
+	}
+}
 function createNetworkSnapshot(networkType) {
 	return {
 		isConnected: networkType !== "none",
@@ -4548,6 +5725,9 @@ function createHeadlessWxState() {
 	let fileId = 0;
 	let loading = null;
 	let networkType = "wifi";
+	let previewImage = null;
+	let openedDocument = null;
+	let clipboardData = "";
 	let shareMenu = {
 		isUpdatableMessage: false,
 		menus: [],
@@ -4749,6 +5929,16 @@ function createHeadlessWxState() {
 			size: savedFile.size
 		};
 	};
+	const getFileInfo = (option) => {
+		const normalizedPath = normalizeFsPath(option.filePath);
+		const fileContent = files.get(normalizedPath);
+		if (fileContent == null) throw new Error(`getFileInfo:fail no such file or directory, stat '${normalizedPath}'`);
+		return {
+			digest: (option.digestAlgorithm === "sha1" ? "sha1" : "md5") === "sha1" ? computeSha1Digest(fileContent) : computeMd5Digest(fileContent),
+			errMsg: "getFileInfo:ok",
+			size: byteLength(fileContent)
+		};
+	};
 	const removeSavedFile = (filePath) => {
 		const normalizedPath = normalizeFsPath(filePath);
 		if (!savedFiles.has(normalizedPath)) throw new Error(`removeSavedFile:fail no such file or directory, unlink '${normalizedPath}'`);
@@ -4999,18 +6189,191 @@ function createHeadlessWxState() {
 		getSavedFileInfo(option) {
 			return getSavedFileInfo(option.filePath);
 		},
+		getFileInfo(option) {
+			return getFileInfo(option);
+		},
 		getSavedFileList() {
 			return getSavedFileList();
 		},
 		getFileText(filePath) {
 			return files.get(filePath) ?? null;
 		},
+		createTempFile(fileContent, preferredPath) {
+			const tempFilePath = allocateFilePath("temp", preferredPath);
+			ensureDirectoryTree(tempFilePath);
+			files.set(tempFilePath, String(fileContent));
+			return tempFilePath;
+		},
+		chooseImage(option) {
+			const count = Number.isFinite(option.count) ? Math.max(1, Math.min(9, Math.trunc(option.count ?? 1))) : 9;
+			const sizeType = Array.isArray(option.sizeType) && option.sizeType.length > 0 ? option.sizeType.filter((item) => typeof item === "string") : ["original"];
+			const sourceType = Array.isArray(option.sourceType) && option.sourceType.length > 0 ? option.sourceType.filter((item) => typeof item === "string") : ["album", "camera"];
+			const fileType = sizeType.includes("compressed") ? "jpg" : "png";
+			const tempFiles = Array.from({ length: count }, (_, index) => {
+				const payload = buildImageTempFilePayload(fileType, 160 + index * 12, 120 + index * 8, {
+					sizeType: [...sizeType],
+					sourceType: [...sourceType]
+				});
+				return {
+					path: this.createTempFile(payload, `headless://wxfile/temp/chosen-image-${String(index + 1).padStart(2, "0")}.${fileType}`),
+					size: payload.length
+				};
+			});
+			return {
+				errMsg: "chooseImage:ok",
+				tempFilePaths: tempFiles.map((item) => item.path),
+				tempFiles
+			};
+		},
+		chooseMessageFile(option) {
+			const count = Number.isFinite(option.count) ? Math.max(1, Math.min(100, Math.trunc(option.count ?? 1))) : 1;
+			const extensions = resolveMessageFileExtensions(option);
+			return {
+				errMsg: "chooseMessageFile:ok",
+				tempFiles: Array.from({ length: count }, (_, index) => {
+					const extension = extensions[index % extensions.length];
+					const sequence = String(index + 1).padStart(2, "0");
+					const fileName = `message-file-${sequence}.${extension}`;
+					let fileContent = `headless message file ${fileName}`;
+					if (isImageFileExtension(extension)) fileContent = buildImageTempFilePayload(extension, 160 + index * 12, 120 + index * 8, { sourceType: ["message"] });
+					else if (isVideoFileExtension(extension)) fileContent = buildVideoTempFilePayload(640, 360, 18 + index, {
+						compressed: true,
+						sourceType: ["message"]
+					});
+					return {
+						name: fileName,
+						path: this.createTempFile(fileContent, `headless://wxfile/temp/chosen-message-file-${sequence}.${extension}`),
+						size: byteLength(fileContent),
+						time: 171e10 + index * 1e3,
+						type: extension
+					};
+				})
+			};
+		},
+		chooseMedia(option) {
+			const count = Number.isFinite(option.count) ? Math.max(1, Math.min(9, Math.trunc(option.count ?? 1))) : 1;
+			const mediaTypes = Array.isArray(option.mediaType) && option.mediaType.length > 0 ? option.mediaType.filter((item) => item === "image" || item === "video") : ["image"];
+			const sourceType = Array.isArray(option.sourceType) && option.sourceType.length > 0 ? option.sourceType.filter((item) => typeof item === "string") : ["album", "camera"];
+			const sizeType = Array.isArray(option.sizeType) && option.sizeType.length > 0 ? option.sizeType.filter((item) => typeof item === "string") : ["compressed"];
+			const maxDuration = Number.isFinite(option.maxDuration) ? Math.max(1, Math.trunc(option.maxDuration ?? 60)) : 60;
+			return {
+				errMsg: "chooseMedia:ok",
+				tempFiles: Array.from({ length: count }, (_, index) => {
+					if (mediaTypes[index % mediaTypes.length] === "video") {
+						const duration = Math.min(maxDuration, 18 + index);
+						const width = 640;
+						const height = 360;
+						const payload = buildVideoTempFilePayload(width, height, duration, {
+							compressed: sizeType.includes("compressed"),
+							maxDuration,
+							sourceType: [...sourceType]
+						});
+						const tempFilePath = this.createTempFile(payload, `headless://wxfile/temp/chosen-media-video-${String(index + 1).padStart(2, "0")}.mp4`);
+						const thumbPayload = buildImageTempFilePayload("jpg", 160, 90, {
+							sizeType: ["compressed"],
+							sourceType: [...sourceType]
+						});
+						const thumbTempFilePath = this.createTempFile(thumbPayload, `headless://wxfile/temp/chosen-media-video-thumb-${String(index + 1).padStart(2, "0")}.jpg`);
+						return {
+							duration,
+							fileType: "video",
+							height,
+							size: payload.length,
+							tempFilePath,
+							thumbTempFilePath,
+							width
+						};
+					}
+					const width = 160 + index * 12;
+					const height = 120 + index * 8;
+					const fileType = sizeType.includes("compressed") ? "jpg" : "png";
+					const payload = buildImageTempFilePayload(fileType, width, height, {
+						sizeType: [...sizeType],
+						sourceType: [...sourceType]
+					});
+					return {
+						fileType: "image",
+						height,
+						size: payload.length,
+						tempFilePath: this.createTempFile(payload, `headless://wxfile/temp/chosen-media-image-${String(index + 1).padStart(2, "0")}.${fileType}`),
+						width
+					};
+				}),
+				type: mediaTypes.length > 1 ? "mix" : mediaTypes[0]
+			};
+		},
+		chooseVideo(option) {
+			const compressed = option.compressed !== false;
+			const maxDuration = Number.isFinite(option.maxDuration) ? Math.max(1, Math.trunc(option.maxDuration ?? 60)) : 60;
+			const sourceType = Array.isArray(option.sourceType) && option.sourceType.length > 0 ? option.sourceType.filter((item) => typeof item === "string") : ["album", "camera"];
+			const payload = JSON.stringify({ config: {
+				compressed,
+				duration: Math.min(maxDuration, compressed ? 18 : 36),
+				height: compressed ? 360 : 720,
+				maxDuration,
+				sourceType: [...sourceType],
+				width: compressed ? 640 : 1280
+			} });
+			const tempFilePath = this.createTempFile(payload, "headless://wxfile/temp/chosen-video-01.mp4");
+			return {
+				duration: Math.min(maxDuration, compressed ? 18 : 36),
+				errMsg: "chooseVideo:ok",
+				height: compressed ? 360 : 720,
+				size: payload.length,
+				tempFilePath,
+				width: compressed ? 640 : 1280
+			};
+		},
+		compressImage(option) {
+			const fileContent = files.get(option.src);
+			if (fileContent == null) throw new Error(`compressImage:fail file not found: ${option.src}`);
+			const sourceSize = inferImageSize(fileContent);
+			const sourceType = inferImageType(option.src, fileContent);
+			const width = Number.isFinite(option.compressedWidth) ? Math.max(1, Math.trunc(option.compressedWidth ?? sourceSize.width)) : Math.max(1, sourceSize.width);
+			const height = Number.isFinite(option.compressedHeight) ? Math.max(1, Math.trunc(option.compressedHeight ?? sourceSize.height)) : Math.max(1, sourceSize.height);
+			const normalizedType = sourceType === "unknown" ? "jpg" : sourceType;
+			const fileExtension = normalizedType === "jpeg" ? "jpg" : normalizedType;
+			const payload = buildImageTempFilePayload(normalizedType, width, height, { quality: Number.isFinite(option.quality) ? Number(option.quality) : void 0 });
+			return {
+				errMsg: "compressImage:ok",
+				tempFilePath: this.createTempFile(payload, `headless://wxfile/temp/compressed-image-${String(fileId + 1).padStart(2, "0")}.${fileExtension}`)
+			};
+		},
 		getNetworkType() {
 			return {
 				errMsg: "getNetworkType:ok",
 				networkType
 			};
 		},
+		getImageInfo(option) {
+			const fileContent = files.get(option.src);
+			if (fileContent == null) throw new Error(`getImageInfo:fail file not found: ${option.src}`);
+			const size = inferImageSize(fileContent);
+			return {
+				errMsg: "getImageInfo:ok",
+				height: size.height,
+				orientation: "up",
+				path: option.src,
+				type: inferImageType(option.src, fileContent),
+				width: size.width
+			};
+		},
+		getVideoInfo(option) {
+			const fileContent = files.get(option.src);
+			if (fileContent == null) throw new Error(`getVideoInfo:fail file not found: ${option.src}`);
+			const info = inferVideoInfo(option.src, fileContent);
+			return {
+				bitrate: info.bitrate,
+				duration: info.duration,
+				errMsg: "getVideoInfo:ok",
+				fps: info.fps,
+				height: info.height,
+				orientation: "up",
+				size: info.size,
+				type: info.type,
+				width: info.width
+			};
+		},
 		getModalLogs() {
 			return modalLogs.map((entry) => ({
 				...entry,
@@ -5045,6 +6408,15 @@ function createHeadlessWxState() {
 		getStorageSnapshot() {
 			return Object.fromEntries(Array.from(storage.entries(), ([key, value]) => [key, cloneValue(value)]));
 		},
+		getClipboardData() {
+			return {
+				data: clipboardData,
+				errMsg: "getClipboardData:ok"
+			};
+		},
+		getClipboardSnapshot() {
+			return { data: clipboardData };
+		},
 		getStorageSync(key) {
 			return cloneValue(storage.get(key));
 		},
@@ -5054,6 +6426,21 @@ function createHeadlessWxState() {
 		getLoading() {
 			return loading ? { ...loading } : null;
 		},
+		getPreviewImage() {
+			return previewImage ? {
+				current: previewImage.current,
+				urls: [...previewImage.urls],
+				visible: previewImage.visible
+			} : null;
+		},
+		getOpenedDocument() {
+			return openedDocument ? {
+				filePath: openedDocument.filePath,
+				fileType: openedDocument.fileType,
+				showMenu: openedDocument.showMenu,
+				visible: openedDocument.visible
+			} : null;
+		},
 		hideShareMenu() {
 			shareMenu = {
 				...shareMenu,
@@ -5123,6 +6510,27 @@ function createHeadlessWxState() {
 		onNetworkStatusChange(callback) {
 			networkStatusChangeCallbacks.add(callback);
 		},
+		openDocument(option) {
+			const normalizedPath = normalizeFsPath(option.filePath);
+			if (!files.has(normalizedPath)) throw new Error(`openDocument:fail no such file or directory, open '${normalizedPath}'`);
+			openedDocument = {
+				filePath: normalizedPath,
+				fileType: typeof option.fileType === "string" && option.fileType.trim() !== "" ? normalizeFileExtension(option.fileType) : inferDocumentFileType(normalizedPath),
+				showMenu: option.showMenu !== false,
+				visible: true
+			};
+			return { errMsg: "openDocument:ok" };
+		},
+		previewImage(option) {
+			const urls = Array.isArray(option.urls) ? option.urls.filter((item) => typeof item === "string" && item.trim() !== "") : [];
+			if (urls.length === 0) throw new Error("previewImage:fail invalid urls");
+			previewImage = {
+				current: typeof option.current === "string" && option.current.trim() !== "" ? option.current : urls[0],
+				urls: [...urls],
+				visible: true
+			};
+			return { errMsg: "previewImage:ok" };
+		},
 		removeStorageSync(key) {
 			storage.delete(key);
 		},
@@ -5170,6 +6578,14 @@ function createHeadlessWxState() {
 		removeSavedFile(option) {
 			return removeSavedFile(option.filePath);
 		},
+		saveImageToPhotosAlbum(option) {
+			if (files.get(option.filePath) == null) throw new Error(`saveImageToPhotosAlbum:fail file not found: ${option.filePath}`);
+			return { errMsg: "saveImageToPhotosAlbum:ok" };
+		},
+		saveVideoToPhotosAlbum(option) {
+			if (files.get(option.filePath) == null) throw new Error(`saveVideoToPhotosAlbum:fail file not found: ${option.filePath}`);
+			return { errMsg: "saveVideoToPhotosAlbum:ok" };
+		},
 		saveFile(option) {
 			const fileContent = files.get(option.tempFilePath);
 			if (fileContent == null) throw new Error(`saveFile:fail tempFilePath not found: ${option.tempFilePath}`);
@@ -5185,6 +6601,10 @@ function createHeadlessWxState() {
 		setStorageSync(key, value) {
 			storage.set(key, cloneValue(value));
 		},
+		setClipboardData(option) {
+			clipboardData = String(option.data);
+			return { errMsg: "setClipboardData:ok" };
+		},
 		setFile(filePath, fileContent) {
 			const normalizedPath = normalizeFsPath(filePath);
 			ensureDirectoryTree(normalizedPath);
@@ -5330,7 +6750,9 @@ function createHeadlessWxState() {
 //#region ../../mpcore/packages/simulator/src/runtime/session.ts
 const LEADING_SLASH_RE$1 = /^\/+/;
 const PAGE_STACK_LIMIT = 10;
+const WHITESPACE_RE = /\s+/;
 const DATA_ATTR_SELECTOR_RE = /^\[data-([^=\]]+)="([^"]*)"\]$/;
+const COMPOUND_SELECTOR_PART_RE = /#[\w-]+|\.[\w-]+|\[data-[^=\]]+="[^"]*"\]|[A-Za-z][\w-]*/g;
 const DATASET_KEY_RE = /-([a-z])/g;
 function stripLeadingSlash(route) {
 	return route.replace(LEADING_SLASH_RE$1, "");
@@ -5351,6 +6773,28 @@ function parseNavigationUrl(url) {
 		query: normalizeQuery(queryString)
 	};
 }
+function parseCompoundSelector(selector) {
+	const parts = selector.match(COMPOUND_SELECTOR_PART_RE) ?? [];
+	return parts.join("") === selector ? parts : [];
+}
+function matchesComponentSelector(scope, selector) {
+	const parts = parseCompoundSelector(selector);
+	if (parts.length === 0) return false;
+	return parts.every((part) => {
+		if (part.startsWith("#")) return scope.id === part.slice(1);
+		if (part.startsWith(".")) return scope.classList?.includes(part.slice(1)) ?? false;
+		const dataAttrMatch = part.match(DATA_ATTR_SELECTOR_RE);
+		if (dataAttrMatch) {
+			const [, key, value] = dataAttrMatch;
+			const datasetKey = key.replace(DATASET_KEY_RE, (_match, char) => char.toUpperCase());
+			return scope.dataset?.[datasetKey] === value;
+		}
+		return scope.alias === part;
+	});
+}
+function normalizeSelectorParts(selector) {
+	return selector.trim().split(WHITESPACE_RE).filter(Boolean);
+}
 function createAppLaunchOptions(pathname, query) {
 	return {
 		path: stripLeadingSlash(pathname),
@@ -5392,6 +6836,8 @@ var HeadlessSession = class {
 	tabBarState = /* @__PURE__ */ new Map();
 	tabBarVisible = false;
 	systemInfo = createDefaultSystemInfo();
+	mediaQueryObservers = /* @__PURE__ */ new Set();
+	canvasContexts = /* @__PURE__ */ new Map();
 	enterOptions = createAppLaunchOptions("", {});
 	launchOptions = createAppLaunchOptions("", {});
 	wxState = createHeadlessWxState();
@@ -5424,7 +6870,20 @@ var HeadlessSession = class {
 		});
 		this.tabBarVisible = this.tabBarRoutes.size > 0;
 		this.moduleLoader = createModuleLoader(this.registries, () => this.pages.slice(), () => this.getApp(), {
+			chooseImage: (option) => this.wxState.chooseImage(option ?? {}),
+			chooseMessageFile: (option) => this.wxState.chooseMessageFile(option ?? {}),
+			chooseMedia: (option) => this.wxState.chooseMedia(option ?? {}),
+			chooseVideo: (option) => this.wxState.chooseVideo(option ?? {}),
+			compressImage: (option) => this.wxState.compressImage(option),
+			createAnimation: (option) => this.createAnimation(option),
+			createCanvasContext: (canvasId, scope) => this.createCanvasContext(canvasId, scope),
+			canvasToTempFilePath: (option) => this.canvasToTempFilePath(option),
+			createIntersectionObserver: (scope, options) => this.createIntersectionObserver(scope, options),
+			createVideoContext: (videoId, scope) => this.createVideoContext(videoId, scope),
 			executeSelectorQuery: (requests, scope) => this.executeSelectorQuery(requests, scope),
+			getFileInfo: (option) => this.wxState.getFileInfo(option),
+			getImageInfo: (option) => this.wxState.getImageInfo(option),
+			getVideoInfo: (option) => this.wxState.getVideoInfo(option),
 			getFileSystemManager: () => this.wxState.getFileSystemManager(),
 			getSavedFileInfo: (option) => this.wxState.getSavedFileInfo(option),
 			getSavedFileList: () => this.wxState.getSavedFileList(),
@@ -5445,11 +6904,13 @@ var HeadlessSession = class {
 					extraData: { ...this.launchOptions.referrerInfo.extraData }
 				}
 			}),
+			getClipboardData: () => this.wxState.getClipboardData(),
 			getMenuButtonBoundingClientRect: () => deriveMenuButtonBoundingClientRect(this.systemInfo),
 			getNetworkType: () => this.wxState.getNetworkType(),
 			navigateBack: (option) => this.navigateBack(option?.delta),
 			navigateTo: (option) => this.navigateTo(option.url),
 			pageScrollTo: (option) => this.pageScrollTo(option),
+			openDocument: (option) => this.wxState.openDocument(option),
 			clearStorageSync: () => this.wxState.clearStorageSync(),
 			getStorageInfoSync: () => this.wxState.getStorageInfoSync(),
 			getStorageSync: (key) => this.wxState.getStorageSync(key),
@@ -5461,14 +6922,18 @@ var HeadlessSession = class {
 			reLaunch: (option) => this.reLaunch(option.url),
 			redirectTo: (option) => this.redirectTo(option.url),
 			removeSavedFile: (option) => this.wxState.removeSavedFile(option),
+			saveImageToPhotosAlbum: (option) => this.wxState.saveImageToPhotosAlbum(option),
+			saveVideoToPhotosAlbum: (option) => this.wxState.saveVideoToPhotosAlbum(option),
 			nextTick: (callback) => queueMicrotask(() => callback?.()),
 			offNetworkStatusChange: (callback) => this.wxState.offNetworkStatusChange(callback),
 			onNetworkStatusChange: (callback) => this.wxState.onNetworkStatusChange(callback),
 			removeStorageSync: (key) => this.wxState.removeStorageSync(key),
+			previewImage: (option) => this.wxState.previewImage(option),
 			request: (option) => this.wxState.request(option),
 			saveFile: (option) => this.wxState.saveFile(option),
 			setBackgroundColor: (option) => this.setBackgroundColor(option),
 			setBackgroundTextStyle: (option) => this.setBackgroundTextStyle(option.textStyle),
+			setClipboardData: (option) => this.wxState.setClipboardData(option),
 			setStorageSync: (key, value) => this.wxState.setStorageSync(key, value),
 			setNavigationBarColor: (option) => this.setNavigationBarColor(option),
 			setNavigationBarTitle: (option) => this.setNavigationBarTitle(option.title),
@@ -5484,6 +6949,7 @@ var HeadlessSession = class {
 			showLoading: (option) => this.wxState.showLoading(option),
 			showModal: (option) => this.wxState.showModal(option),
 			showToast: (option) => this.wxState.showToast(option),
+			startPullDownRefresh: () => this.startPullDownRefresh(),
 			stopPullDownRefresh: () => this.stopPullDownRefresh(),
 			switchTab: (option) => this.switchTab(option.url),
 			uploadFile: (option) => this.wxState.uploadFile(option),
@@ -5542,6 +7008,8 @@ var HeadlessSession = class {
 			moduleLoader: this.moduleLoader,
 			project: this.project,
 			session: {
+				createIntersectionObserver: (scope, options) => this.createIntersectionObserver(scope, options),
+				createMediaQueryObserver: (scope) => this.createMediaQueryObserver(scope),
 				selectAllComponentsWithin: (scopeId, selector) => this.selectAllComponentsWithin(scopeId, selector),
 				selectComponentWithin: (scopeId, selector) => this.selectComponentWithin(scopeId, selector),
 				selectOwnerComponent: (scopeId) => this.selectOwnerComponent(scopeId)
@@ -5609,6 +7077,7 @@ var HeadlessSession = class {
 		}
 		const instance = this.componentCache.get(normalizedScopeId);
 		if (!instance) throw new Error(`Unknown scope "${normalizedScopeId}" in headless runtime.`);
+		instance.__lastInteractionEvent__ = void 0;
 		const method = instance[methodName];
 		if (typeof method !== "function") throw new TypeError(`Method "${methodName}" does not exist on headless component scope "${normalizedScopeId}".`);
 		return method.apply(instance, args);
@@ -5658,6 +7127,15 @@ var HeadlessSession = class {
 	getStorageInfo() {
 		return this.wxState.getStorageInfoSync();
 	}
+	getClipboardData() {
+		return this.wxState.getClipboardSnapshot();
+	}
+	getPreviewImage() {
+		return this.wxState.getPreviewImage();
+	}
+	getOpenedDocument() {
+		return this.wxState.getOpenedDocument();
+	}
 	getPullDownRefreshState() {
 		return { ...this.pullDownRefreshState };
 	}
@@ -5931,7 +7409,8 @@ var HeadlessSession = class {
 	}
 	pageScrollTo(option) {
 		const current = this.requireCurrentPage("wx.pageScrollTo()");
-		current.__scrollTop__ = Number(option.scrollTop ?? 0);
+		const selectorScrollTop = resolveSelectorScrollTop(this.renderCurrentPage().root, option.selector);
+		current.__scrollTop__ = Number(selectorScrollTop ?? option.scrollTop ?? 0);
 		current.onPageScroll?.({ scrollTop: current.__scrollTop__ });
 	}
 	triggerPullDownRefresh() {
@@ -5943,6 +7422,10 @@ var HeadlessSession = class {
 		current.onPullDownRefresh?.();
 		return current;
 	}
+	startPullDownRefresh() {
+		this.triggerPullDownRefresh();
+		return { errMsg: "startPullDownRefresh:ok" };
+	}
 	triggerReachBottom() {
 		const current = this.requireCurrentPage("triggerReachBottom()");
 		current.onReachBottom?.();
@@ -5953,6 +7436,7 @@ var HeadlessSession = class {
 		applyResizeToSystemInfo(this.systemInfo, options);
 		current.onResize?.(options);
 		this.runPageComponentLifetime(current.route, "resize", options);
+		this.notifyMediaQueryObservers();
 		return current;
 	}
 	triggerRouteDone(options = {}) {
@@ -5973,6 +7457,11 @@ var HeadlessSession = class {
 		const scopeId = scope && scope !== current ? this.getComponentScopeId(scope) : null;
 		return executeSelectorQueryRequests(requests, {
 			page: current,
+			resolveContext: (node) => {
+				if (node.name !== "canvas") return { type: "unsupported-context" };
+				const canvasId = node.attribs?.["canvas-id"];
+				return typeof canvasId === "string" && canvasId ? this.createCanvasContext(canvasId, scope) : { type: "unsupported-context" };
+			},
 			root: resolveSelectorQueryScopeRoot(rendered.root, scopeId),
 			windowInfo: this.getWindowInfo()
 		});
@@ -5986,6 +7475,8 @@ var HeadlessSession = class {
 			background: resolveBackgroundSnapshot(this.project.appConfig, pageConfig),
 			navigationBar: resolveNavigationBarSnapshot(this.project.appConfig, pageConfig)
 		});
+		pageInstance.createIntersectionObserver = (options) => this.createIntersectionObserver(pageInstance, options);
+		pageInstance.createMediaQueryObserver = () => this.createMediaQueryObserver(pageInstance);
 		pageInstance.selectComponent = (selector) => this.selectComponent(selector);
 		pageInstance.selectAllComponents = (selector) => this.selectAllComponents(selector);
 		pageInstance.onLoad?.(target.query);
@@ -6035,10 +7526,12 @@ var HeadlessSession = class {
 		this.tabPages.clear();
 		this.componentCache.clear();
 		this.componentScopes.clear();
+		this.clearMediaQueryObservers();
 		this.currentPageInstance = null;
 	}
 	unloadPage(page) {
 		page.onUnload?.();
+		this.clearMediaQueryObservers(page);
 		this.detachPageComponents(page.route);
 		this.tabPages.delete(stripLeadingSlash(page.route));
 	}
@@ -6049,21 +7542,21 @@ var HeadlessSession = class {
 		return current;
 	}
 	selectComponentsWithin(rootScopeId, selector) {
-		const normalizedSelector = selector.trim();
-		if (!normalizedSelector) return [];
+		const selectorParts = normalizeSelectorParts(selector);
+		if (selectorParts.length === 0) return [];
 		return [...this.componentScopes.entries()].filter(([candidateScopeId, scope]) => {
 			if (!candidateScopeId.includes("/")) return false;
 			if (rootScopeId && candidateScopeId === rootScopeId) return false;
 			if (rootScopeId && !candidateScopeId.startsWith(`${rootScopeId}/`)) return false;
-			if (normalizedSelector.startsWith("#")) return scope.id === normalizedSelector.slice(1);
-			if (normalizedSelector.startsWith(".")) return scope.classList?.includes(normalizedSelector.slice(1)) ?? false;
-			const dataAttrMatch = normalizedSelector.match(DATA_ATTR_SELECTOR_RE);
-			if (dataAttrMatch) {
-				const [, key, value] = dataAttrMatch;
-				const datasetKey = key.replace(DATASET_KEY_RE, (_match, char) => char.toUpperCase());
-				return scope.dataset?.[datasetKey] === value;
+			const lastPart = selectorParts.at(-1);
+			if (!lastPart || !matchesComponentSelector(scope, lastPart)) return false;
+			let currentScope = scope.ownerScopeId ? this.componentScopes.get(scope.ownerScopeId) : void 0;
+			for (let partIndex = selectorParts.length - 2; partIndex >= 0; partIndex -= 1) {
+				while (currentScope && !matchesComponentSelector(currentScope, selectorParts[partIndex])) currentScope = currentScope.ownerScopeId ? this.componentScopes.get(currentScope.ownerScopeId) : void 0;
+				if (!currentScope) return false;
+				currentScope = currentScope.ownerScopeId ? this.componentScopes.get(currentScope.ownerScopeId) : void 0;
 			}
-			return scope.alias === normalizedSelector;
+			return true;
 		}).map(([candidateScopeId]) => this.componentCache.get(candidateScopeId)).filter(Boolean);
 	}
 	detachPageComponents(route) {
@@ -6075,6 +7568,18 @@ var HeadlessSession = class {
 			this.componentScopes.delete(scopeId);
 		}
 	}
+	notifyMediaQueryObservers() {
+		for (const entry of [...this.mediaQueryObservers]) {
+			if (entry.ownerPage !== this.currentPageInstance) continue;
+			entry.notify();
+		}
+	}
+	clearMediaQueryObservers(ownerPage) {
+		for (const entry of [...this.mediaQueryObservers]) {
+			if (ownerPage && entry.ownerPage !== ownerPage) continue;
+			entry.disconnect();
+		}
+	}
 	runPageComponentLifetime(route, lifetimeName, payload) {
 		const prefix = `page:${stripLeadingSlash(route)}`;
 		for (const [scopeId, instance] of this.componentCache.entries()) {
@@ -6086,6 +7591,100 @@ var HeadlessSession = class {
 		for (const [scopeId, instance] of this.componentCache.entries()) if (instance === component) return scopeId;
 		return null;
 	}
+	createVideoContext(videoId, scope) {
+		return createHeadlessVideoContext({
+			callScopeMethod: (scopeId, methodName, event) => this.callScopeMethod(scopeId, methodName, event),
+			renderCurrentPage: () => this.renderCurrentPage(),
+			resolveScope: (value) => {
+				const current = this.currentPageInstance;
+				if (!value || value === current) return { kind: "page" };
+				const scopeId = this.getScopeIdForComponent(value);
+				if (!scopeId) return { kind: "missing" };
+				return {
+					kind: "component",
+					scopeId
+				};
+			}
+		}, videoId, scope);
+	}
+	createAnimation(option) {
+		return createHeadlessAnimation(option);
+	}
+	resolveCanvasScopeKey(scope) {
+		const current = this.currentPageInstance;
+		if (!scope || scope === current) return "page";
+		const scopeId = this.getScopeIdForComponent(scope);
+		return scopeId ? `component:${scopeId}` : "missing";
+	}
+	createCanvasContext(canvasId, scope) {
+		const context = createHeadlessCanvasContext({
+			renderCurrentPage: () => this.renderCurrentPage(),
+			resolveScope: (value) => {
+				const current = this.currentPageInstance;
+				if (!value || value === current) return { kind: "page" };
+				const scopeId = this.getScopeIdForComponent(value);
+				if (!scopeId) return { kind: "missing" };
+				return {
+					kind: "component",
+					scopeId
+				};
+			}
+		}, canvasId, scope);
+		this.canvasContexts.set(`${this.resolveCanvasScopeKey(scope)}:${canvasId}`, context);
+		return context;
+	}
+	canvasToTempFilePath(option) {
+		const context = this.canvasContexts.get(`${this.resolveCanvasScopeKey(option.component)}:${option.canvasId}`);
+		if (!context) throw new Error(`canvasToTempFilePath:fail canvas "${option.canvasId}" has not been drawn in headless runtime.`);
+		return {
+			errMsg: "canvasToTempFilePath:ok",
+			tempFilePath: this.wxState.createTempFile(JSON.stringify({
+				canvasId: option.canvasId,
+				config: {
+					destHeight: option.destHeight,
+					destWidth: option.destWidth,
+					fileType: option.fileType,
+					height: option.height,
+					quality: option.quality,
+					width: option.width,
+					x: option.x,
+					y: option.y
+				},
+				snapshot: context.__getSnapshot()
+			}))
+		};
+	}
+	createIntersectionObserver(scope, options) {
+		return createHeadlessIntersectionObserver({
+			getWindowInfo: () => this.getWindowInfo(),
+			renderCurrentPage: () => this.renderCurrentPage(),
+			resolveScope: (value) => {
+				const current = this.currentPageInstance;
+				if (!value || value === current) return { kind: "page" };
+				const scopeId = this.getScopeIdForComponent(value);
+				if (!scopeId) return { kind: "missing" };
+				return {
+					kind: "component",
+					scopeId
+				};
+			}
+		}, scope, options);
+	}
+	createMediaQueryObserver(scope) {
+		const current = this.requireCurrentPage("createMediaQueryObserver()");
+		const ownerPage = scope === current || !scope ? current : this.currentPageInstance ?? current;
+		let entry;
+		const controller = createHeadlessMediaQueryObserver({ getWindowInfo: () => this.getWindowInfo() }, () => {
+			this.mediaQueryObservers.delete(entry);
+		});
+		entry = {
+			disconnect: controller.disconnect,
+			notify: controller.notify,
+			ownerPage
+		};
+		this.mediaQueryObservers.add(entry);
+		return controller.observer;
+	}
 };
 function createHeadlessSession(options) {
 	return new HeadlessSession(options);