preflite 1.0.1

package/dist/infrastructure/midscene/executionDumpWatcher.js

@@ -0,0 +1,219 @@
+import { mkdirSync, watch } from "node:fs";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import sharp from "sharp";
+const MAX_ASSETS_PER_FLUSH = 24;
+const MAX_ASSET_BYTES_PER_FLUSH = 4 * 1024 * 1024;
+function fingerprint(st) {
+    return `${st.mtimeMs}:${st.size}`;
+}
+export async function mergeExecutionDumpJsonFromDir(bundleDir) {
+    const names = await fs.readdir(bundleDir);
+    const numbered = names
+        .map((name) => {
+        const m = /^(\d+)\.execution\.json$/.exec(name);
+        return m ? { name, i: Number.parseInt(m[1], 10) } : null;
+    })
+        .filter((x) => x !== null)
+        .sort((a, b) => a.i - b.i);
+    let base = null;
+    const allExecutions = [];
+    for (const { name } of numbered) {
+        const filePath = path.join(bundleDir, name);
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        let part;
+        try {
+            part = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!base) {
+            base = { ...part };
+        }
+        const ex = part.executions;
+        if (Array.isArray(ex)) {
+            for (const item of ex) {
+                allExecutions.push(item);
+            }
+        }
+    }
+    if (!base) {
+        return null;
+    }
+    return { ...base, executions: allExecutions };
+}
+export function startExecutionDumpWatcher(bundleDir, onFlush, options) {
+    try {
+        mkdirSync(bundleDir, { recursive: true });
+    }
+    catch {
+        /* 若仍失败，watch 会抛错由调用方感知 */
+    }
+    const debounceMs = options?.debounceMs ?? 450;
+    let revision = 0;
+    const fingerprints = new Map();
+    let timer = null;
+    let stopped = false;
+    let watcher = null;
+    let lastDumpJsonSent = "";
+    const imageCompression = options?.imageCompression;
+    const compressImage = async (buf, ext) => {
+        if (!imageCompression || imageCompression.quality >= 100)
+            return buf;
+        if (ext === ".gif")
+            return buf;
+        let pipeline = sharp(buf, { animated: false }).rotate();
+        if (imageCompression.maxWidth && imageCompression.maxWidth > 0) {
+            pipeline = pipeline.resize({ width: imageCompression.maxWidth, withoutEnlargement: true });
+        }
+        const quality = Math.floor(Math.max(1, Math.min(100, imageCompression.quality)));
+        if (ext === ".jpg" || ext === ".jpeg") {
+            return pipeline.jpeg({ quality, mozjpeg: true }).toBuffer();
+        }
+        if (ext === ".webp") {
+            return pipeline.webp({ quality }).toBuffer();
+        }
+        if (ext === ".png") {
+            return pipeline.png({ quality, palette: true, compressionLevel: 9 }).toBuffer();
+        }
+        return buf;
+    };
+    const schedule = () => {
+        if (stopped)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            void flush();
+        }, debounceMs);
+    };
+    const flush = async () => {
+        if (stopped)
+            return;
+        let merged = null;
+        try {
+            merged = await mergeExecutionDumpJsonFromDir(bundleDir);
+        }
+        catch {
+            return;
+        }
+        const reportAssetFiles = [];
+        let bytesBudget = MAX_ASSET_BYTES_PER_FLUSH;
+        const skipBySize = (size, budget) => size <= 0 || size > budget;
+        const walkImages = async (relBase) => {
+            const absBase = path.join(bundleDir, relBase);
+            let entries;
+            try {
+                entries = await fs.readdir(absBase, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const ent of entries) {
+                if (reportAssetFiles.length >= MAX_ASSETS_PER_FLUSH)
+                    return;
+                const rel = relBase ? `${relBase}/${ent.name}` : ent.name;
+                if (ent.isDirectory()) {
+                    await walkImages(rel);
+                    continue;
+                }
+                if (!ent.isFile())
+                    continue;
+                const ext = path.extname(ent.name).toLowerCase();
+                if (![".png", ".jpg", ".jpeg", ".webp", ".gif"].includes(ext))
+                    continue;
+                const full = path.join(bundleDir, rel);
+                let st;
+                try {
+                    st = await fs.stat(full);
+                }
+                catch {
+                    continue;
+                }
+                const fp = fingerprint(st);
+                if (fingerprints.get(rel) === fp)
+                    continue;
+                if (skipBySize(st.size, bytesBudget))
+                    continue;
+                let buf;
+                try {
+                    buf = await fs.readFile(full);
+                }
+                catch {
+                    continue;
+                }
+                try {
+                    const compressed = await compressImage(buf, ext);
+                    if (compressed.length > 0 && compressed.length < buf.length) {
+                        buf = compressed;
+                        if (imageCompression?.overwriteFiles) {
+                            await fs.writeFile(full, buf);
+                            st = await fs.stat(full);
+                        }
+                    }
+                }
+                catch {
+                    /* 压缩失败时保留原图 */
+                }
+                bytesBudget -= buf.length;
+                fingerprints.set(rel, fingerprint(st));
+                reportAssetFiles.push({
+                    relativePath: rel.replace(/\\/g, "/"),
+                    base64: buf.toString("base64"),
+                });
+            }
+        };
+        try {
+            await walkImages("screenshots");
+        }
+        catch {
+            /* screenshots 可能尚未创建 */
+        }
+        const jsonStr = merged === null ? "" : JSON.stringify(merged);
+        if (reportAssetFiles.length === 0) {
+            if (merged === null)
+                return;
+            if (jsonStr === lastDumpJsonSent)
+                return;
+        }
+        revision += 1;
+        if (jsonStr) {
+            lastDumpJsonSent = jsonStr;
+        }
+        try {
+            await onFlush({
+                executionDumpJson: jsonStr || "{}",
+                executionDumpRevision: revision,
+                reportAssetFiles,
+            });
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    try {
+        watcher = watch(bundleDir, { persistent: false, recursive: true }, schedule);
+    }
+    catch {
+        watcher = watch(bundleDir, { persistent: false }, schedule);
+    }
+    schedule();
+    const stop = () => {
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        watcher?.close();
+        watcher = null;
+    };
+    return { stop };
+}

package/dist/infrastructure/midscene/videoRecorder.js

@@ -0,0 +1,365 @@
+import { spawn } from "node:child_process";
+import { mkdir, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { augmentPathForShellCommands } from "../system/CommandRunner.js";
+import { PlatformType } from "../../shared-kernel/enums/index.js";
+function truthy(raw) {
+    const v = raw?.trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function envString(env, key, fallback) {
+    const v = env[key]?.trim();
+    return v ? v : fallback;
+}
+function envNumber(env, key, fallback, min, max) {
+    const n = Number(env[key]);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(max, Math.max(min, n));
+}
+function extractDeviceToken(resourceId) {
+    const idx = resourceId.indexOf(":");
+    return idx >= 0 ? resourceId.slice(idx + 1) : resourceId;
+}
+function safeNamePart(raw) {
+    return raw
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+function buildOutputName(ctx) {
+    const scope = safeNamePart(ctx.taskId || extractDeviceToken(ctx.resourceId) || "run");
+    return `${ctx.platform.toLowerCase()}-${scope}-${Date.now()}.mp4`;
+}
+function buildRemoteAndroidRecordingPath(ctx) {
+    const scope = safeNamePart(ctx.taskId || extractDeviceToken(ctx.resourceId) || "run") || "run";
+    return `/sdcard/preflight-${scope}-${Date.now()}.mp4`;
+}
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function positivePort(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return undefined;
+    return Math.floor(n);
+}
+function androidAdbCommandPrefix(ctx) {
+    const serial = envString(ctx.runtimeEnv, "MIDSCENE_ANDROID_SERIAL", extractDeviceToken(ctx.resourceId));
+    const host = envString(ctx.runtimeEnv, "MIDSCENE_ANDROID_ADB_HOST", "127.0.0.1");
+    const port = positivePort(ctx.runtimeEnv.MIDSCENE_ANDROID_ADB_PORT) ?? 5037;
+    return `adb -H ${shQuote(host)} -P ${port} -s ${shQuote(serial)}`;
+}
+function harmonyHdcCommandPrefix(ctx) {
+    const hdc = envString(ctx.runtimeEnv, "MIDSCENE_HARMONY_HDC_PATH", "hdc");
+    const host = ctx.runtimeEnv.MIDSCENE_HARMONY_HDC_HOST?.trim();
+    const port = positivePort(ctx.runtimeEnv.MIDSCENE_HARMONY_HDC_PORT);
+    const server = host && port ? ` -s ${shQuote(`${host}:${port}`)}` : "";
+    const deviceId = envString(ctx.runtimeEnv, "MIDSCENE_HARMONY_DEVICE_ID", extractDeviceToken(ctx.resourceId));
+    return `${shQuote(hdc)}${server} -t ${shQuote(deviceId)}`;
+}
+function resolveAutoSource(ctx) {
+    if (ctx.platform === PlatformType.IOS) {
+        const host = envString(ctx.runtimeEnv, "MIDSCENE_IOS_WDA_HOST", "127.0.0.1");
+        const explicitMjpegPort = positivePort(ctx.runtimeEnv.MIDSCENE_IOS_WDA_MJPEG_PORT) ??
+            positivePort(ctx.runtimeEnv.IOS_WDA_MJPEG_PORT);
+        const wdaPort = positivePort(ctx.runtimeEnv.MIDSCENE_IOS_WDA_PORT) ?? positivePort(ctx.runtimeEnv.IOS_WDA_PORT);
+        const mjpegPort = explicitMjpegPort ?? (wdaPort != null ? wdaPort + 1000 : undefined);
+        if (!mjpegPort)
+            return undefined;
+        return { kind: "url", url: `http://${host}:${mjpegPort}/` };
+    }
+    if (ctx.platform === PlatformType.ANDROID) {
+        return {
+            kind: "scrcpy-record",
+            serial: envString(ctx.runtimeEnv, "MIDSCENE_ANDROID_SERIAL", extractDeviceToken(ctx.resourceId)),
+        };
+    }
+    if (ctx.platform === PlatformType.HARMONY) {
+        return {
+            kind: "command",
+            command: `${harmonyHdcCommandPrefix(ctx)} shell screenrecord --output-format=h264 -`,
+            inputFormat: "h264",
+        };
+    }
+    return undefined;
+}
+export function resolveVideoRecorderConfig(env, context) {
+    const runtimeEnv = { ...env, ...context.runtimeEnv };
+    return {
+        enabled: truthy(runtimeEnv.MIDSCENE_RECORD_VIDEO_ENABLED),
+        source: resolveAutoSource({ ...context, runtimeEnv }),
+        fps: Math.floor(envNumber(runtimeEnv, "MIDSCENE_RECORD_VIDEO_FPS", 30, 1, 120)),
+        scaleWidth: Math.floor(envNumber(runtimeEnv, "MIDSCENE_RECORD_VIDEO_SCALE_WIDTH", 540, 120, 4096)),
+        crf: Math.floor(envNumber(runtimeEnv, "MIDSCENE_RECORD_VIDEO_CRF", 32, 0, 51)),
+        preset: envString(runtimeEnv, "MIDSCENE_RECORD_VIDEO_PRESET", "fast"),
+        playbackRate: envNumber(runtimeEnv, "MIDSCENE_RECORD_VIDEO_PLAYBACK_RATE", 1, 0.1, 8),
+        outputName: buildOutputName({ ...context, runtimeEnv }),
+    };
+}
+function buildVideoFilters(config) {
+    const filters = [`scale=${config.scaleWidth}:-2`];
+    if (config.playbackRate !== 1) {
+        filters.push(`setpts=${(1 / config.playbackRate).toFixed(6)}*PTS`);
+    }
+    return filters.join(",");
+}
+async function resolveFfmpegCommand(env) {
+    const explicit = env.MIDSCENE_RECORD_VIDEO_FFMPEG_PATH?.trim() || env.FFMPEG_PATH?.trim();
+    if (explicit)
+        return explicit;
+    try {
+        const mod = (await import("@ffmpeg-installer/ffmpeg"));
+        const bundled = mod.default?.path ?? mod.path;
+        if (bundled)
+            return bundled;
+    }
+    catch {
+        /* optional dependency; fall back to PATH */
+    }
+    return "ffmpeg";
+}
+function spawnEnv() {
+    return {
+        ...process.env,
+        PATH: augmentPathForShellCommands(process.env.PATH),
+    };
+}
+function buildFfmpegArgs(config, outputPath, ffmpegCommand) {
+    if (!config.source)
+        throw new Error("record video source is not available");
+    const inputArgs = config.source.kind === "url"
+        ? ["-i", config.source.url]
+        : config.source.kind === "command"
+            ? ["-f", config.source.inputFormat, "-i", "pipe:0"]
+            : config.source.kind === "android-screenrecord-file"
+                ? ["-i", config.source.remotePath]
+                : (() => {
+                    throw new Error("scrcpy recording must be transcoded from its raw local file");
+                })();
+    // 对于实时流（URL / 管道），需要使用 fragmented MP4 确保中断时文件仍可播放。
+    // frag_keyframe+empty_moov 让 moov atom 写在文件开头，播放器无需等待完整的
+    // 文件尾部索引即可开始解码。
+    const movflags = config.source?.kind === "url" || config.source?.kind === "command"
+        ? ["-movflags", "frag_keyframe+empty_moov"]
+        : [];
+    return [
+        ffmpegCommand,
+        "-y",
+        ...inputArgs,
+        "-r",
+        String(config.fps),
+        "-vf",
+        buildVideoFilters(config),
+        ...movflags,
+        "-an",
+        "-c:v",
+        "libx264",
+        "-preset",
+        config.preset,
+        "-crf",
+        String(config.crf),
+        outputPath,
+    ];
+}
+export async function startVideoRecording(reportDir, config) {
+    if (!config.enabled)
+        return null;
+    if (!config.source) {
+        console.warn("[videoRecorder] enabled but no platform input source could be resolved");
+        return null;
+    }
+    const recordingsDir = path.join(reportDir, "recordings");
+    await mkdir(recordingsDir, { recursive: true });
+    const outputPath = path.join(recordingsDir, config.outputName);
+    const ffmpegCommand = await resolveFfmpegCommand(process.env);
+    if (config.source.kind === "scrcpy-record") {
+        return startScrcpyRecording(recordingsDir, outputPath, config, ffmpegCommand);
+    }
+    if (config.source.kind === "android-screenrecord-file") {
+        return startAndroidFileRecording(recordingsDir, outputPath, config, ffmpegCommand);
+    }
+    const args = buildFfmpegArgs(config, outputPath, ffmpegCommand).slice(1);
+    const sourceLabel = config.source.kind === "url" ? config.source.url : config.source.command;
+    const child = config.source.kind === "url"
+        ? spawn(ffmpegCommand, args, { stdio: ["ignore", "pipe", "pipe"], env: spawnEnv() })
+        : spawn("sh", ["-lc", `${config.source.command} | ${shQuote(ffmpegCommand)} ${args.map(shQuote).join(" ")}`], {
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: spawnEnv(),
+        });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.stdout?.resume();
+    child.on("error", (err) => {
+        stderr += `\n${err.message}`;
+    });
+    console.info(`[videoRecorder] started source=${sourceLabel} fps=${config.fps} width=${config.scaleWidth} crf=${config.crf} output=${outputPath}`);
+    return {
+        outputPath,
+        stop: () => stopVideoRecording(child, outputPath, () => stderr),
+    };
+}
+async function startScrcpyRecording(recordingsDir, outputPath, config, ffmpegCommand) {
+    if (!config.source || config.source.kind !== "scrcpy-record") {
+        throw new Error("scrcpy recording requires scrcpy-record source");
+    }
+    const rawPath = path.join(recordingsDir, `.raw-${path.basename(outputPath)}`);
+    const args = ["-s", config.source.serial, "--no-window", "--record", rawPath];
+    const child = spawn("scrcpy", args, {
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: spawnEnv(),
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.stdout?.resume();
+    child.on("error", (err) => {
+        stderr += `\n${err.message}`;
+    });
+    console.info(`[videoRecorder] started source=scrcpy ${args.map(shQuote).join(" ")} fps=${config.fps} width=${config.scaleWidth} crf=${config.crf} output=${outputPath}`);
+    return {
+        outputPath,
+        stop: async () => {
+            const stoppedStderr = await stopChildProcess(child, () => stderr);
+            stderr = `${stderr}\n${stoppedStderr}`;
+            const args = buildFfmpegArgs({ ...config, source: { kind: "url", url: pathToFileURL(rawPath).toString() } }, outputPath, ffmpegCommand);
+            const transcode = await runProcess(args[0], args.slice(1), 120_000);
+            stderr = `${stderr}\n${transcode.stderr}`;
+            await rm(rawPath, { force: true }).catch(() => { });
+            return finishStoppedRecording(outputPath, stderr);
+        },
+    };
+}
+async function startAndroidFileRecording(recordingsDir, outputPath, config, ffmpegCommand) {
+    if (!config.source || config.source.kind !== "android-screenrecord-file") {
+        throw new Error("android file recording requires android-screenrecord-file source");
+    }
+    const rawPath = path.join(recordingsDir, `.raw-${path.basename(outputPath)}`);
+    const source = config.source;
+    const command = `${source.adbPrefix} shell rm -f ${shQuote(source.remotePath)}; exec ${source.adbPrefix} shell screenrecord ${shQuote(source.remotePath)}`;
+    const child = spawn("sh", ["-lc", command], {
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: spawnEnv(),
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    child.stdout?.resume();
+    child.on("error", (err) => {
+        stderr += `\n${err.message}`;
+    });
+    console.info(`[videoRecorder] started source=${command} fps=${config.fps} width=${config.scaleWidth} crf=${config.crf} output=${outputPath}`);
+    return {
+        outputPath,
+        stop: async () => {
+            const stoppedStderr = await stopChildProcess(child, () => stderr);
+            stderr = `${stderr}\n${stoppedStderr}`;
+            const pull = await runShell(`${source.adbPrefix} pull ${shQuote(source.remotePath)} ${shQuote(rawPath)}`, 30_000);
+            stderr = `${stderr}\n${pull.stderr}`;
+            if (!pull.ok) {
+                await runShell(`${source.adbPrefix} shell rm -f ${shQuote(source.remotePath)}`, 10_000).catch(() => { });
+                return finishStoppedRecording(outputPath, stderr);
+            }
+            const args = buildFfmpegArgs({ ...config, source: { kind: "url", url: pathToFileURL(rawPath).toString() } }, outputPath, ffmpegCommand);
+            const transcode = await runProcess(args[0], args.slice(1), 120_000);
+            stderr = `${stderr}\n${transcode.stderr}`;
+            await runShell(`${source.adbPrefix} shell rm -f ${shQuote(source.remotePath)}`, 10_000).catch(() => { });
+            await rm(rawPath, { force: true }).catch(() => { });
+            return finishStoppedRecording(outputPath, stderr);
+        },
+    };
+}
+async function stopVideoRecording(child, outputPath, getStderr) {
+    const stderr = await stopChildProcess(child, getStderr);
+    return finishStoppedRecording(outputPath, stderr);
+}
+async function stopChildProcess(child, getStderr) {
+    if (child.exitCode != null || child.killed) {
+        return getStderr();
+    }
+    if (child.pid != null && child.pid > 0) {
+        try {
+            process.kill(-child.pid, "SIGINT");
+        }
+        catch {
+            child.kill("SIGINT");
+        }
+    }
+    return new Promise((resolve) => {
+        const done = () => resolve(getStderr());
+        const timer = setTimeout(() => {
+            if (child.pid != null && child.pid > 0) {
+                try {
+                    process.kill(-child.pid, "SIGTERM");
+                }
+                catch {
+                    if (child.exitCode == null && !child.killed)
+                        child.kill("SIGTERM");
+                }
+            }
+            setTimeout(() => {
+                if (child.exitCode == null && !child.killed) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        /* already gone */
+                    }
+                }
+                resolve(getStderr());
+            }, 3_000);
+        }, 8_000);
+        child.once("close", () => {
+            clearTimeout(timer);
+            done();
+        });
+    });
+}
+function runShell(command, timeoutMs) {
+    return runProcess("sh", ["-lc", command], timeoutMs);
+}
+function runProcess(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], env: spawnEnv() });
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+        }, timeoutMs);
+        child.stdout?.resume();
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({ ok: false, stderr: `${stderr}\n${err.message}` });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ ok: code === 0, stderr });
+        });
+    });
+}
+async function finishStoppedRecording(outputPath, stderr) {
+    try {
+        const st = await stat(outputPath);
+        if (st.isFile() && st.size > 0) {
+            console.info(`[videoRecorder] stopped output=${outputPath} bytes=${st.size}`);
+            return { ok: true, outputPath, stderr };
+        }
+    }
+    catch {
+        /* missing file */
+    }
+    console.warn(`[videoRecorder] stopped without output=${outputPath} stderr=${stderr.slice(-500)}`);
+    await writeFile(`${outputPath}.stderr.log`, stderr || "video recording produced no output", "utf8").catch(() => { });
+    return { ok: false, stderr };
+}

package/dist/infrastructure/midscene/zipReportDir.js

@@ -0,0 +1,36 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+const execFileAsync = promisify(execFile);
+/**
+ * 将目录打成 zip 文件，返回 **临时** zip 路径。调用方负责在合适时机删除整个临时目录或 zip。
+ * 依赖系统 `zip` 可执行文件（macOS / 常见 Linux）。
+ */
+export async function zipDirectoryToFile(bundleDir, stem) {
+    if (!bundleDir)
+        return undefined;
+    const outDir = await mkdtemp(path.join(tmpdir(), "report-zip-"));
+    const outZip = path.join(outDir, `${stem}-bundle.zip`);
+    try {
+        await execFileAsync("zip", ["-q", "-r", outZip, "."], { cwd: bundleDir });
+    }
+    catch {
+        await rm(outDir, { recursive: true, force: true });
+        return undefined;
+    }
+    return outZip;
+}
+export async function readFileAsBase64(filePath) {
+    const buf = await readFile(filePath);
+    return buf.toString("base64");
+}
+export async function rmQuiet(target) {
+    try {
+        await rm(target, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+}