@oniroproject/core 0.7.0 → 0.8.0

package/dist/index.js

@@ -105,9 +105,9 @@ var CmdToolsNotInstalledError = class extends OniroError {
   expectedPath;
 };
 var UnsupportedPlatformError = class extends OniroError {
-  constructor(platform6) {
-    super(`Unsupported platform: ${platform6}.`);
-    this.platform = platform6;
+  constructor(platform7) {
+    super(`Unsupported platform: ${platform7}.`);
+    this.platform = platform7;
     this.name = "UnsupportedPlatformError";
   }
   platform;
@@ -122,6 +122,14 @@ var ChecksumMismatchError = class extends OniroError {
   expected;
   actual;
 };
+var InsufficientSpaceError = class extends OniroError {
+  constructor(message, dir, cause) {
+    super(message, cause);
+    this.dir = dir;
+    this.name = "InsufficientSpaceError";
+  }
+  dir;
+};
 var CancelledError = class extends OniroError {
   constructor(message = "Operation cancelled.") {
     super(message);
@@ -168,29 +176,29 @@ var OHOS_URL_BASE = "https://repo.huaweicloud.com/openharmony/os";
 // src/sdk/platform.ts
 import * as os2 from "os";
 function getOsFolder() {
-  const platform6 = os2.platform();
-  if (platform6 === "linux") return "linux";
-  if (platform6 === "darwin") return "darwin";
-  if (platform6 === "win32") return "windows";
-  throw new UnsupportedPlatformError(platform6);
+  const platform7 = os2.platform();
+  if (platform7 === "linux") return "linux";
+  if (platform7 === "darwin") return "darwin";
+  if (platform7 === "win32") return "windows";
+  throw new UnsupportedPlatformError(platform7);
 }
 function getSdkFilename(version) {
-  const platform6 = os2.platform();
+  const platform7 = os2.platform();
   const v = version ?? ALL_SDKS[ALL_SDKS.length - 1].version;
   const strips = ALL_SDKS.find((r) => r.version === v)?.tarballStrip ?? { linuxWindows: 1, darwin: 3 };
-  if (platform6 === "linux") {
+  if (platform7 === "linux") {
     return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "linux", strip: strips.linuxWindows };
   }
-  if (platform6 === "darwin") {
+  if (platform7 === "darwin") {
     if (os2.arch() === "arm64") {
       return { filename: "L2-SDK-MAC-M1-PUBLIC.tar.gz", osFolder: "darwin", strip: strips.darwin };
     }
     return { filename: "ohos-sdk-mac-public.tar.gz", osFolder: "darwin", strip: strips.darwin };
   }
-  if (platform6 === "win32") {
+  if (platform7 === "win32") {
     return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "windows", strip: strips.linuxWindows };
   }
-  throw new UnsupportedPlatformError(platform6);
+  throw new UnsupportedPlatformError(platform7);
 }
 
 // src/sdk/paths.ts
@@ -231,6 +239,8 @@ function getOhpmPath(config) {
   return getCmdToolsBin(config, "ohpm");
 }
 function getHdcPath(config) {
+  const override = config.get("hdcPath", "");
+  if (override) return override;
   const base = path2.join(getCmdToolsPath(config), "sdk", "default", "openharmony", "toolchains");
   if (os3.platform() === "win32") {
     return pickExisting([
@@ -281,8 +291,164 @@ function detectProjectSdkVersion(projectRoot, logger = noopLogger) {
   }
 }
 
-// src/sdk/download.ts
+// src/sdk/tmp.ts
 import * as fs3 from "fs";
+import * as os4 from "os";
+import * as path4 from "path";
+var INSTALL_TMP_DIRNAME = ".oniro-tmp";
+var TMPFS_MAGIC = 16914836;
+var RAMFS_MAGIC = 2240043254;
+var HINT_EXAMPLE = os4.platform() === "win32" ? "D:\\oniro-tmp" : "~/.cache/oniro-tmp";
+var TMP_DIR_HINT = `Point the scratch directory at a filesystem with more room using --tmp-dir <path> (or the ONIRO_TMP_DIR environment variable), e.g. --tmp-dir ${HINT_EXAMPLE}.`;
+function resolveTmpRoot(config, override, installRoot) {
+  const explicit = (override ?? "").trim();
+  if (explicit) return path4.resolve(explicit);
+  const configured = config.get("tmpDir", "").trim();
+  if (configured) return path4.resolve(configured);
+  if (installRoot) return path4.join(path4.resolve(installRoot), INSTALL_TMP_DIRNAME);
+  return os4.tmpdir();
+}
+function createTempWorkDir(root, prefix) {
+  try {
+    fs3.mkdirSync(root, { recursive: true });
+    return fs3.mkdtempSync(path4.join(root, prefix));
+  } catch (err) {
+    if (isOutOfSpaceError(err)) throw toSpaceError(err, root, "a temporary directory");
+    throw new OniroError(
+      `Cannot create a temporary directory in '${root}': ${err instanceof Error ? err.message : String(err)}
+${TMP_DIR_HINT}`,
+      err
+    );
+  }
+}
+function removeTempWorkDir(dir, root) {
+  fs3.rmSync(dir, { recursive: true, force: true });
+  if (!root || path4.basename(root) !== INSTALL_TMP_DIRNAME) return;
+  try {
+    fs3.rmdirSync(root);
+  } catch {
+  }
+}
+function createInstallTempDir(opts) {
+  const requested = (opts.override ?? "").trim() || opts.config.get("tmpDir", "").trim();
+  const root = resolveTmpRoot(opts.config, opts.override, opts.installRoot);
+  try {
+    return { dir: createTempWorkDir(root, opts.prefix), root };
+  } catch (err) {
+    const fallback = os4.tmpdir();
+    if (requested || isOutOfSpaceError(err) || path4.resolve(fallback) === path4.resolve(root)) throw err;
+    const reason = err instanceof Error ? err.message.split("\n")[0] : String(err);
+    (opts.logger ?? noopLogger).warn(`${reason} Falling back to '${fallback}'.`);
+    return { dir: createTempWorkDir(fallback, opts.prefix), root: fallback };
+  }
+}
+function nearestExisting(dir) {
+  let current = path4.resolve(dir);
+  for (; ; ) {
+    if (fs3.existsSync(current)) return current;
+    const parent = path4.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function getFreeSpaceBytes(dir) {
+  const target = nearestExisting(dir);
+  if (!target) return null;
+  try {
+    const stats = fs3.statfsSync(target);
+    return Number(stats.bsize) * Number(stats.bavail);
+  } catch {
+    return null;
+  }
+}
+function isRamBackedPath(dir) {
+  const target = nearestExisting(dir);
+  if (!target) return false;
+  try {
+    const type = Number(fs3.statfsSync(target).type);
+    return type === TMPFS_MAGIC || type === RAMFS_MAGIC;
+  } catch {
+    return false;
+  }
+}
+function formatBytes(bytes) {
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let value = Math.max(0, bytes);
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value >= 10 || unit === 0 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`;
+}
+function isOutOfSpaceError(err) {
+  if (err instanceof InsufficientSpaceError) return true;
+  const seen = /* @__PURE__ */ new Set();
+  let current = err;
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const e = current;
+    if (e.code === "ENOSPC" || e.code === "EDQUOT") return true;
+    if (typeof e.message === "string" && /ENOSPC|EDQUOT|no space left on device/i.test(e.message)) return true;
+    current = e.cause;
+  }
+  return false;
+}
+function spaceMessage(dir, what, opts) {
+  const need = typeof opts.requiredBytes === "number" ? `needs about ${formatBytes(opts.requiredBytes)}` : null;
+  const free = typeof opts.freeBytes === "number" ? `${formatBytes(opts.freeBytes)} available` : null;
+  const amounts = [need, free].filter(Boolean).join(", ");
+  const lines = [`Not enough free space in '${dir}' for ${what}${amounts ? ` (${amounts})` : ""}.`];
+  if (isRamBackedPath(dir)) {
+    lines.push(
+      `'${dir}' is on a RAM-backed filesystem (tmpfs), so its capacity is limited by free memory, not by free disk.`
+    );
+  }
+  if (opts.tmpDirHint) lines.push(TMP_DIR_HINT);
+  return lines.join("\n");
+}
+function ensureFreeSpace(dir, requiredBytes, what) {
+  if (!Number.isFinite(requiredBytes) || requiredBytes <= 0) return;
+  const freeBytes = getFreeSpaceBytes(dir);
+  if (freeBytes === null || freeBytes >= requiredBytes) return;
+  throw new InsufficientSpaceError(
+    spaceMessage(dir, what, { requiredBytes, freeBytes, tmpDirHint: true }),
+    dir
+  );
+}
+function errorPath(err) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = err;
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const e = current;
+    if (typeof e.path === "string" && e.path) return e.path;
+    if (typeof e.dest === "string" && e.dest) return e.dest;
+    current = e.cause;
+  }
+  return null;
+}
+function isInside(child, parent) {
+  const rel = path4.relative(path4.resolve(parent), path4.resolve(child));
+  return rel === "" || !rel.startsWith("..") && !path4.isAbsolute(rel);
+}
+function toSpaceError(err, tmpRoot, what) {
+  if (err instanceof InsufficientSpaceError) return err;
+  if (!isOutOfSpaceError(err)) return err;
+  const failed = errorPath(err);
+  const failedDir = failed ? path4.dirname(path4.resolve(failed)) : path4.resolve(tmpRoot);
+  const inTmp = isInside(failedDir, tmpRoot);
+  const dir = inTmp ? path4.resolve(tmpRoot) : failedDir;
+  return new InsufficientSpaceError(
+    spaceMessage(dir, what, { freeBytes: getFreeSpaceBytes(dir), tmpDirHint: inTmp }),
+    dir,
+    err
+  );
+}
+
+// src/sdk/download.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
 import * as crypto from "crypto";
 import { pipeline } from "stream";
 import { promisify } from "util";
@@ -292,36 +458,57 @@ var pipelineAsync = promisify(pipeline);
 async function downloadFile(opts) {
   const { url, dest, progress, abortSignal } = opts;
   const proto = url.startsWith("https") ? https : http;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const s = Math.max(0, Math.min(100, opts.start ?? 0));
     const r = Math.max(0, Math.min(100 - s, opts.range ?? 100));
     let settled = false;
     const done = (err) => {
       if (settled) return;
       settled = true;
-      err ? reject(err) : resolve2();
+      err ? reject(err) : resolve4();
     };
     if (abortSignal?.aborted) {
       done(new CancelledError("Download cancelled before start."));
       return;
     }
-    const file = fs3.createWriteStream(dest);
+    const destDir = path5.dirname(path5.resolve(dest));
+    const what = opts.what ?? `the download of '${url}'`;
+    const writeFailed = (err) => isOutOfSpaceError(err) ? toSpaceError(err, opts.tmpRoot ?? destDir, what) : new OniroError(`Error writing '${dest}': ${err instanceof Error ? err.message : String(err)}`, err);
+    const file = fs4.createWriteStream(dest);
+    let activeResponse;
+    const failWith = (err) => {
+      file.close(() => fs4.rm(dest, { force: true }, () => done(err)));
+    };
+    file.on("error", (err) => {
+      try {
+        activeResponse?.destroy?.();
+      } catch {
+      }
+      failWith(writeFailed(err));
+    });
     const req = proto.get(url, (response) => {
+      activeResponse = response;
       if (response.statusCode !== 200) {
         try {
           response.destroy();
         } catch {
         }
-        try {
-          file.close();
-        } catch {
-        }
-        fs3.unlink(dest, () => {
-        });
-        done(new OniroError(`Failed to download '${url}' (HTTP ${response.statusCode})`));
+        failWith(new OniroError(`Failed to download '${url}' (HTTP ${response.statusCode})`));
         return;
       }
       const total = parseInt(response.headers["content-length"] || "0", 10);
+      if (total > 0) {
+        try {
+          ensureFreeSpace(opts.tmpRoot ?? destDir, total, what);
+        } catch (err) {
+          try {
+            response.destroy();
+          } catch {
+          }
+          failWith(err);
+          return;
+        }
+      }
       let downloaded = 0;
       let lastOverall = Math.round(s);
       response.on("data", (chunk) => {
@@ -345,38 +532,26 @@ async function downloadFile(opts) {
           const inc = endOverall - lastOverall;
           if (inc > 0) progress.report({ message: "Downloading: 100%", increment: inc });
         }
-        file.close((err) => err ? done(err) : done());
+        file.close((err) => err ? done(writeFailed(err)) : done());
       });
       abortSignal?.addEventListener("abort", () => {
         response.destroy();
-        file.close();
-        fs3.unlink(dest, () => {
-        });
-        done(new CancelledError("Download cancelled."));
+        failWith(new CancelledError("Download cancelled."));
       });
     });
     req.on("error", (err) => {
-      try {
-        file.close();
-      } catch {
-      }
-      fs3.unlink(dest, () => {
-      });
-      done(new OniroError(`Error downloading '${url}': ${err.message}`, err));
+      failWith(new OniroError(`Error downloading '${url}': ${err.message}`, err));
     });
     abortSignal?.addEventListener("abort", () => {
       req.destroy();
-      file.close();
-      fs3.unlink(dest, () => {
-      });
-      done(new CancelledError("Download cancelled."));
+      failWith(new CancelledError("Download cancelled."));
     });
   });
 }
 async function verifySha256(filePath, sha256Path) {
-  const expected = fs3.readFileSync(sha256Path, "utf8").split(/\s+/)[0];
+  const expected = fs4.readFileSync(sha256Path, "utf8").split(/\s+/)[0];
   const hash = crypto.createHash("sha256");
-  await pipelineAsync(fs3.createReadStream(filePath), hash);
+  await pipelineAsync(fs4.createReadStream(filePath), hash);
   const actual = hash.digest("hex");
   if (actual !== expected) {
     throw new ChecksumMismatchError(expected, actual);
@@ -384,9 +559,9 @@ async function verifySha256(filePath, sha256Path) {
 }
 
 // src/sdk/extract.ts
-import * as fs4 from "fs";
-import * as os4 from "os";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as os5 from "os";
+import * as path6 from "path";
 import { pipeline as pipeline2 } from "stream";
 import { promisify as promisify2 } from "util";
 import * as tar from "tar";
@@ -403,12 +578,12 @@ async function extractZipWithProgress(opts) {
   const r = Math.max(0, Math.min(100 - s, opts.range ?? 100));
   let processed = 0;
   let lastOverall = Math.round(s);
-  await fs4.promises.mkdir(dest, { recursive: true });
-  const destRoot = path4.resolve(dest);
+  await fs5.promises.mkdir(dest, { recursive: true });
+  const destRoot = path6.resolve(dest);
   const safeResolveTarget = (entryName) => {
-    const resolved = path4.resolve(destRoot, entryName);
-    const rel = path4.relative(destRoot, resolved);
-    if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+    const resolved = path6.resolve(destRoot, entryName);
+    const rel = path6.relative(destRoot, resolved);
+    if (rel.startsWith("..") || path6.isAbsolute(rel)) {
       throw new OniroError(`Blocked ZIP entry with illegal path: ${entryName}`);
     }
     return resolved;
@@ -420,25 +595,25 @@ async function extractZipWithProgress(opts) {
       const attr = file.attr ? file.attr >>> 16 : 0;
       const isSymlink = "isSymbolicLink" in file ? Boolean(file.isSymbolicLink) : (attr & 61440) === 40960;
       if (file.isDirectory) {
-        await fs4.promises.mkdir(targetPath, { recursive: true });
+        await fs5.promises.mkdir(targetPath, { recursive: true });
       } else if (isSymlink) {
-        await fs4.promises.mkdir(path4.dirname(targetPath), { recursive: true });
+        await fs5.promises.mkdir(path6.dirname(targetPath), { recursive: true });
         const linkTargetBuffer = await zip.entryData(file);
         const linkTarget = linkTargetBuffer.toString("utf8");
         try {
-          const isWin = os4.platform() === "win32";
-          await fs4.promises.symlink(linkTarget, targetPath, isWin ? "file" : void 0);
+          const isWin = os5.platform() === "win32";
+          await fs5.promises.symlink(linkTarget, targetPath, isWin ? "file" : void 0);
         } catch (e) {
           logger.warn(`Failed to create symlink at ${targetPath}: ${String(e)}`);
         }
       } else {
-        await fs4.promises.mkdir(path4.dirname(targetPath), { recursive: true });
+        await fs5.promises.mkdir(path6.dirname(targetPath), { recursive: true });
         const readStream = await zip.stream(file);
-        const writeStream = fs4.createWriteStream(targetPath);
+        const writeStream = fs5.createWriteStream(targetPath);
         await pipelineAsync2(readStream, writeStream);
         if (attr > 0) {
           try {
-            await fs4.promises.chmod(targetPath, attr & 511);
+            await fs5.promises.chmod(targetPath, attr & 511);
           } catch {
           }
         }
@@ -470,41 +645,41 @@ async function extractTarball(tarPath, dest, strip = 0) {
 }
 
 // src/sdk/list.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 function getSupportedSdksForUi(config) {
-  const base = path5.join(getSdkRootDir(config), getOsFolder());
+  const base = path7.join(getSdkRootDir(config), getOsFolder());
   return ALL_SDKS.map((sdk) => ({
     version: sdk.version,
     api: sdk.api,
-    installed: fs5.existsSync(path5.join(base, sdk.api))
+    installed: fs6.existsSync(path7.join(base, sdk.api))
   })).sort((a, b) => Number(b.api) - Number(a.api));
 }
 function getInstalledSdks(config) {
   const sdkRoot = getSdkRootDir(config);
   const versions = /* @__PURE__ */ new Set();
-  if (!fs5.existsSync(sdkRoot)) return [];
+  if (!fs6.existsSync(sdkRoot)) return [];
   for (const osFolder of ["linux", "darwin", "windows"]) {
-    const osPath = path5.join(sdkRoot, osFolder);
-    if (!fs5.existsSync(osPath) || !fs5.statSync(osPath).isDirectory()) continue;
-    for (const api of fs5.readdirSync(osPath)) {
-      const apiPath = path5.join(osPath, api);
-      if (fs5.statSync(apiPath).isDirectory()) versions.add(api);
+    const osPath = path7.join(sdkRoot, osFolder);
+    if (!fs6.existsSync(osPath) || !fs6.statSync(osPath).isDirectory()) continue;
+    for (const api of fs6.readdirSync(osPath)) {
+      const apiPath = path7.join(osPath, api);
+      if (fs6.statSync(apiPath).isDirectory()) versions.add(api);
     }
   }
   return ALL_SDKS.filter((sdk) => versions.has(sdk.api)).map((sdk) => sdk.version);
 }
 
 // src/sdk/remove.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 function removeSdk(config, api) {
   const sdkRoot = getSdkRootDir(config);
   let removed = false;
   for (const osFolder of ["linux", "darwin", "windows"]) {
-    const sdkPath = path6.join(sdkRoot, osFolder, api);
-    if (fs6.existsSync(sdkPath)) {
-      fs6.rmSync(sdkPath, { recursive: true, force: true });
+    const sdkPath = path8.join(sdkRoot, osFolder, api);
+    if (fs7.existsSync(sdkPath)) {
+      fs7.rmSync(sdkPath, { recursive: true, force: true });
       removed = true;
     }
   }
@@ -512,19 +687,18 @@ function removeSdk(config, api) {
 }
 
 // src/sdk/install.ts
-import * as fs8 from "fs";
-import * as os5 from "os";
-import * as path7 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 
 // src/sdk/move.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 function movePath(src, dest) {
   try {
-    fs7.renameSync(src, dest);
+    fs8.renameSync(src, dest);
   } catch (err) {
     if (err.code !== "EXDEV") throw err;
-    fs7.cpSync(src, dest, { recursive: true });
-    fs7.rmSync(src, { recursive: true, force: true });
+    fs8.cpSync(src, dest, { recursive: true });
+    fs8.rmSync(src, { recursive: true, force: true });
   }
 }
 
@@ -536,21 +710,29 @@ async function downloadAndInstallSdk(opts) {
   const urlBase = config.get("sdkUrlBase", OHOS_URL_BASE);
   const downloadUrl = `${urlBase}/${version}-Release/${filename}`;
   const sha256Url = `${downloadUrl}.sha256`;
-  const tmpDir = fs8.mkdtempSync(path7.join(os5.tmpdir(), "oniro-sdk-"));
-  const tarPath = path7.join(tmpDir, filename);
-  const sha256Path = path7.join(tmpDir, `${filename}.sha256`);
-  const extractDir = path7.join(tmpDir, "extract");
-  fs8.mkdirSync(extractDir);
-  const sdkInstallDir = path7.join(getSdkRootDir(config), osFolder, api);
-  fs8.mkdirSync(path7.dirname(sdkInstallDir), { recursive: true });
+  const what = `the SDK ${version} install`;
+  const sdkRoot = getSdkRootDir(config);
+  const { dir: tmpDir, root: tmpRoot } = createInstallTempDir({
+    config,
+    override: opts.tmpDir,
+    installRoot: sdkRoot,
+    prefix: "oniro-sdk-",
+    logger
+  });
+  const tarPath = path9.join(tmpDir, filename);
+  const sha256Path = path9.join(tmpDir, `${filename}.sha256`);
+  const extractDir = path9.join(tmpDir, "extract");
+  fs9.mkdirSync(extractDir);
+  const sdkInstallDir = path9.join(sdkRoot, osFolder, api);
+  fs9.mkdirSync(path9.dirname(sdkInstallDir), { recursive: true });
   const checkCancelled = () => {
     if (abortSignal?.aborted) throw new CancelledError();
   };
   try {
     progress?.report({ message: "Downloading SDK archive...", increment: 0 });
-    await downloadFile({ url: downloadUrl, dest: tarPath, progress, abortSignal, start: 0, range: 35 });
+    await downloadFile({ url: downloadUrl, dest: tarPath, progress, abortSignal, start: 0, range: 35, what, tmpRoot });
     progress?.report({ message: "Downloading checksum...", increment: 0 });
-    await downloadFile({ url: sha256Url, dest: sha256Path, progress, abortSignal, start: 35, range: 10 });
+    await downloadFile({ url: sha256Url, dest: sha256Path, progress, abortSignal, start: 35, range: 10, what, tmpRoot });
     progress?.report({ message: "Verifying checksum...", increment: 0 });
     await verifySha256(tarPath, sha256Path);
     progress?.report({ message: "Verifying checksum...", increment: 5 });
@@ -559,13 +741,13 @@ async function downloadAndInstallSdk(opts) {
     await extractTarball(tarPath, extractDir, strip);
     progress?.report({ message: "Extracting SDK (this may take a while)...", increment: 10 });
     checkCancelled();
-    const osContentPath = path7.join(extractDir, osFolder);
-    if (!fs8.existsSync(osContentPath)) {
+    const osContentPath = path9.join(extractDir, osFolder);
+    if (!fs9.existsSync(osContentPath)) {
       throw new OniroError(
         `Expected folder '${osFolder}' not found in extracted SDK. Tarball layout may have changed.`
       );
     }
-    const zipFiles = fs8.readdirSync(osContentPath).filter((n2) => n2.endsWith(".zip"));
+    const zipFiles = fs9.readdirSync(osContentPath).filter((n2) => n2.endsWith(".zip"));
     const componentsStart = 60;
     const componentsBudget = 35;
     const n = zipFiles.length;
@@ -580,39 +762,40 @@ async function downloadAndInstallSdk(opts) {
     for (const zipFile of zipFiles) {
       checkCancelled();
       logger.info(`Extracting component ${zipFile}`);
-      const zipPath = path7.join(osContentPath, zipFile);
+      const zipPath = path9.join(osContentPath, zipFile);
       const thisBudget = base + (rem > 0 ? 1 : 0);
       if (rem > 0) rem--;
       await extractZipWithProgress({ zipPath, dest: osContentPath, progress, start: cursor, range: thisBudget, logger });
       cursor += thisBudget;
-      fs8.unlinkSync(zipPath);
+      fs9.unlinkSync(zipPath);
     }
     progress?.report({ message: "Finalizing installation...", increment: 0 });
-    if (fs8.existsSync(sdkInstallDir)) {
-      fs8.rmSync(sdkInstallDir, { recursive: true, force: true });
+    if (fs9.existsSync(sdkInstallDir)) {
+      fs9.rmSync(sdkInstallDir, { recursive: true, force: true });
     }
     movePath(osContentPath, sdkInstallDir);
     progress?.report({ message: "Finalizing installation...", increment: 3 });
     progress?.report({ message: "Cleaning up...", increment: 0 });
-    fs8.rmSync(tmpDir, { recursive: true, force: true });
+    removeTempWorkDir(tmpDir, tmpRoot);
     progress?.report({ message: "Cleaning up...", increment: 2 });
   } catch (err) {
-    logger.error(`SDK install failed: ${err instanceof Error ? err.message : String(err)}`);
-    fs8.rmSync(tmpDir, { recursive: true, force: true });
-    throw err;
+    const wrapped = toSpaceError(err, tmpRoot, what);
+    logger.error(`SDK install failed: ${wrapped instanceof Error ? wrapped.message : String(wrapped)}`);
+    removeTempWorkDir(tmpDir, tmpRoot);
+    throw wrapped;
   }
 }
 
 // src/cmdTools/install.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as os6 from "os";
-import * as path8 from "path";
+import * as path10 from "path";
 import { execFileSync } from "child_process";
-function getCmdToolsDownloadUrl(config, platform6 = os6.platform()) {
-  if (platform6 === "linux") {
+function getCmdToolsDownloadUrl(config, platform7 = os6.platform()) {
+  if (platform7 === "linux") {
     return config.get("cmdToolsUrlLinux", defaultPaths.cmdToolsUrlLinux);
   }
-  if (platform6 === "win32") {
+  if (platform7 === "win32") {
     const url = config.get("cmdToolsUrlWindows", "");
     if (!url) {
       throw new OniroError(
@@ -621,7 +804,7 @@ function getCmdToolsDownloadUrl(config, platform6 = os6.platform()) {
     }
     return url;
   }
-  if (platform6 === "darwin") {
+  if (platform7 === "darwin") {
     const url = config.get("cmdToolsUrlMac", "");
     if (!url) {
       throw new OniroError(
@@ -630,20 +813,20 @@ function getCmdToolsDownloadUrl(config, platform6 = os6.platform()) {
     }
     return url;
   }
-  throw new UnsupportedPlatformError(platform6);
+  throw new UnsupportedPlatformError(platform7);
 }
 function findCmdToolsSourceDir(extractPath) {
   const known = [
-    path8.join(extractPath, "command-line-tools"),
-    path8.join(extractPath, "oh-command-line-tools"),
-    path8.join(extractPath, "commandline-tools")
+    path10.join(extractPath, "command-line-tools"),
+    path10.join(extractPath, "oh-command-line-tools"),
+    path10.join(extractPath, "commandline-tools")
   ];
   for (const c of known) {
-    if (fs9.existsSync(c)) return c;
+    if (fs10.existsSync(c)) return c;
   }
-  const entries = fs9.readdirSync(extractPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path8.join(extractPath, e.name));
+  const entries = fs10.readdirSync(extractPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path10.join(extractPath, e.name));
   for (const dir of entries) {
-    if (fs9.existsSync(path8.join(dir, "bin"))) return dir;
+    if (fs10.existsSync(path10.join(dir, "bin"))) return dir;
   }
   throw new OniroError("Could not locate command line tools folder in the extracted archive.");
 }
@@ -651,53 +834,62 @@ async function installCmdTools(opts) {
   const { config, progress, abortSignal } = opts;
   const logger = opts.logger ?? noopLogger;
   const CMD_PATH = getCmdToolsPath(config);
-  const tmpDir = fs9.mkdtempSync(path8.join(os6.tmpdir(), "oniro-cmdtools-"));
-  const zipPath = opts.localZipPath ?? path8.join(tmpDir, "oh-command-line-tools.zip");
-  const extractPath = path8.join(tmpDir, "oh-command-line-tools");
+  const what = "the command-line tools install";
+  const { dir: tmpDir, root: tmpRoot } = createInstallTempDir({
+    config,
+    override: opts.tmpDir,
+    installRoot: path10.dirname(CMD_PATH),
+    prefix: "oniro-cmdtools-",
+    logger
+  });
+  const zipPath = opts.localZipPath ?? path10.join(tmpDir, "oh-command-line-tools.zip");
+  const extractPath = path10.join(tmpDir, "oh-command-line-tools");
   try {
     if (!opts.localZipPath) {
       const url = getCmdToolsDownloadUrl(config);
       progress?.report({ message: "Downloading command line tools...", increment: 0 });
-      await downloadFile({ url, dest: zipPath, progress, abortSignal, start: 0, range: 50 });
+      await downloadFile({ url, dest: zipPath, progress, abortSignal, start: 0, range: 50, what, tmpRoot });
     }
     progress?.report({ message: "Extracting tools...", increment: 0 });
     await extractZipWithProgress({ zipPath, dest: extractPath, progress, start: 50, range: 45, logger });
-    fs9.mkdirSync(CMD_PATH, { recursive: true });
+    fs10.mkdirSync(CMD_PATH, { recursive: true });
     const srcDir = findCmdToolsSourceDir(extractPath);
-    for (const entry of fs9.readdirSync(srcDir)) {
-      const src = path8.join(srcDir, entry);
-      const dest = path8.join(CMD_PATH, entry);
-      if (fs9.statSync(src).isDirectory()) {
-        if (fs9.existsSync(dest)) fs9.rmSync(dest, { recursive: true, force: true });
+    for (const entry of fs10.readdirSync(srcDir)) {
+      const src = path10.join(srcDir, entry);
+      const dest = path10.join(CMD_PATH, entry);
+      if (fs10.statSync(src).isDirectory()) {
+        if (fs10.existsSync(dest)) fs10.rmSync(dest, { recursive: true, force: true });
         movePath(src, dest);
       } else {
-        fs9.copyFileSync(src, dest);
+        fs10.copyFileSync(src, dest);
       }
     }
-    const binDir = path8.join(CMD_PATH, "bin");
-    if (fs9.existsSync(binDir) && os6.platform() !== "win32") {
-      for (const file of fs9.readdirSync(binDir)) {
-        fs9.chmodSync(path8.join(binDir, file), 493);
+    const binDir = path10.join(CMD_PATH, "bin");
+    if (fs10.existsSync(binDir) && os6.platform() !== "win32") {
+      for (const file of fs10.readdirSync(binDir)) {
+        fs10.chmodSync(path10.join(binDir, file), 493);
       }
     }
     progress?.report({ message: "Finalizing installation...", increment: 5 });
     progress?.report({ message: "Cleaning up...", increment: 0 });
+  } catch (err) {
+    throw toSpaceError(err, tmpRoot, what);
   } finally {
-    fs9.rmSync(tmpDir, { recursive: true, force: true });
+    removeTempWorkDir(tmpDir, tmpRoot);
   }
 }
 function getCmdToolsStatus(config) {
   const cmdPath = getCmdToolsPath(config);
-  const binDir = path8.join(cmdPath, "bin");
+  const binDir = path10.join(cmdPath, "bin");
   const candidates = os6.platform() === "win32" ? ["ohpm.exe", "ohpm.cmd", "ohpm.bat", "ohpm"] : ["ohpm"];
-  const bin = candidates.map((c) => path8.join(binDir, c)).find((p) => fs9.existsSync(p));
+  const bin = candidates.map((c) => path10.join(binDir, c)).find((p) => fs10.existsSync(p));
   if (!bin) {
     return { installed: false, status: "Not installed" };
   }
   try {
-    const versionFile = path8.join(cmdPath, "version.txt");
-    if (fs9.existsSync(versionFile)) {
-      const content = fs9.readFileSync(versionFile, "utf8");
+    const versionFile = path10.join(cmdPath, "version.txt");
+    if (fs10.existsSync(versionFile)) {
+      const content = fs10.readFileSync(versionFile, "utf8");
       for (const line of content.split(/\r?\n/)) {
         const m = line.match(/^\s*#\s*Version:\s*(.+)$/);
         if (m?.[1]) return { installed: true, status: `Installed (${m[1].trim()})` };
@@ -717,14 +909,14 @@ function isCmdToolsInstalled(config) {
 }
 function removeCmdTools(config) {
   const cmdPath = getCmdToolsPath(config);
-  if (fs9.existsSync(cmdPath)) {
-    fs9.rmSync(cmdPath, { recursive: true, force: true });
+  if (fs10.existsSync(cmdPath)) {
+    fs10.rmSync(cmdPath, { recursive: true, force: true });
   }
 }
 
 // src/sign/encryptKey.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 import * as crypto2 from "crypto";
 var DAEMON_ROOT_KEY_COMPONENT_LENGTH = 16;
 var DAEMON_SALT_KEY_LENGTH = 16;
@@ -796,33 +988,33 @@ function getRootKey(fdComponents, salt) {
 function createAndStoreKey(dir, keyLength) {
   const key = crypto2.randomBytes(keyLength);
   const hash = crypto2.createHash("sha256").update(key).digest("hex");
-  const filePath = path9.join(dir, hash);
-  fs10.writeFileSync(filePath, key);
-  fs10.chmodSync(filePath, KEY_FILE_PERMISSIONS);
+  const filePath = path11.join(dir, hash);
+  fs11.writeFileSync(filePath, key);
+  fs11.chmodSync(filePath, KEY_FILE_PERMISSIONS);
   return key;
 }
 function createAndStoreEnKey(rootKey, ceDir) {
   const workKey = crypto2.randomBytes(DAEMON_WORK_KEY_LENGTH);
   const encrypted = encrypt(rootKey, workKey);
   const hash = crypto2.createHash("sha256").update(encrypted).digest("hex");
-  const filePath = path9.join(ceDir, hash);
-  fs10.writeFileSync(filePath, encrypted);
-  fs10.chmodSync(filePath, KEY_FILE_PERMISSIONS);
+  const filePath = path11.join(ceDir, hash);
+  fs11.writeFileSync(filePath, encrypted);
+  fs11.chmodSync(filePath, KEY_FILE_PERMISSIONS);
 }
 function createMaterial(materialPath) {
-  fs10.mkdirSync(materialPath, { recursive: true });
-  fs10.chmodSync(materialPath, KEY_FILE_DIRECTORY_PERMISSIONS);
-  const fdDir = path9.join(materialPath, "fd");
-  const acDir = path9.join(materialPath, "ac");
-  const ceDir = path9.join(materialPath, "ce");
-  fs10.mkdirSync(fdDir, { recursive: true });
-  fs10.mkdirSync(acDir, { recursive: true });
-  fs10.mkdirSync(ceDir, { recursive: true });
+  fs11.mkdirSync(materialPath, { recursive: true });
+  fs11.chmodSync(materialPath, KEY_FILE_DIRECTORY_PERMISSIONS);
+  const fdDir = path11.join(materialPath, "fd");
+  const acDir = path11.join(materialPath, "ac");
+  const ceDir = path11.join(materialPath, "ce");
+  fs11.mkdirSync(fdDir, { recursive: true });
+  fs11.mkdirSync(acDir, { recursive: true });
+  fs11.mkdirSync(ceDir, { recursive: true });
   const fdSubDirs = ["0", "1", "2"];
   const fdComponents = [];
   for (const sub of fdSubDirs) {
-    const subDir = path9.join(fdDir, sub);
-    fs10.mkdirSync(subDir, { recursive: true });
+    const subDir = path11.join(fdDir, sub);
+    fs11.mkdirSync(subDir, { recursive: true });
     const comp = createAndStoreKey(subDir, DAEMON_ROOT_KEY_COMPONENT_LENGTH);
     fdComponents.push(comp);
   }
@@ -831,24 +1023,24 @@ function createMaterial(materialPath) {
   createAndStoreEnKey(rootKey, ceDir);
 }
 function readSingleFile(dir) {
-  if (!fs10.existsSync(dir) || !fs10.statSync(dir).isDirectory()) {
+  if (!fs11.existsSync(dir) || !fs11.statSync(dir).isDirectory()) {
     throw new Error(`Missing signing material directory: ${dir}`);
   }
-  const files = fs10.readdirSync(dir).filter((f) => f !== ".DS_Store");
+  const files = fs11.readdirSync(dir).filter((f) => f !== ".DS_Store");
   if (files.length !== 1) {
     throw new Error(`Signing material in ${dir} is illegal (expected exactly one file).`);
   }
-  return fs10.readFileSync(path9.join(dir, files[0]));
+  return fs11.readFileSync(path11.join(dir, files[0]));
 }
 function getKey(materialPath) {
-  if (!fs10.existsSync(materialPath) || !fs10.statSync(materialPath).isDirectory()) {
+  if (!fs11.existsSync(materialPath) || !fs11.statSync(materialPath).isDirectory()) {
     throw new Error("Material directory does not exist.");
   }
-  const fdDir = path9.join(materialPath, "fd");
-  const fdComponents = ["0", "1", "2"].map((sub) => readSingleFile(path9.join(fdDir, sub)));
-  const salt = readSingleFile(path9.join(materialPath, "ac"));
+  const fdDir = path11.join(materialPath, "fd");
+  const fdComponents = ["0", "1", "2"].map((sub) => readSingleFile(path11.join(fdDir, sub)));
+  const salt = readSingleFile(path11.join(materialPath, "ac"));
   const rootKey = getRootKey(fdComponents, salt);
-  const workMaterial = readSingleFile(path9.join(materialPath, "ce"));
+  const workMaterial = readSingleFile(path11.join(materialPath, "ce"));
   return decrypt(rootKey, workMaterial);
 }
 function encryptPwd(password, materialPath) {
@@ -863,8 +1055,8 @@ function decryptPwd(encryptedHex, materialPath) {
 }
 
 // src/sign/generateSigningConfigs.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import JSON52 from "json5";
 
@@ -934,17 +1126,17 @@ var SIGNING_KIND_CONFIG = {
 };
 function copyFilesToProject(projectDir, paths, kind, logger, applicationCertPath) {
   logger.info("[sign] Copying signing material into project...");
-  const signaturesDir = path10.join(projectDir, "signatures");
-  fs11.mkdirSync(signaturesDir, { recursive: true });
-  fs11.copyFileSync(paths.keystore, path10.join(signaturesDir, "OpenHarmony.p12"));
-  fs11.copyFileSync(paths.profileCert, path10.join(signaturesDir, "OpenHarmonyProfileRelease.pem"));
-  fs11.copyFileSync(paths.unsignedProfileTemplate, path10.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json"));
+  const signaturesDir = path12.join(projectDir, "signatures");
+  fs12.mkdirSync(signaturesDir, { recursive: true });
+  fs12.copyFileSync(paths.keystore, path12.join(signaturesDir, "OpenHarmony.p12"));
+  fs12.copyFileSync(paths.profileCert, path12.join(signaturesDir, "OpenHarmonyProfileRelease.pem"));
+  fs12.copyFileSync(paths.unsignedProfileTemplate, path12.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json"));
   if (kind === "application-release") {
-    const dest = path10.join(signaturesDir, "OpenHarmonyApplication.cer");
+    const dest = path12.join(signaturesDir, "OpenHarmonyApplication.cer");
     if (applicationCertPath) {
-      fs11.copyFileSync(applicationCertPath, dest);
+      fs12.copyFileSync(applicationCertPath, dest);
     } else {
-      fs11.writeFileSync(dest, OPEN_HARMONY_APPLICATION_CERT);
+      fs12.writeFileSync(dest, OPEN_HARMONY_APPLICATION_CERT);
     }
   }
 }
@@ -953,7 +1145,7 @@ function resolveAppFeature(apl, override) {
   return apl === "normal" ? "hos_normal_app" : "hos_system_app";
 }
 function extractLeafCertificate(chainPath) {
-  const certContent = fs11.readFileSync(chainPath, "utf-8");
+  const certContent = fs12.readFileSync(chainPath, "utf-8");
   const parts = certContent.split("-----END CERTIFICATE-----");
   if (parts.length < 3) {
     throw new OniroError(`${chainPath} does not contain enough certificates.`);
@@ -963,20 +1155,20 @@ function extractLeafCertificate(chainPath) {
 function modifyProfileTemplate(projectDir, apl, appFeature, logger, options = {}) {
   const kind = options.kind ?? pickSigningKind(apl);
   logger.info(`[sign] Modifying profile template (apl=${apl}, app-feature=${appFeature}, kind=${kind})...`);
-  const appJsonPath = path10.join(projectDir, "AppScope/app.json5");
-  const profileTemplatePath = path10.join(projectDir, "signatures/UnsgnedReleasedProfileTemplate.json");
-  if (!fs11.existsSync(appJsonPath)) {
+  const appJsonPath = path12.join(projectDir, "AppScope/app.json5");
+  const profileTemplatePath = path12.join(projectDir, "signatures/UnsgnedReleasedProfileTemplate.json");
+  if (!fs12.existsSync(appJsonPath)) {
     throw new OniroError(`${appJsonPath} does not exist.`);
   }
   let appJson;
   try {
-    appJson = JSON52.parse(fs11.readFileSync(appJsonPath, "utf-8"));
+    appJson = JSON52.parse(fs12.readFileSync(appJsonPath, "utf-8"));
   } catch (e) {
     throw new OniroError(`Error parsing ${appJsonPath}: ${e.message}`, e);
   }
   let profileTemplate;
   try {
-    profileTemplate = JSON.parse(fs11.readFileSync(profileTemplatePath, "utf-8"));
+    profileTemplate = JSON.parse(fs12.readFileSync(profileTemplatePath, "utf-8"));
   } catch (e) {
     throw new OniroError(`Error parsing ${profileTemplatePath}: ${e.message}`, e);
   }
@@ -989,7 +1181,7 @@ function modifyProfileTemplate(projectDir, apl, appFeature, logger, options = {}
   profileTemplate["bundle-info"]["bundle-name"] = appJson.app.bundleName;
   profileTemplate["bundle-info"]["apl"] = apl;
   profileTemplate["bundle-info"]["app-feature"] = appFeature;
-  const distCertChainPath = path10.join(
+  const distCertChainPath = path12.join(
     projectDir,
     "signatures",
     SIGNING_KIND_CONFIG[kind].certBasename
@@ -999,13 +1191,13 @@ function modifyProfileTemplate(projectDir, apl, appFeature, logger, options = {}
     profileTemplate.acls = profileTemplate.acls ?? {};
     profileTemplate.acls["allowed-acls"] = options.acls;
   }
-  fs11.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
+  fs12.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
 }
 function generateP7bFile(projectDir, paths, logger, passwords) {
   logger.info("[sign] Generating P7b profile via hap-sign-tool...");
-  const signaturesDir = path10.join(projectDir, "signatures");
-  const profileTemplatePath = path10.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json");
-  const outputProfilePath = path10.join(signaturesDir, "app1-profile.p7b");
+  const signaturesDir = path12.join(projectDir, "signatures");
+  const profileTemplatePath = path12.join(signaturesDir, "UnsgnedReleasedProfileTemplate.json");
+  const outputProfilePath = path12.join(signaturesDir, "app1-profile.p7b");
   const args = [
     "-jar",
     paths.signTool,
@@ -1039,11 +1231,11 @@ function generateP7bFile(projectDir, paths, logger, passwords) {
   }
 }
 function detectSigningConfigNames(projectDir) {
-  const buildProfilePath = path10.join(projectDir, "build-profile.json5");
-  if (!fs11.existsSync(buildProfilePath)) return ["default"];
+  const buildProfilePath = path12.join(projectDir, "build-profile.json5");
+  if (!fs12.existsSync(buildProfilePath)) return ["default"];
   let parsed;
   try {
-    parsed = JSON52.parse(fs11.readFileSync(buildProfilePath, "utf-8"));
+    parsed = JSON52.parse(fs12.readFileSync(buildProfilePath, "utf-8"));
   } catch {
     return ["default"];
   }
@@ -1060,14 +1252,14 @@ function detectSigningConfigNames(projectDir) {
 }
 function updateBuildProfile(projectDir, kind, logger, passwords) {
   logger.info("[sign] Writing signing configs into build-profile.json5...");
-  const materialDir = path10.join(projectDir, "signatures", "material");
-  const buildProfilePath = path10.join(projectDir, "build-profile.json5");
+  const materialDir = path12.join(projectDir, "signatures", "material");
+  const buildProfilePath = path12.join(projectDir, "build-profile.json5");
   const encryptedStorePassword = encryptPwd(passwords.store, materialDir);
   const encryptedKeyPassword = encryptPwd(passwords.key, materialDir);
   let buildProfile = { app: {} };
-  if (fs11.existsSync(buildProfilePath)) {
+  if (fs12.existsSync(buildProfilePath)) {
     try {
-      buildProfile = JSON52.parse(fs11.readFileSync(buildProfilePath, "utf-8"));
+      buildProfile = JSON52.parse(fs12.readFileSync(buildProfilePath, "utf-8"));
     } catch (e) {
       throw new OniroError(`Error parsing ${buildProfilePath}: ${e.message}`, e);
     }
@@ -1088,13 +1280,13 @@ function updateBuildProfile(projectDir, kind, logger, passwords) {
       storeFile: "./signatures/OpenHarmony.p12"
     }
   }));
-  fs11.writeFileSync(buildProfilePath, JSON.stringify(buildProfile, null, 2));
+  fs12.writeFileSync(buildProfilePath, JSON.stringify(buildProfile, null, 2));
 }
 function prepareMaterialDirectory(projectDir, logger) {
   logger.info("[sign] Generating fresh signing material...");
-  const materialDir = path10.join(projectDir, "signatures", "material");
-  if (fs11.existsSync(materialDir)) {
-    fs11.rmSync(materialDir, { recursive: true, force: true });
+  const materialDir = path12.join(projectDir, "signatures", "material");
+  if (fs12.existsSync(materialDir)) {
+    fs12.rmSync(materialDir, { recursive: true, force: true });
   }
   createMaterial(materialDir);
 }
@@ -1117,15 +1309,15 @@ function generateSigningConfigs(options) {
       "Could not detect project SDK version (compileSdkVersion missing in build-profile.json5)."
     );
   }
-  const sdkPath = path10.join(sdkHome, String(sdkVersion));
-  if (!fs11.existsSync(sdkPath)) {
+  const sdkPath = path12.join(sdkHome, String(sdkVersion));
+  if (!fs12.existsSync(sdkPath)) {
     throw new OniroError(`SDK path does not exist: ${sdkPath}`);
   }
   const paths = {
-    signTool: path10.join(sdkPath, "toolchains/lib/hap-sign-tool.jar"),
-    keystore: path10.join(sdkPath, "toolchains/lib/OpenHarmony.p12"),
-    profileCert: path10.join(sdkPath, "toolchains/lib/OpenHarmonyProfileRelease.pem"),
-    unsignedProfileTemplate: path10.join(sdkPath, "toolchains/lib/UnsgnedReleasedProfileTemplate.json")
+    signTool: path12.join(sdkPath, "toolchains/lib/hap-sign-tool.jar"),
+    keystore: path12.join(sdkPath, "toolchains/lib/OpenHarmony.p12"),
+    profileCert: path12.join(sdkPath, "toolchains/lib/OpenHarmonyProfileRelease.pem"),
+    unsignedProfileTemplate: path12.join(sdkPath, "toolchains/lib/UnsgnedReleasedProfileTemplate.json")
   };
   const kind = pickSigningKind(apl);
   const passwords = options.passwords ?? DEFAULT_PASSWORDS;
@@ -1139,46 +1331,54 @@ function generateSigningConfigs(options) {
 }
 
 // src/emulator/install.ts
-import * as fs12 from "fs";
-import * as os7 from "os";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 async function installEmulator(opts) {
   const { config, progress, abortSignal } = opts;
   const logger = opts.logger ?? noopLogger;
   const url = config.get("emulatorUrl", defaultPaths.emulatorUrl);
   const emulatorDir = getEmulatorDir(config);
-  const tmpDir = fs12.mkdtempSync(path11.join(os7.tmpdir(), "oniro-emulator-"));
-  const tmpZip = path11.join(tmpDir, "oniro_emulator.zip");
+  const what = "the emulator install";
+  const { dir: tmpDir, root: tmpRoot } = createInstallTempDir({
+    config,
+    override: opts.tmpDir,
+    installRoot: path13.dirname(emulatorDir),
+    prefix: "oniro-emulator-",
+    logger
+  });
+  const tmpZip = path13.join(tmpDir, "oniro_emulator.zip");
   try {
-    fs12.mkdirSync(emulatorDir, { recursive: true });
+    fs13.mkdirSync(emulatorDir, { recursive: true });
     progress?.report({ message: "Downloading emulator...", increment: 0 });
-    await downloadFile({ url, dest: tmpZip, progress, abortSignal, start: 0, range: 50 });
+    await downloadFile({ url, dest: tmpZip, progress, abortSignal, start: 0, range: 50, what, tmpRoot });
     progress?.report({ message: "Extracting emulator...", increment: 0 });
     await extractZipWithProgress({ zipPath: tmpZip, dest: emulatorDir, progress, start: 50, range: 45, logger });
-    const runSh = path11.join(emulatorDir, "images", "run.sh");
-    if (fs12.existsSync(runSh)) {
-      fs12.chmodSync(runSh, 493);
+    const runSh = path13.join(emulatorDir, "images", "run.sh");
+    if (fs13.existsSync(runSh)) {
+      fs13.chmodSync(runSh, 493);
     }
     progress?.report({ message: "Finalizing installation...", increment: 5 });
+  } catch (err) {
+    throw toSpaceError(err, tmpRoot, what);
   } finally {
-    fs12.rmSync(tmpDir, { recursive: true, force: true });
+    removeTempWorkDir(tmpDir, tmpRoot);
   }
 }
 function isEmulatorInstalled(config) {
-  const imagesDir = path11.join(getEmulatorDir(config), "images");
-  return fs12.existsSync(path11.join(imagesDir, "run.sh")) || fs12.existsSync(path11.join(imagesDir, "run.bat"));
+  const imagesDir = path13.join(getEmulatorDir(config), "images");
+  return fs13.existsSync(path13.join(imagesDir, "run.sh")) || fs13.existsSync(path13.join(imagesDir, "run.bat"));
 }
 function removeEmulator(config) {
   const emulatorDir = getEmulatorDir(config);
-  if (fs12.existsSync(emulatorDir)) {
-    fs12.rmSync(emulatorDir, { recursive: true, force: true });
+  if (fs13.existsSync(emulatorDir)) {
+    fs13.rmSync(emulatorDir, { recursive: true, force: true });
   }
 }
 
 // src/emulator/lifecycle.ts
-import * as fs13 from "fs";
-import * as os8 from "os";
-import * as path12 from "path";
+import * as fs14 from "fs";
+import * as os7 from "os";
+import * as path14 from "path";
 import { spawn as spawn2 } from "child_process";
 
 // src/hdc/exec.ts
@@ -1187,7 +1387,7 @@ function runProcess(opts) {
   const { command, args, cwd, env, onOutput } = opts;
   const timeoutMs = opts.timeoutMs ?? 6e4;
   const { abortSignal } = opts;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     if (abortSignal?.aborted) {
       reject(new CancelledError(`Command aborted before start: ${command}`));
       return;
@@ -1248,7 +1448,7 @@ ${stderr.trim()}` : "")
         );
         return;
       }
-      resolve2({ code: code ?? -1, stdout, stderr });
+      resolve4({ code: code ?? -1, stdout, stderr });
     });
   });
 }
@@ -1274,9 +1474,29 @@ function ensureOk(result, command) {
   }
   return result;
 }
+var REMOTE_RC_RE = /__ONIRO_RC=(-?\d+)__/g;
+function parseRemoteExit(stdout) {
+  let code = null;
+  for (const m of stdout.matchAll(REMOTE_RC_RE)) code = Number(m[1]);
+  if (code === null) return null;
+  return { code, stdout: stdout.replace(REMOTE_RC_RE, "").replace(/[ \t\r\n]+$/, "") };
+}
+async function shellChecked(opts) {
+  const { command, ...rest } = opts;
+  const res = await hdcExec({ ...rest, args: ["shell", `${command}; echo "__ONIRO_RC=$?__"`] });
+  const parsed = parseRemoteExit(res.stdout);
+  if (!parsed) return res;
+  return { code: parsed.code, stdout: parsed.stdout, stderr: res.stderr };
+}
+function ensureRemoteOk(result, command) {
+  if (result.code !== 0) {
+    throw new CommandFailedError(command, result.code, result.stderr.trim() || result.stdout.trim());
+  }
+  return result;
+}
 
 // src/emulator/lifecycle.ts
-var PID_FILE = path12.join(os8.tmpdir(), "oniro_emulator.pid");
+var PID_FILE = path14.join(os7.tmpdir(), "oniro_emulator.pid");
 async function attemptHdcConnection(config, address = "127.0.0.1:55555", logger = noopLogger) {
   try {
     await hdcExec({ config, args: ["start", "-r"], logger });
@@ -1289,24 +1509,24 @@ async function attemptHdcConnection(config, address = "127.0.0.1:55555", logger
   }
 }
 function resolveLauncher(imagesPath, headless, connect) {
-  const runSh = path12.join(imagesPath, "run.sh");
-  const runBat = path12.join(imagesPath, "run.bat");
+  const runSh = path14.join(imagesPath, "run.sh");
+  const runBat = path14.join(imagesPath, "run.bat");
   const extra = [];
   if (headless) extra.push("--headless");
   if (connect) extra.push("--connect", connect);
-  if (os8.platform() === "win32") {
-    if (fs13.existsSync(runBat)) {
+  if (os7.platform() === "win32") {
+    if (fs14.existsSync(runBat)) {
       return { command: "cmd.exe", args: ["/c", runBat, ...extra], cwd: imagesPath };
     }
-    if (fs13.existsSync(runSh)) {
+    if (fs14.existsSync(runSh)) {
       return { command: "bash", args: [runSh, ...extra], cwd: imagesPath };
     }
     throw new OniroError(`No emulator launcher (run.bat or run.sh) found in ${imagesPath}.`);
   }
-  if (fs13.existsSync(runSh)) {
+  if (fs14.existsSync(runSh)) {
     return { command: "bash", args: [runSh, ...extra], cwd: imagesPath };
   }
-  if (fs13.existsSync(runBat)) {
+  if (fs14.existsSync(runBat)) {
     return { command: "bash", args: [runBat, ...extra], cwd: imagesPath };
   }
   throw new OniroError(`No emulator launcher (run.sh or run.bat) found in ${imagesPath}.`);
@@ -1314,9 +1534,9 @@ function resolveLauncher(imagesPath, headless, connect) {
 async function startEmulator(opts) {
   const { config } = opts;
   const logger = opts.logger ?? noopLogger;
-  if (os8.platform() !== "win32" && fs13.existsSync(PID_FILE)) {
+  if (os7.platform() !== "win32" && fs14.existsSync(PID_FILE)) {
     try {
-      const pid = Number(fs13.readFileSync(PID_FILE, "utf8").trim());
+      const pid = Number(fs14.readFileSync(PID_FILE, "utf8").trim());
       if (Number.isFinite(pid) && pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1332,13 +1552,13 @@ async function startEmulator(opts) {
       logger.warn(`Could not read PID file: ${err.message}`);
     }
   }
-  const imagesPath = path12.join(getEmulatorDir(config), "images");
-  if (!fs13.existsSync(imagesPath)) {
+  const imagesPath = path14.join(getEmulatorDir(config), "images");
+  if (!fs14.existsSync(imagesPath)) {
     throw new OniroError(`Emulator images directory not found at ${imagesPath}. Run \`oniro-app emulator install\` first.`);
   }
   const launcher = resolveLauncher(imagesPath, opts.headless === true, opts.connect);
-  const logPath = opts.logFile ?? (os8.platform() === "win32" ? "NUL" : "/dev/null");
-  const logFd = fs13.openSync(logPath, "a");
+  const logPath = opts.logFile ?? (os7.platform() === "win32" ? "NUL" : "/dev/null");
+  const logFd = fs14.openSync(logPath, "a");
   let child;
   try {
     child = spawn2(launcher.command, [...launcher.args], {
@@ -1348,19 +1568,19 @@ async function startEmulator(opts) {
       windowsHide: true
     });
   } finally {
-    fs13.closeSync(logFd);
+    fs14.closeSync(logFd);
   }
   if (!child.pid) {
     throw new OniroError(`Failed to spawn launcher (${launcher.command} ${launcher.args.join(" ")}).`);
   }
-  fs13.writeFileSync(PID_FILE, String(child.pid));
+  fs14.writeFileSync(PID_FILE, String(child.pid));
   child.unref();
   logger.info(`Emulator launched (PID ${child.pid}). Logs: ${logPath}`);
-  const earlyExit = new Promise((resolve2) => {
-    child.once("exit", (code) => resolve2(code));
-    child.once("error", () => resolve2(-1));
+  const earlyExit = new Promise((resolve4) => {
+    child.once("exit", (code) => resolve4(code));
+    child.once("error", () => resolve4(-1));
   });
-  const liveness = new Promise((resolve2) => setTimeout(() => resolve2("alive"), 2e3));
+  const liveness = new Promise((resolve4) => setTimeout(() => resolve4("alive"), 2e3));
   const outcome = await Promise.race([earlyExit, liveness]);
   if (outcome !== "alive") {
     const tail = readTail(logPath, 4e3);
@@ -1400,24 +1620,24 @@ ${tail}` : ""}`);
 }
 function readTail(filePath, bytes) {
   try {
-    const stat = fs13.statSync(filePath);
+    const stat = fs14.statSync(filePath);
     const start = Math.max(0, stat.size - bytes);
-    const fd = fs13.openSync(filePath, "r");
+    const fd = fs14.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(stat.size - start);
-      fs13.readSync(fd, buf, 0, buf.length, start);
+      fs14.readSync(fd, buf, 0, buf.length, start);
       return buf.toString("utf8");
     } finally {
-      fs13.closeSync(fd);
+      fs14.closeSync(fd);
     }
   } catch {
     return "";
   }
 }
 async function stopEmulator(logger = noopLogger) {
-  if (fs13.existsSync(PID_FILE)) {
+  if (fs14.existsSync(PID_FILE)) {
     try {
-      const pid = Number(fs13.readFileSync(PID_FILE, "utf8").trim());
+      const pid = Number(fs14.readFileSync(PID_FILE, "utf8").trim());
       if (Number.isFinite(pid) && pid > 0) {
         try {
           process.kill(pid, "SIGTERM");
@@ -1430,13 +1650,13 @@ async function stopEmulator(logger = noopLogger) {
       logger.warn(`Could not read PID file: ${err.message}`);
     }
   }
-  const [killCmd, ...killArgs] = os8.platform() === "win32" ? ["taskkill", "/IM", "qemu-system-x86_64.exe", "/F"] : ["pkill", "-f", "qemu-system-x86_64"];
+  const [killCmd, ...killArgs] = os7.platform() === "win32" ? ["taskkill", "/IM", "qemu-system-x86_64.exe", "/F"] : ["pkill", "-f", "qemu-system-x86_64"];
   try {
     await runProcess({ command: killCmd, args: killArgs, logger });
   } catch (err) {
     logger.warn(`[emulator] could not run ${killCmd}: ${err.message}`);
   }
-  fs13.rm(PID_FILE, { force: true }, (err) => {
+  fs14.rm(PID_FILE, { force: true }, (err) => {
     if (err) logger.warn(`Could not remove PID file: ${err.message}`);
   });
 }
@@ -1559,7 +1779,7 @@ async function getDisplaySize(config, opts = {}) {
 
 // src/hdc/wait.ts
 function delay(ms, signal) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     if (signal?.aborted) {
       reject(new CancelledError("Wait cancelled."));
       return;
@@ -1574,7 +1794,7 @@ function delay(ms, signal) {
     };
     const timer = setTimeout(() => {
       cleanup();
-      resolve2();
+      resolve4();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -1603,21 +1823,21 @@ async function waitForCondition(opts) {
 }
 
 // src/hdc/app.ts
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 import { spawn as spawn3 } from "child_process";
 
 // src/hdc/project.ts
-import * as fs14 from "fs";
-import * as path13 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 import JSON53 from "json5";
 function readJson5(filePath) {
-  const content = fs14.readFileSync(filePath, "utf-8");
+  const content = fs15.readFileSync(filePath, "utf-8");
   return JSON53.parse(content);
 }
 function getBundleName(projectDir) {
-  const appJsonPath = path13.join(projectDir, "AppScope", "app.json5");
-  if (!fs14.existsSync(appJsonPath)) {
+  const appJsonPath = path15.join(projectDir, "AppScope", "app.json5");
+  if (!fs15.existsSync(appJsonPath)) {
     throw new OniroError(`Could not find app.json5 at ${appJsonPath}`);
   }
   const appJson = readJson5(appJsonPath);
@@ -1627,8 +1847,8 @@ function getBundleName(projectDir) {
   return appJson.app.bundleName;
 }
 function getMainAbility(projectDir, moduleName = "entry", abilityName) {
-  const moduleJsonPath = path13.join(projectDir, moduleName, "src", "main", "module.json5");
-  if (!fs14.existsSync(moduleJsonPath)) {
+  const moduleJsonPath = path15.join(projectDir, moduleName, "src", "main", "module.json5");
+  if (!fs15.existsSync(moduleJsonPath)) {
     throw new OniroError(`Could not find module.json5 at ${moduleJsonPath}`);
   }
   const moduleJson = readJson5(moduleJsonPath);
@@ -1651,8 +1871,8 @@ function getMainAbility(projectDir, moduleName = "entry", abilityName) {
 async function installApp(opts) {
   const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
   const relativeHapPath = opts.hapPath ?? opts.config.get("hapPath", defaultPaths.hapPath);
-  const hapPath = path14.isAbsolute(relativeHapPath) ? relativeHapPath : path14.join(opts.projectDir, relativeHapPath);
-  if (!fs15.existsSync(hapPath)) {
+  const hapPath = path16.isAbsolute(relativeHapPath) ? relativeHapPath : path16.join(opts.projectDir, relativeHapPath);
+  if (!fs16.existsSync(hapPath)) {
     throw new OniroError(`HAP file not found at: ${hapPath}. Build and sign the app first.`);
   }
   const result = await hdcExec({ config: opts.config, args: ["install", hapPath], timeoutMs: 3e5 });
@@ -1669,13 +1889,59 @@ async function installApp(opts) {
 function detectAaStartFailure(output) {
   return /failed to start ability|Error Code:\s*\d|Error Message:/i.test(output) ? output.trim() : null;
 }
+function parseMainAbilityFromBmDump(stdout) {
+  const start = stdout.indexOf("{");
+  if (start < 0) return null;
+  let info;
+  try {
+    info = JSON.parse(stdout.slice(start));
+  } catch {
+    return null;
+  }
+  const mods = Array.isArray(info?.hapModuleInfos) ? info.hapModuleInfos : [];
+  const abilityOf = (m) => m?.mainElementName || m?.mainAbility || void 0;
+  const isEntry = (m) => m?.moduleType === 1 || m?.moduleType === "1" || m?.moduleType === "entry";
+  const entry = mods.find((m) => isEntry(m) && abilityOf(m));
+  const any = mods.find((m) => abilityOf(m));
+  return entry && abilityOf(entry) || any && abilityOf(any) || null;
+}
+async function resolveInstalledMainAbility(opts) {
+  const res = await shell({
+    config: opts.config,
+    command: `bm dump -n ${opts.bundle}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: 15e3,
+    logger: opts.logger
+  });
+  const ability = parseMainAbilityFromBmDump(res.stdout);
+  if (!ability) {
+    throw new OniroError(
+      `Could not determine the main ability for installed bundle ${opts.bundle} (is it installed?). Pass an explicit ability instead.`
+    );
+  }
+  return ability;
+}
 async function launchApp(opts) {
   const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
-  const bundleName = getBundleName(opts.projectDir);
-  const mainAbility = getMainAbility(opts.projectDir, opts.moduleName, opts.abilityName);
+  let bundleName;
+  let mainAbility;
+  if (opts.bundleName) {
+    bundleName = opts.bundleName;
+    mainAbility = opts.abilityName ?? await resolveInstalledMainAbility({
+      config: opts.config,
+      bundle: bundleName,
+      deviceSerial: opts.deviceSerial,
+      logger: opts.logger
+    });
+  } else {
+    if (!opts.projectDir) throw new OniroError("launchApp requires either bundleName or projectDir.");
+    bundleName = getBundleName(opts.projectDir);
+    mainAbility = getMainAbility(opts.projectDir, opts.moduleName, opts.abilityName);
+  }
   const result = await hdcExec({
     config: opts.config,
-    args: ["shell", "aa", "start", "-a", mainAbility, "-b", bundleName]
+    args: ["shell", "aa", "start", "-a", mainAbility, "-b", bundleName],
+    deviceSerial: opts.deviceSerial
   });
   if (result.stdout.trim()) logger.info(result.stdout.trim());
   if (result.stderr.trim()) logger.warn(result.stderr.trim());
@@ -1690,7 +1956,7 @@ function listRunningProcesses(config, options = {}) {
   const logger = options.logger ?? noopLogger;
   const timeoutMs = options.timeoutMs ?? 1e3;
   const hdc = getHdcPath(config);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const proc = spawn3(hdc, ["track-jpid"]);
     const processes = [];
     let resolved = false;
@@ -1704,7 +1970,7 @@ function listRunningProcesses(config, options = {}) {
         if (options.targetProcessName && name === options.targetProcessName && !resolved) {
           resolved = true;
           proc.kill();
-          resolve2(pid);
+          resolve4(pid);
           return;
         }
       }
@@ -1725,7 +1991,7 @@ function listRunningProcesses(config, options = {}) {
       if (options.targetProcessName) {
         reject(new OniroError(`Could not find process for bundle: ${options.targetProcessName}`));
       } else {
-        resolve2(processes);
+        resolve4(processes);
       }
     }, timeoutMs);
     proc.on("close", () => {
@@ -1735,7 +2001,7 @@ function listRunningProcesses(config, options = {}) {
       if (options.targetProcessName) {
         reject(new OniroError(`Could not find process for bundle: ${options.targetProcessName}`));
       } else {
-        resolve2(processes);
+        resolve4(processes);
       }
     });
   });
@@ -1755,8 +2021,17 @@ async function findRunningProcess(opts) {
     logger: opts.logger
   });
   const pid = res.stdout.trim().split(/\s+/).filter(Boolean)[0];
-  if (res.code !== 0 || !pid || !/^\d+$/.test(pid)) return null;
-  return { pid, name: opts.bundle };
+  if (res.code === 0 && pid && /^\d+$/.test(pid)) return { pid, name: opts.bundle };
+  try {
+    const list = await listRunningProcesses(opts.config, { timeoutMs: 1200, logger: opts.logger });
+    if (Array.isArray(list)) {
+      const mine = (name) => name === opts.bundle || name.startsWith(`${opts.bundle}/`) || name.startsWith(`${opts.bundle}:`);
+      const match = list.find((p) => p.name === opts.bundle) ?? list.find((p) => mine(p.name));
+      if (match) return match;
+    }
+  } catch {
+  }
+  return null;
 }
 async function uninstallApp(opts) {
   const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
@@ -1870,12 +2145,12 @@ async function reboot(opts) {
 }
 
 // src/hdc/screen.ts
-import * as fs16 from "fs";
-import * as os9 from "os";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as os8 from "os";
+import * as path17 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 function tmpName(ext) {
-  return path15.join(os9.tmpdir(), `oniro_screen_${randomBytes2(6).toString("hex")}.${ext}`);
+  return path17.join(os8.tmpdir(), `oniro_screen_${randomBytes2(6).toString("hex")}.${ext}`);
 }
 async function takeScreenshot(opts) {
   const remote = "/data/local/tmp/oniro_screenshot.jpeg";
@@ -1885,11 +2160,11 @@ async function takeScreenshot(opts) {
   const local = tmpName("jpeg");
   try {
     await recvFile({ config: opts.config, remote, local, deviceSerial: opts.deviceSerial, timeoutMs });
-    const pixels = await fs16.promises.readFile(local);
+    const pixels = await fs17.promises.readFile(local);
     const size = await getDisplaySize(opts.config, { deviceSerial: opts.deviceSerial }) ?? { width: 0, height: 0 };
     return { pixels, width: size.width, height: size.height };
   } finally {
-    fs16.promises.unlink(local).catch(() => {
+    fs17.promises.unlink(local).catch(() => {
     });
     void shell({ config: opts.config, command: `rm -f ${remote}`, deviceSerial: opts.deviceSerial }).catch(() => {
     });
@@ -1908,9 +2183,9 @@ async function captureBurst(opts) {
       const local = tmpName(`burst_${i}.jpeg`);
       try {
         await recvFile({ config: opts.config, remote: `${remoteDir}/f${i}.jpeg`, local, deviceSerial: opts.deviceSerial });
-        frames.push(await fs16.promises.readFile(local));
+        frames.push(await fs17.promises.readFile(local));
       } finally {
-        fs16.promises.unlink(local).catch(() => {
+        fs17.promises.unlink(local).catch(() => {
         });
       }
     }
@@ -1954,8 +2229,8 @@ function buildInputCommand(opts) {
 }
 async function sendInput(opts) {
   const cmd = buildInputCommand(opts);
-  const res = await shell({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
-  ensureOk(res, `hdc shell ${cmd}`);
+  const res = await shellChecked({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+  ensureRemoteOk(res, `hdc shell ${cmd}`);
 }
 function buildGestureCommands(waypoints) {
   if (waypoints.length < 2) {
@@ -1998,32 +2273,47 @@ function waypointsToRawEvents(waypoints, holdStartMs = 0, holdEndMs = 0) {
   events.push({ type: "up", x: last.x, y: last.y, t: last.t + holdStartMs + holdEndMs });
   return events;
 }
+var UITEST_VELOCITY_MIN = 200;
+var UITEST_VELOCITY_MAX = 4e4;
+function buildGestureUitestCommand(waypoints, opts = {}) {
+  if (waypoints.length < 2) throw new OniroError("sendGesture requires at least two waypoints.");
+  const a = waypoints[0];
+  const b = waypoints[waypoints.length - 1];
+  const dist = Math.hypot(b.x - a.x, b.y - a.y);
+  const dtMs = b.t - a.t;
+  const op = (opts.holdStartMs ?? 0) > 0 ? "drag" : "swipe";
+  let cmd = `uitest uiInput ${op} ${a.x} ${a.y} ${b.x} ${b.y}`;
+  if (dtMs > 0 && dist > 0) {
+    const v = Math.round(dist / (dtMs / 1e3));
+    cmd += ` ${Math.max(UITEST_VELOCITY_MIN, Math.min(UITEST_VELOCITY_MAX, v))}`;
+  }
+  return cmd;
+}
 async function sendGesture(opts) {
-  const wantsHold = (opts.holdStartMs ?? 0) > 0 || (opts.holdEndMs ?? 0) > 0;
-  if (wantsHold) {
-    await sendRawTouch({
-      config: opts.config,
-      events: waypointsToRawEvents(opts.waypoints, opts.holdStartMs, opts.holdEndMs),
-      deviceSerial: opts.deviceSerial,
-      logger: opts.logger
-    });
-    return;
+  if ((opts.holdEndMs ?? 0) > 0) {
+    opts.logger?.warn(
+      "sendGesture: hold-end has no uitest equivalent and is ignored; use sendRawTouch for a trailing hold."
+    );
   }
-  for (const cmd of buildGestureCommands(opts.waypoints)) {
-    const res = await shell({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
-    ensureOk(res, `hdc shell ${cmd}`);
+  if (opts.waypoints.length > 2) {
+    opts.logger?.debug(
+      `sendGesture: ${opts.waypoints.length} waypoints collapsed to first\u2192last (uitest has no polyline path).`
+    );
   }
+  const cmd = buildGestureUitestCommand(opts.waypoints, { holdStartMs: opts.holdStartMs });
+  const res = await shellChecked({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+  ensureRemoteOk(res, `hdc shell ${cmd}`);
 }
 async function sendRawTouch(opts) {
   const cmd = buildRawTouchCommand(opts.events);
-  const res = await shell({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
-  ensureOk(res, `hdc shell ${cmd}`);
+  const res = await shellChecked({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+  ensureRemoteOk(res, `hdc shell ${cmd}`);
 }
 
 // src/hdc/dump.ts
-import * as fs17 from "fs";
-import * as os10 from "os";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as os9 from "os";
+import * as path18 from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 function parseBounds(s) {
   const m = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/.exec(s ?? "");
@@ -2108,10 +2398,10 @@ async function dumpLayout(opts) {
   if (!m) throw new OniroError(`Could not parse dumpLayout output:
 ${dump.stdout}`);
   const remote = m[1];
-  const local = path16.join(os10.tmpdir(), `oniro_layout_${randomBytes3(6).toString("hex")}.json`);
+  const local = path18.join(os9.tmpdir(), `oniro_layout_${randomBytes3(6).toString("hex")}.json`);
   try {
     await recvFile({ config: opts.config, remote, local, deviceSerial: opts.deviceSerial, timeoutMs });
-    const parsed = JSON.parse(await fs17.promises.readFile(local, "utf8"));
+    const parsed = JSON.parse(await fs18.promises.readFile(local, "utf8"));
     const display = await getDisplaySize(opts.config, { deviceSerial: opts.deviceSerial });
     if (opts.prune === false) {
       return { display, tree: parsed };
@@ -2120,7 +2410,7 @@ ${dump.stdout}`);
     const tree = Array.isArray(prunedRaw) ? { children: prunedRaw } : prunedRaw ?? { children: [] };
     return { display, tree };
   } finally {
-    fs17.promises.unlink(local).catch(() => {
+    fs18.promises.unlink(local).catch(() => {
     });
     void shell({ config: opts.config, command: `rm -f ${remote}`, deviceSerial: opts.deviceSerial }).catch(() => {
     });
@@ -2132,7 +2422,7 @@ import { spawn as spawn4 } from "child_process";
 function setHilogLevel(opts) {
   const logger = opts.logger ?? noopLogger;
   const hdc = getHdcPath(opts.config);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = spawn4(hdc, ["shell", "hilog", "-b", opts.level]);
     let stderr = "";
     child.stderr.on("data", (chunk) => {
@@ -2144,7 +2434,7 @@ function setHilogLevel(opts) {
     });
     child.once("close", (code) => {
       if (code === 0) {
-        resolve2();
+        resolve4();
       } else {
         const msg = stderr.trim() || `hdc shell hilog -b ${opts.level} exited with code ${code}`;
         logger.error(`[hilog] ${msg}`);
@@ -2199,7 +2489,7 @@ async function resolveProcessId(config, bundle, deviceSerial) {
   return proc?.pid;
 }
 function waitForLog(opts) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const deadline = Date.now() + opts.timeoutMs;
     let settled = false;
     let child = null;
@@ -2221,7 +2511,7 @@ function waitForLog(opts) {
       if (settled) return;
       settled = true;
       cleanup();
-      resolve2(entry);
+      resolve4(entry);
     };
     const fail = (err) => {
       if (settled) return;
@@ -2268,7 +2558,7 @@ function waitForLog(opts) {
   });
 }
 function watchLog(opts) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const matches = [];
     let settled = false;
     let child = null;
@@ -2288,7 +2578,7 @@ function watchLog(opts) {
       if (settled) return;
       settled = true;
       cleanup();
-      resolve2(opts.dedup === false ? matches : dedupEntries(matches));
+      resolve4(opts.dedup === false ? matches : dedupEntries(matches));
     };
     const onAbort = () => {
       if (settled) return;
@@ -2340,8 +2630,8 @@ async function dumpLog(opts) {
 }
 
 // src/build/runHvigorw.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 import { spawn as spawn5 } from "child_process";
 function buildHvigorwArgs(opts) {
   const args = [opts.task ?? "assembleHap", "--mode", "module"];
@@ -2356,17 +2646,17 @@ function buildHvigorwArgs(opts) {
 function runHvigorw(opts) {
   const { config, projectDir } = opts;
   const logger = opts.logger ?? noopLogger;
-  if (!fs18.existsSync(path17.join(projectDir, "build-profile.json5"))) {
+  if (!fs19.existsSync(path19.join(projectDir, "build-profile.json5"))) {
     throw new OniroError(`Not an OpenHarmony project: ${projectDir} (build-profile.json5 not found).`);
   }
-  if (!fs18.existsSync(getCmdToolsPath(config))) {
+  if (!fs19.existsSync(getCmdToolsPath(config))) {
     throw new CmdToolsNotInstalledError(getCmdToolsPath(config));
   }
   const hvigorw = getHvigorwPath(config, projectDir);
   const args = buildHvigorwArgs(opts);
   if (process.platform !== "win32") {
     try {
-      fs18.chmodSync(hvigorw, 493);
+      fs19.chmodSync(hvigorw, 493);
     } catch {
     }
   }
@@ -2374,7 +2664,7 @@ function runHvigorw(opts) {
     ...process.env,
     OHOS_BASE_SDK_HOME: getOhosBaseSdkHome(config)
   };
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     if (opts.abortSignal?.aborted) {
       reject(new CancelledError("hvigorw build cancelled."));
       return;
@@ -2415,19 +2705,18 @@ function runHvigorw(opts) {
       settled = true;
       cleanup();
       const exitCode = code ?? 1;
-      if (exitCode === 0) resolve2({ exitCode });
+      if (exitCode === 0) resolve4({ exitCode });
       else reject(new OniroError(`hvigorw exited with code ${exitCode}`));
     });
   });
 }
 
 // src/build/discoverHaps.ts
-import * as fs19 from "fs";
-import * as path18 from "path";
-function moduleOf(projectDir, hapPath) {
-  const rel = path18.relative(projectDir, hapPath);
-  const first = rel.split(path18.sep)[0];
-  return first && first !== ".." ? first : "(root)";
+import * as fs20 from "fs";
+import * as path20 from "path";
+function moduleOfHap(hapFileName) {
+  const dash = hapFileName.indexOf("-");
+  return dash > 0 ? hapFileName.slice(0, dash) : hapFileName.replace(/\.hap$/i, "");
 }
 async function discoverHaps(opts) {
   const { projectDir } = opts;
@@ -2435,14 +2724,14 @@ async function discoverHaps(opts) {
   const result = {};
   const walk = async (dir, depth) => {
     if (depth > maxDepth) return;
-    const entries = await fs19.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fs20.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const e of entries) {
-      const full = path18.join(dir, e.name);
+      const full = path20.join(dir, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name === "oh_modules" || e.name === ".git") continue;
         await walk(full, depth + 1);
       } else if (e.isFile() && e.name.endsWith(".hap")) {
-        const moduleName = moduleOf(projectDir, full);
+        const moduleName = moduleOfHap(e.name);
         const bucket = result[moduleName] ??= { signed: [], unsigned: [] };
         if (e.name.includes("unsigned")) bucket.unsigned.push(full);
         else if (e.name.includes("signed")) bucket.signed.push(full);
@@ -2454,8 +2743,8 @@ async function discoverHaps(opts) {
 }
 
 // src/build/ohpm.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path21 from "path";
 function runOhpm(opts) {
   return runProcess({
     command: getOhpmPath(opts.config),
@@ -2468,7 +2757,7 @@ function runOhpm(opts) {
   });
 }
 async function ensureOhModules(opts) {
-  if (fs20.existsSync(path19.join(opts.projectDir, "oh_modules"))) {
+  if (fs21.existsSync(path21.join(opts.projectDir, "oh_modules"))) {
     return { installed: false };
   }
   const res = await runOhpm({
@@ -2563,21 +2852,21 @@ function isValidBundleName(bundleName) {
 }
 
 // src/project/templates.ts
-import * as fs21 from "fs";
-import * as path20 from "path";
+import * as fs22 from "fs";
+import * as path22 from "path";
 function toHumanTemplateName(folderName) {
   return folderName.replace(/([a-z])([A-Z])/g, "$1 $2");
 }
 function listTemplates(templateRoot) {
-  if (!fs21.existsSync(templateRoot)) return [];
-  const entries = fs21.readdirSync(templateRoot, { withFileTypes: true });
+  if (!fs22.existsSync(templateRoot)) return [];
+  const entries = fs22.readdirSync(templateRoot, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => {
-    const dir = path20.join(templateRoot, e.name);
-    const metaPath = path20.join(dir, "template.json");
+    const dir = path22.join(templateRoot, e.name);
+    const metaPath = path22.join(dir, "template.json");
     let meta = {};
-    if (fs21.existsSync(metaPath)) {
+    if (fs22.existsSync(metaPath)) {
       try {
-        meta = JSON.parse(fs21.readFileSync(metaPath, "utf8"));
+        meta = JSON.parse(fs22.readFileSync(metaPath, "utf8"));
       } catch {
       }
     }
@@ -2592,57 +2881,57 @@ function listTemplates(templateRoot) {
 function validateTemplateLayout(templateDir, defaultModuleName) {
   const required = [
     "build-profile.json5",
-    path20.join("AppScope", "app.json5"),
-    path20.join(defaultModuleName, "src", "main", "module.json5"),
-    path20.join(defaultModuleName, "oh-package.json5"),
+    path22.join("AppScope", "app.json5"),
+    path22.join(defaultModuleName, "src", "main", "module.json5"),
+    path22.join(defaultModuleName, "oh-package.json5"),
     "hvigorfile.ts"
   ];
-  return required.filter((rel) => !fs21.existsSync(path20.join(templateDir, rel)));
+  return required.filter((rel) => !fs22.existsSync(path22.join(templateDir, rel)));
 }
 
 // src/project/createScaffold.ts
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path23 from "path";
 
 // src/project/jsonHelpers.ts
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import JSON54 from "json5";
 function readJson5File(filePath) {
-  return JSON54.parse(fs22.readFileSync(filePath, "utf8"));
+  return JSON54.parse(fs23.readFileSync(filePath, "utf8"));
 }
 function writeJson5File(filePath, value) {
-  fs22.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  fs23.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 function readJsonFile(filePath) {
-  return JSON.parse(fs22.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs23.readFileSync(filePath, "utf8"));
 }
 function writeJsonFile(filePath, value) {
-  fs22.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+  fs23.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 
 // src/project/createScaffold.ts
 var IGNORED_DIRS = /* @__PURE__ */ new Set(["oh_modules", "node_modules", "build", ".hvigor"]);
 async function pathExists(p) {
   try {
-    await fs23.promises.access(p);
+    await fs24.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function copyDirRecursive(srcDir, destDir) {
-  await fs23.promises.mkdir(destDir, { recursive: true });
-  const entries = await fs23.promises.readdir(srcDir, { withFileTypes: true });
+  await fs24.promises.mkdir(destDir, { recursive: true });
+  const entries = await fs24.promises.readdir(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const src = path21.join(srcDir, entry.name);
-    const dest = path21.join(destDir, entry.name);
+    const src = path23.join(srcDir, entry.name);
+    const dest = path23.join(destDir, entry.name);
     if (entry.isDirectory()) {
       await copyDirRecursive(src, dest);
     } else if (entry.isSymbolicLink()) {
       continue;
     } else if (entry.isFile()) {
       if (entry.name === "template.json") continue;
-      await fs23.promises.copyFile(src, dest);
+      await fs24.promises.copyFile(src, dest);
     }
   }
 }
@@ -2650,9 +2939,9 @@ async function normalizeJson5ToJson(projectDir, logger) {
   const stack = [projectDir];
   while (stack.length > 0) {
     const currentDir = stack.pop();
-    const entries = await fs23.promises.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs24.promises.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path21.join(currentDir, entry.name);
+      const fullPath = path23.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         stack.push(fullPath);
@@ -2674,23 +2963,23 @@ function toJavaPropertiesPath(p) {
 function createOrUpdateLocalProperties(projectDir, sdkDir) {
   const content = `sdk.dir=${toJavaPropertiesPath(sdkDir)}
 `;
-  fs23.writeFileSync(path21.join(projectDir, "local.properties"), content, "utf8");
+  fs24.writeFileSync(path23.join(projectDir, "local.properties"), content, "utf8");
 }
 function renameIfExists(fromPath, toPath) {
-  if (fs23.existsSync(fromPath) && fromPath !== toPath) {
-    fs23.renameSync(fromPath, toPath);
+  if (fs24.existsSync(fromPath) && fromPath !== toPath) {
+    fs24.renameSync(fromPath, toPath);
   }
 }
 function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
-  const appJsonPath = path21.join(projectDir, "AppScope", "app.json5");
-  if (fs23.existsSync(appJsonPath)) {
+  const appJsonPath = path23.join(projectDir, "AppScope", "app.json5");
+  if (fs24.existsSync(appJsonPath)) {
     const appJson = readJson5File(appJsonPath);
     appJson.app = appJson.app ?? {};
     appJson.app.bundleName = args.bundleName;
     writeJson5File(appJsonPath, appJson);
   }
-  const stringsPath = path21.join(projectDir, "AppScope", "resources", "base", "element", "string.json");
-  if (fs23.existsSync(stringsPath)) {
+  const stringsPath = path23.join(projectDir, "AppScope", "resources", "base", "element", "string.json");
+  if (fs24.existsSync(stringsPath)) {
     const strings = readJsonFile(stringsPath);
     if (Array.isArray(strings.string)) {
       const appName = strings.string.find((s) => s.name === "app_name");
@@ -2698,8 +2987,8 @@ function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
     }
     writeJsonFile(stringsPath, strings);
   }
-  const buildProfilePath = path21.join(projectDir, "build-profile.json5");
-  if (fs23.existsSync(buildProfilePath)) {
+  const buildProfilePath = path23.join(projectDir, "build-profile.json5");
+  if (fs24.existsSync(buildProfilePath)) {
     const buildProfile = readJson5File(buildProfilePath);
     buildProfile.app = buildProfile.app ?? {};
     if (Array.isArray(buildProfile.app.products) && buildProfile.app.products.length > 0) {
@@ -2712,23 +3001,23 @@ function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
     }
     writeJson5File(buildProfilePath, buildProfile);
   }
-  const moduleJsonPath = path21.join(projectDir, args.moduleName, "src", "main", "module.json5");
-  if (fs23.existsSync(moduleJsonPath)) {
+  const moduleJsonPath = path23.join(projectDir, args.moduleName, "src", "main", "module.json5");
+  if (fs24.existsSync(moduleJsonPath)) {
     const moduleJson = readJson5File(moduleJsonPath);
     moduleJson.module = moduleJson.module ?? {};
     moduleJson.module.name = args.moduleName;
     writeJson5File(moduleJsonPath, moduleJson);
   }
-  const moduleOhPackagePath = path21.join(projectDir, args.moduleName, "oh-package.json5");
-  if (fs23.existsSync(moduleOhPackagePath)) {
+  const moduleOhPackagePath = path23.join(projectDir, args.moduleName, "oh-package.json5");
+  if (fs24.existsSync(moduleOhPackagePath)) {
     const pkg = readJson5File(moduleOhPackagePath);
     pkg.name = args.moduleName;
     writeJson5File(moduleOhPackagePath, pkg);
   }
-  const vscodeDir = path21.join(projectDir, ".vscode");
-  fs23.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path23.join(projectDir, ".vscode");
+  fs24.mkdirSync(vscodeDir, { recursive: true });
   const hapPath = `${args.moduleName}/build/default/outputs/default/${args.moduleName}-default-signed.hap`;
-  writeJsonFile(path21.join(vscodeDir, "settings.json"), {
+  writeJsonFile(path23.join(vscodeDir, "settings.json"), {
     "oniro.hapPath": hapPath,
     "files.associations": { "*.json5": "jsonc" }
   });
@@ -2745,7 +3034,7 @@ async function createScaffold(opts) {
   if (!opts.location || !await pathExists(opts.location)) {
     throw new OniroError(`Location does not exist: ${opts.location}`);
   }
-  const templateDir = path21.join(opts.templateRoot, opts.templateId);
+  const templateDir = path23.join(opts.templateRoot, opts.templateId);
   if (!await pathExists(templateDir)) {
     throw new OniroError(`Template not found: ${templateDir}`);
   }
@@ -2758,17 +3047,17 @@ async function createScaffold(opts) {
     throw new OniroError(`Template '${opts.templateId}' is missing required files:
 - ${missing.join("\n- ")}`);
   }
-  const projectDir = path21.join(opts.location, opts.projectName);
+  const projectDir = path23.join(opts.location, opts.projectName);
   if (await pathExists(projectDir)) {
     if (!opts.overwrite) {
       throw new OniroError(`Destination already exists: ${projectDir}. Pass overwrite: true to replace it.`);
     }
-    await fs23.promises.rm(projectDir, { recursive: true, force: true });
+    await fs24.promises.rm(projectDir, { recursive: true, force: true });
   }
   logger.info(`[create] Scaffolding ${opts.templateId} at ${projectDir}`);
   await copyDirRecursive(templateDir, projectDir);
   if (moduleName !== defaultModuleName) {
-    renameIfExists(path21.join(projectDir, defaultModuleName), path21.join(projectDir, moduleName));
+    renameIfExists(path23.join(projectDir, defaultModuleName), path23.join(projectDir, moduleName));
   }
   updateTemplateConfigs(
     projectDir,
@@ -2785,11 +3074,11 @@ async function createScaffold(opts) {
 }
 
 // src/project/listModules.ts
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 function listModules(opts) {
-  const buildProfile = path22.join(opts.projectDir, "build-profile.json5");
-  if (!fs24.existsSync(buildProfile)) {
+  const buildProfile = path24.join(opts.projectDir, "build-profile.json5");
+  if (!fs25.existsSync(buildProfile)) {
     throw new OniroError(`build-profile.json5 not found at ${buildProfile}`);
   }
   const parsed = readJson5File(buildProfile);
@@ -2801,12 +3090,12 @@ function listModules(opts) {
 }
 
 // src/project/abilities.ts
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 function listAbilities(opts) {
   const moduleName = opts.moduleName ?? "entry";
-  const moduleJsonPath = path23.join(opts.projectDir, moduleName, "src", "main", "module.json5");
-  if (!fs25.existsSync(moduleJsonPath)) {
+  const moduleJsonPath = path25.join(opts.projectDir, moduleName, "src", "main", "module.json5");
+  if (!fs26.existsSync(moduleJsonPath)) {
     throw new OniroError(`Could not find module.json5 at ${moduleJsonPath}`);
   }
   const parsed = readJson5File(moduleJsonPath);
@@ -2814,12 +3103,12 @@ function listAbilities(opts) {
 }
 
 // src/project/prepareSigning.ts
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path26 from "path";
 function hasSigningArtifacts(dir) {
-  if (!fs26.existsSync(path24.join(dir, "signatures"))) return false;
-  const buildProfile = path24.join(dir, "build-profile.json5");
-  if (!fs26.existsSync(buildProfile)) return false;
+  if (!fs27.existsSync(path26.join(dir, "signatures"))) return false;
+  const buildProfile = path26.join(dir, "build-profile.json5");
+  if (!fs27.existsSync(buildProfile)) return false;
   try {
     const parsed = readJson5File(buildProfile);
     return Array.isArray(parsed.app?.signingConfigs) && parsed.app.signingConfigs.length > 0;
@@ -2909,8 +3198,8 @@ async function diffHapAssets(opts) {
 }
 
 // src/install/apply.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs28 from "fs";
+import * as path27 from "path";
 function decideInstallMethod(s) {
   if (!s.signInfoInconsistent) return "replace";
   if (s.isSystemBundle && !s.allowUninstall) return "refuse";
@@ -2931,7 +3220,7 @@ async function pidOf(config, bundle, deviceSerial) {
 async function resolveHapPath(opts) {
   let hapPath = opts.hapPath;
   if (hapPath) {
-    if (!path25.isAbsolute(hapPath) && opts.projectDir) hapPath = path25.join(opts.projectDir, hapPath);
+    if (!path27.isAbsolute(hapPath) && opts.projectDir) hapPath = path27.join(opts.projectDir, hapPath);
   } else {
     if (!opts.projectDir) throw new OniroError("applyChanges requires hapPath or projectDir.");
     const haps = await discoverHaps({ projectDir: opts.projectDir });
@@ -2950,7 +3239,7 @@ async function resolveHapPath(opts) {
       hapPath = withSigned[0][1].signed[0];
     }
   }
-  if (!fs27.existsSync(hapPath)) throw new OniroError(`HAP not found at ${hapPath}.`);
+  if (!fs28.existsSync(hapPath)) throw new OniroError(`HAP not found at ${hapPath}.`);
   return hapPath;
 }
 async function applyChanges(opts) {
@@ -2960,7 +3249,7 @@ async function applyChanges(opts) {
   const allowUninstall = opts.allowUninstall ?? false;
   const hapPath = await resolveHapPath(opts);
   let assetsChanged = false;
-  if (opts.installedHapPath && fs27.existsSync(opts.installedHapPath)) {
+  if (opts.installedHapPath && fs28.existsSync(opts.installedHapPath)) {
     try {
       const diff = await diffHapAssets({ installedHap: opts.installedHapPath, newHap: hapPath });
       assetsChanged = diff.addedAssetPaths.length > 0 || diff.removedAssetPaths.length > 0;
@@ -3002,7 +3291,7 @@ async function applyChanges(opts) {
 }
 
 // src/index.ts
-var VERSION = "0.7.0";
+var VERSION = "0.8.0";
 export {
   ALL_SDKS,
   APL_VALUES,
@@ -3011,22 +3300,28 @@ export {
   ChecksumMismatchError,
   CmdToolsNotInstalledError,
   CommandFailedError,
+  INSTALL_TMP_DIRNAME,
+  InsufficientSpaceError,
   OHOS_URL_BASE,
   OniroError,
   SdkNotInstalledError,
+  TMP_DIR_HINT,
   UnsupportedPlatformError,
   VERSION,
   applyChanges,
   attemptHdcConnection,
   buildGestureCommands,
+  buildGestureUitestCommand,
   buildHap,
   buildHvigorwArgs,
   buildInputCommand,
   buildRawTouchCommand,
   captureBurst,
   consoleLogger,
+  createInstallTempDir,
   createMaterial,
   createScaffold,
+  createTempWorkDir,
   decideInstallMethod,
   decideReboot,
   decryptPwd,
@@ -3047,14 +3342,17 @@ export {
   dumpScreen,
   dumpWindow,
   encryptPwd,
+  ensureFreeSpace,
   ensureOhModules,
   ensureOk,
+  ensureRemoteOk,
   extractTarball,
   extractZipWithProgress,
   findAppProcessId,
   findCmdToolsSourceDir,
   findRunningProcess,
   forceStop,
+  formatBytes,
   generateSigningConfigs,
   getBundleName,
   getCmdToolsBin,
@@ -3064,6 +3362,7 @@ export {
   getDeviceInfo,
   getDisplaySize,
   getEmulatorDir,
+  getFreeSpaceBytes,
   getHdcPath,
   getHvigorwPath,
   getInstalledSdks,
@@ -3081,6 +3380,8 @@ export {
   installEmulator,
   isCmdToolsInstalled,
   isEmulatorInstalled,
+  isOutOfSpaceError,
+  isRamBackedPath,
   isValidBundleName,
   isValidProjectName,
   launchApp,
@@ -3098,6 +3399,8 @@ export {
   parseCodelinterFindings,
   parseDeviceList,
   parseHilogLine,
+  parseMainAbilityFromBmDump,
+  parseRemoteExit,
   pickSigningKind,
   prepareSigning,
   pruneLayout,
@@ -3108,6 +3411,8 @@ export {
   removeCmdTools,
   removeEmulator,
   removeSdk,
+  removeTempWorkDir,
+  resolveTmpRoot,
   runCodelinter,
   runHvigorw,
   runOhpm,
@@ -3120,11 +3425,13 @@ export {
   sendRawTouch,
   setHilogLevel,
   shell,
+  shellChecked,
   startEmulator,
   staticConfig,
   stopEmulator,
   streamHilog,
   takeScreenshot,
+  toSpaceError,
   uninstallApp,
   validateTemplateLayout,
   verifySha256,
@@ -3133,6 +3440,7 @@ export {
   waitForCondition,
   waitForLog,
   watchLog,
+  waypointsToRawEvents,
   writeJson5File,
   writeJsonFile
 };