@oniroproject/core 0.6.2 → 0.8.0

package/dist/index.cjs

@@ -36,72 +36,148 @@ __export(index_exports, {
   CancelledError: () => CancelledError,
   ChecksumMismatchError: () => ChecksumMismatchError,
   CmdToolsNotInstalledError: () => CmdToolsNotInstalledError,
+  CommandFailedError: () => CommandFailedError,
+  INSTALL_TMP_DIRNAME: () => INSTALL_TMP_DIRNAME,
+  InsufficientSpaceError: () => InsufficientSpaceError,
   OHOS_URL_BASE: () => OHOS_URL_BASE,
   OniroError: () => OniroError,
   SdkNotInstalledError: () => SdkNotInstalledError,
+  TMP_DIR_HINT: () => TMP_DIR_HINT,
   UnsupportedPlatformError: () => UnsupportedPlatformError,
   VERSION: () => VERSION,
+  applyChanges: () => applyChanges,
   attemptHdcConnection: () => attemptHdcConnection,
+  buildGestureCommands: () => buildGestureCommands,
+  buildGestureUitestCommand: () => buildGestureUitestCommand,
+  buildHap: () => buildHap,
+  buildHvigorwArgs: () => buildHvigorwArgs,
+  buildInputCommand: () => buildInputCommand,
+  buildRawTouchCommand: () => buildRawTouchCommand,
+  captureBurst: () => captureBurst,
   consoleLogger: () => consoleLogger,
+  createInstallTempDir: () => createInstallTempDir,
   createMaterial: () => createMaterial,
   createScaffold: () => createScaffold,
+  createTempWorkDir: () => createTempWorkDir,
+  decideInstallMethod: () => decideInstallMethod,
+  decideReboot: () => decideReboot,
   decryptPwd: () => decryptPwd,
+  dedupEntries: () => dedupEntries,
   defaultContext: () => defaultContext,
   defaultPaths: () => defaultPaths,
+  detectAaStartFailure: () => detectAaStartFailure,
   detectProjectSdkVersion: () => detectProjectSdkVersion,
   detectSigningConfigNames: () => detectSigningConfigNames,
+  diffEntryNames: () => diffEntryNames,
+  diffHapAssets: () => diffHapAssets,
+  discoverHaps: () => discoverHaps,
   downloadAndInstallSdk: () => downloadAndInstallSdk,
   downloadFile: () => downloadFile,
+  dumpLayout: () => dumpLayout,
+  dumpLog: () => dumpLog,
+  dumpRenderService: () => dumpRenderService,
+  dumpScreen: () => dumpScreen,
+  dumpWindow: () => dumpWindow,
   encryptPwd: () => encryptPwd,
+  ensureFreeSpace: () => ensureFreeSpace,
+  ensureOhModules: () => ensureOhModules,
+  ensureOk: () => ensureOk,
+  ensureRemoteOk: () => ensureRemoteOk,
   extractTarball: () => extractTarball,
   extractZipWithProgress: () => extractZipWithProgress,
   findAppProcessId: () => findAppProcessId,
   findCmdToolsSourceDir: () => findCmdToolsSourceDir,
+  findRunningProcess: () => findRunningProcess,
+  forceStop: () => forceStop,
+  formatBytes: () => formatBytes,
   generateSigningConfigs: () => generateSigningConfigs,
   getBundleName: () => getBundleName,
   getCmdToolsBin: () => getCmdToolsBin,
   getCmdToolsDownloadUrl: () => getCmdToolsDownloadUrl,
   getCmdToolsPath: () => getCmdToolsPath,
   getCmdToolsStatus: () => getCmdToolsStatus,
+  getDeviceInfo: () => getDeviceInfo,
+  getDisplaySize: () => getDisplaySize,
   getEmulatorDir: () => getEmulatorDir,
+  getFreeSpaceBytes: () => getFreeSpaceBytes,
   getHdcPath: () => getHdcPath,
   getHvigorwPath: () => getHvigorwPath,
   getInstalledSdks: () => getInstalledSdks,
   getKey: () => getKey,
   getMainAbility: () => getMainAbility,
   getOhosBaseSdkHome: () => getOhosBaseSdkHome,
+  getOhpmPath: () => getOhpmPath,
   getOsFolder: () => getOsFolder,
   getSdkFilename: () => getSdkFilename,
   getSdkRootDir: () => getSdkRootDir,
   getSupportedSdksForUi: () => getSupportedSdksForUi,
+  hdcExec: () => hdcExec,
   installApp: () => installApp,
   installCmdTools: () => installCmdTools,
   installEmulator: () => installEmulator,
   isCmdToolsInstalled: () => isCmdToolsInstalled,
   isEmulatorInstalled: () => isEmulatorInstalled,
+  isOutOfSpaceError: () => isOutOfSpaceError,
+  isRamBackedPath: () => isRamBackedPath,
   isValidBundleName: () => isValidBundleName,
   isValidProjectName: () => isValidProjectName,
   launchApp: () => launchApp,
+  listAbilities: () => listAbilities,
+  listDevices: () => listDevices,
+  listModules: () => listModules,
   listRunningProcesses: () => listRunningProcesses,
   listTemplates: () => listTemplates,
   nonInteractivePrompter: () => nonInteractivePrompter,
   noopLogger: () => noopLogger,
   noopProgress: () => noopProgress,
+  paramGet: () => paramGet,
+  paramSet: () => paramSet,
+  parseBounds: () => parseBounds,
+  parseCodelinterFindings: () => parseCodelinterFindings,
+  parseDeviceList: () => parseDeviceList,
   parseHilogLine: () => parseHilogLine,
+  parseMainAbilityFromBmDump: () => parseMainAbilityFromBmDump,
+  parseRemoteExit: () => parseRemoteExit,
   pickSigningKind: () => pickSigningKind,
+  prepareSigning: () => prepareSigning,
+  pruneLayout: () => pruneLayout,
   readJson5File: () => readJson5File,
   readJsonFile: () => readJsonFile,
+  reboot: () => reboot,
+  recvFile: () => recvFile,
   removeCmdTools: () => removeCmdTools,
   removeEmulator: () => removeEmulator,
   removeSdk: () => removeSdk,
+  removeTempWorkDir: () => removeTempWorkDir,
+  resolveTmpRoot: () => resolveTmpRoot,
+  runCodelinter: () => runCodelinter,
   runHvigorw: () => runHvigorw,
+  runOhpm: () => runOhpm,
+  runProcess: () => runProcess,
+  scopedLogger: () => scopedLogger,
+  selectDevice: () => selectDevice,
+  sendFile: () => sendFile,
+  sendGesture: () => sendGesture,
+  sendInput: () => sendInput,
+  sendRawTouch: () => sendRawTouch,
   setHilogLevel: () => setHilogLevel,
+  shell: () => shell,
+  shellChecked: () => shellChecked,
   startEmulator: () => startEmulator,
   staticConfig: () => staticConfig,
   stopEmulator: () => stopEmulator,
   streamHilog: () => streamHilog,
+  takeScreenshot: () => takeScreenshot,
+  toSpaceError: () => toSpaceError,
+  uninstallApp: () => uninstallApp,
   validateTemplateLayout: () => validateTemplateLayout,
   verifySha256: () => verifySha256,
+  waitForBoot: () => waitForBoot,
+  waitForBundle: () => waitForBundle,
+  waitForCondition: () => waitForCondition,
+  waitForLog: () => waitForLog,
+  watchLog: () => watchLog,
+  waypointsToRawEvents: () => waypointsToRawEvents,
   writeJson5File: () => writeJson5File,
   writeJsonFile: () => writeJsonFile
 });
@@ -124,6 +200,15 @@ var consoleLogger = {
   warn: (m) => console.warn(m),
   error: (m) => console.error(m)
 };
+function scopedLogger(logger, scope) {
+  const prefix = `[${scope}] `;
+  return {
+    debug: (m) => logger.debug(prefix + m),
+    info: (m) => logger.info(prefix + m),
+    warn: (m) => logger.warn(prefix + m),
+    error: (m) => logger.error(prefix + m)
+  };
+}
 
 // src/ports/progress.ts
 var noopProgress = {
@@ -205,9 +290,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;
@@ -222,12 +307,33 @@ 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);
     this.name = "CancelledError";
   }
 };
+var CommandFailedError = class extends OniroError {
+  constructor(command, exitCode, stderr) {
+    super(`Command failed (exit ${exitCode}): ${command}${stderr ? `
+${stderr}` : ""}`);
+    this.command = command;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "CommandFailedError";
+  }
+  command;
+  exitCode;
+  stderr;
+};
 
 // src/ports/context.ts
 function defaultContext(overrides = {}) {
@@ -239,45 +345,45 @@ function defaultContext(overrides = {}) {
 
 // src/sdk/constants.ts
 var ALL_SDKS = [
-  { version: "4.0", api: "10" },
-  { version: "4.1", api: "11" },
-  { version: "5.0.0", api: "12" },
-  { version: "5.0.1", api: "13" },
-  { version: "5.0.2", api: "14" },
-  { version: "5.0.3", api: "15" },
-  { version: "5.1.0", api: "18" },
-  { version: "6.0", api: "20" },
-  { version: "6.1", api: "23" }
+  { version: "4.0", api: "10", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "4.1", api: "11", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.0.0", api: "12", tarballStrip: { linuxWindows: 0, darwin: 3 } },
+  { version: "5.0.1", api: "13", tarballStrip: { linuxWindows: 0, darwin: 3 } },
+  { version: "5.0.2", api: "14", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.0.3", api: "15", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.1.0", api: "18", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "5.1.1", api: "19", tarballStrip: { linuxWindows: 1, darwin: 3 } },
+  { version: "6.0", api: "20", tarballStrip: { linuxWindows: 0, darwin: 3 } },
+  { version: "6.1", api: "23", tarballStrip: { linuxWindows: 0, darwin: 3 } }
 ];
 var OHOS_URL_BASE = "https://repo.huaweicloud.com/openharmony/os";
 
 // src/sdk/platform.ts
 var os2 = __toESM(require("os"), 1);
 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;
-  if (platform6 === "linux") {
-    const strip = v === "5.0.0" || v === "5.0.1" || v === "6.0" || v === "6.1" ? 0 : 1;
-    return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "linux", strip };
+  const strips = ALL_SDKS.find((r) => r.version === v)?.tarballStrip ?? { linuxWindows: 1, darwin: 3 };
+  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: 3 };
+      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: 3 };
+    return { filename: "ohos-sdk-mac-public.tar.gz", osFolder: "darwin", strip: strips.darwin };
   }
-  if (platform6 === "win32") {
-    const strip = v === "5.0.0" || v === "5.0.1" || v === "6.0" || v === "6.1" ? 0 : 1;
-    return { filename: "ohos-sdk-windows_linux-public.tar.gz", osFolder: "windows", strip };
+  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
@@ -302,19 +408,24 @@ function pickExisting(candidates) {
   }
   return candidates[0];
 }
-function getCmdToolsBin(config) {
+function getCmdToolsBin(config, name = "ohpm") {
   const binDir = path2.join(getCmdToolsPath(config), "bin");
   if (os3.platform() === "win32") {
     return pickExisting([
-      path2.join(binDir, "ohpm.exe"),
-      path2.join(binDir, "ohpm.cmd"),
-      path2.join(binDir, "ohpm.bat"),
-      path2.join(binDir, "ohpm")
+      path2.join(binDir, `${name}.exe`),
+      path2.join(binDir, `${name}.cmd`),
+      path2.join(binDir, `${name}.bat`),
+      path2.join(binDir, name)
     ]);
   }
-  return path2.join(binDir, "ohpm");
+  return path2.join(binDir, name);
+}
+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([
@@ -327,15 +438,20 @@ function getHdcPath(config) {
   return path2.join(base, "hdc");
 }
 function getHvigorwPath(config, projectDir) {
-  const cmdToolsBin = path2.join(getCmdToolsPath(config), "bin");
-  return pickExisting([
+  const local = pickExisting([
     path2.join(projectDir, "hvigorw"),
     path2.join(projectDir, "hvigorw.bat"),
-    path2.join(projectDir, "hvigorw.cmd"),
-    path2.join(cmdToolsBin, "hvigorw"),
-    path2.join(cmdToolsBin, "hvigorw.bat"),
-    path2.join(cmdToolsBin, "hvigorw.cmd")
+    path2.join(projectDir, "hvigorw.cmd")
   ]);
+  if (fs.existsSync(local) && isProjectLocalHvigorwWorking(projectDir)) {
+    return local;
+  }
+  return getCmdToolsBin(config, "hvigorw");
+}
+function isProjectLocalHvigorwWorking(projectDir) {
+  const wrapper = path2.join(projectDir, "hvigor", "hvigor-wrapper.js");
+  const nodeModules = path2.join(projectDir, "hvigor", "node_modules");
+  return fs.existsSync(wrapper) && fs.existsSync(nodeModules);
 }
 
 // src/sdk/detectProjectSdk.ts
@@ -360,8 +476,164 @@ function detectProjectSdkVersion(projectRoot, logger = noopLogger) {
   }
 }
 
-// src/sdk/download.ts
+// src/sdk/tmp.ts
 var fs3 = __toESM(require("fs"), 1);
+var os4 = __toESM(require("os"), 1);
+var path4 = __toESM(require("path"), 1);
+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
+var fs4 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
 var crypto = __toESM(require("crypto"), 1);
 var import_node_stream = require("stream");
 var import_node_util = require("util");
@@ -371,36 +643,57 @@ var pipelineAsync = (0, import_node_util.promisify)(import_node_stream.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) => {
@@ -424,38 +717,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);
@@ -463,9 +744,9 @@ async function verifySha256(filePath, sha256Path) {
 }
 
 // src/sdk/extract.ts
-var fs4 = __toESM(require("fs"), 1);
-var os4 = __toESM(require("os"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var os5 = __toESM(require("os"), 1);
+var path6 = __toESM(require("path"), 1);
 var import_node_stream2 = require("stream");
 var import_node_util2 = require("util");
 var tar = __toESM(require("tar"), 1);
@@ -482,12 +763,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;
@@ -499,25 +780,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 {
           }
         }
@@ -549,41 +830,41 @@ async function extractTarball(tarPath, dest, strip = 0) {
 }
 
 // src/sdk/list.ts
-var fs5 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
 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
-var fs6 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
 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;
     }
   }
@@ -591,30 +872,52 @@ function removeSdk(config, api) {
 }
 
 // src/sdk/install.ts
-var fs7 = __toESM(require("fs"), 1);
-var os5 = __toESM(require("os"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs9 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
+
+// src/sdk/move.ts
+var fs8 = __toESM(require("fs"), 1);
+function movePath(src, dest) {
+  try {
+    fs8.renameSync(src, dest);
+  } catch (err) {
+    if (err.code !== "EXDEV") throw err;
+    fs8.cpSync(src, dest, { recursive: true });
+    fs8.rmSync(src, { recursive: true, force: true });
+  }
+}
+
+// src/sdk/install.ts
 async function downloadAndInstallSdk(opts) {
   const { config, version, api, progress, abortSignal } = opts;
   const logger = opts.logger ?? noopLogger;
   const { filename, osFolder, strip } = getSdkFilename(version);
-  const downloadUrl = `${OHOS_URL_BASE}/${version}-Release/${filename}`;
+  const urlBase = config.get("sdkUrlBase", OHOS_URL_BASE);
+  const downloadUrl = `${urlBase}/${version}-Release/${filename}`;
   const sha256Url = `${downloadUrl}.sha256`;
-  const tmpDir = fs7.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");
-  fs7.mkdirSync(extractDir);
-  const sdkInstallDir = path7.join(getSdkRootDir(config), osFolder, api);
-  fs7.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 });
@@ -623,13 +926,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 (!fs7.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 = fs7.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;
@@ -644,39 +947,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;
-      fs7.unlinkSync(zipPath);
+      fs9.unlinkSync(zipPath);
     }
     progress?.report({ message: "Finalizing installation...", increment: 0 });
-    if (fs7.existsSync(sdkInstallDir)) {
-      fs7.rmSync(sdkInstallDir, { recursive: true, force: true });
+    if (fs9.existsSync(sdkInstallDir)) {
+      fs9.rmSync(sdkInstallDir, { recursive: true, force: true });
     }
-    fs7.renameSync(osContentPath, sdkInstallDir);
+    movePath(osContentPath, sdkInstallDir);
     progress?.report({ message: "Finalizing installation...", increment: 3 });
     progress?.report({ message: "Cleaning up...", increment: 0 });
-    fs7.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)}`);
-    fs7.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
-var fs8 = __toESM(require("fs"), 1);
+var fs10 = __toESM(require("fs"), 1);
 var os6 = __toESM(require("os"), 1);
-var path8 = __toESM(require("path"), 1);
+var path10 = __toESM(require("path"), 1);
 var import_node_child_process = require("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(
@@ -685,7 +989,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(
@@ -694,20 +998,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 (fs8.existsSync(c)) return c;
+    if (fs10.existsSync(c)) return c;
   }
-  const entries = fs8.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 (fs8.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.");
 }
@@ -715,53 +1019,62 @@ async function installCmdTools(opts) {
   const { config, progress, abortSignal } = opts;
   const logger = opts.logger ?? noopLogger;
   const CMD_PATH = getCmdToolsPath(config);
-  const tmpDir = fs8.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 });
-    fs8.mkdirSync(CMD_PATH, { recursive: true });
+    fs10.mkdirSync(CMD_PATH, { recursive: true });
     const srcDir = findCmdToolsSourceDir(extractPath);
-    for (const entry of fs8.readdirSync(srcDir)) {
-      const src = path8.join(srcDir, entry);
-      const dest = path8.join(CMD_PATH, entry);
-      if (fs8.statSync(src).isDirectory()) {
-        if (fs8.existsSync(dest)) fs8.rmSync(dest, { recursive: true, force: true });
-        fs8.renameSync(src, dest);
+    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 {
-        fs8.copyFileSync(src, dest);
+        fs10.copyFileSync(src, dest);
       }
     }
-    const binDir = path8.join(CMD_PATH, "bin");
-    if (fs8.existsSync(binDir) && os6.platform() !== "win32") {
-      for (const file of fs8.readdirSync(binDir)) {
-        fs8.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 {
-    fs8.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) => fs8.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 (fs8.existsSync(versionFile)) {
-      const content = fs8.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()})` };
@@ -781,14 +1094,14 @@ function isCmdToolsInstalled(config) {
 }
 function removeCmdTools(config) {
   const cmdPath = getCmdToolsPath(config);
-  if (fs8.existsSync(cmdPath)) {
-    fs8.rmSync(cmdPath, { recursive: true, force: true });
+  if (fs10.existsSync(cmdPath)) {
+    fs10.rmSync(cmdPath, { recursive: true, force: true });
   }
 }
 
 // src/sign/encryptKey.ts
-var fs9 = __toESM(require("fs"), 1);
-var path9 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs"), 1);
+var path11 = __toESM(require("path"), 1);
 var crypto2 = __toESM(require("crypto"), 1);
 var DAEMON_ROOT_KEY_COMPONENT_LENGTH = 16;
 var DAEMON_SALT_KEY_LENGTH = 16;
@@ -860,33 +1173,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);
-  fs9.writeFileSync(filePath, key);
-  fs9.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);
-  fs9.writeFileSync(filePath, encrypted);
-  fs9.chmodSync(filePath, KEY_FILE_PERMISSIONS);
+  const filePath = path11.join(ceDir, hash);
+  fs11.writeFileSync(filePath, encrypted);
+  fs11.chmodSync(filePath, KEY_FILE_PERMISSIONS);
 }
 function createMaterial(materialPath) {
-  fs9.mkdirSync(materialPath, { recursive: true });
-  fs9.chmodSync(materialPath, KEY_FILE_DIRECTORY_PERMISSIONS);
-  const fdDir = path9.join(materialPath, "fd");
-  const acDir = path9.join(materialPath, "ac");
-  const ceDir = path9.join(materialPath, "ce");
-  fs9.mkdirSync(fdDir, { recursive: true });
-  fs9.mkdirSync(acDir, { recursive: true });
-  fs9.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);
-    fs9.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);
   }
@@ -895,24 +1208,24 @@ function createMaterial(materialPath) {
   createAndStoreEnKey(rootKey, ceDir);
 }
 function readSingleFile(dir) {
-  if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) {
+  if (!fs11.existsSync(dir) || !fs11.statSync(dir).isDirectory()) {
     throw new Error(`Missing signing material directory: ${dir}`);
   }
-  const files = fs9.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 fs9.readFileSync(path9.join(dir, files[0]));
+  return fs11.readFileSync(path11.join(dir, files[0]));
 }
 function getKey(materialPath) {
-  if (!fs9.existsSync(materialPath) || !fs9.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) {
@@ -927,8 +1240,8 @@ function decryptPwd(encryptedHex, materialPath) {
 }
 
 // src/sign/generateSigningConfigs.ts
-var fs10 = __toESM(require("fs"), 1);
-var path10 = __toESM(require("path"), 1);
+var fs12 = __toESM(require("fs"), 1);
+var path12 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_json52 = __toESM(require("json5"), 1);
 
@@ -982,6 +1295,7 @@ zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/
 // src/sign/generateSigningConfigs.ts
 var APL_VALUES = ["normal", "system_basic", "system_core"];
 var APP_FEATURE_VALUES = ["hos_normal_app", "hos_system_app"];
+var DEFAULT_PASSWORDS = { store: "123456", key: "123456" };
 function pickSigningKind(apl) {
   return apl === "normal" ? "profile-release" : "application-release";
 }
@@ -995,18 +1309,20 @@ var SIGNING_KIND_CONFIG = {
     certBasename: "OpenHarmonyApplication.cer"
   }
 };
-function copyFilesToProject(projectDir, paths, kind, logger) {
+function copyFilesToProject(projectDir, paths, kind, logger, applicationCertPath) {
   logger.info("[sign] Copying signing material into project...");
-  const signaturesDir = path10.join(projectDir, "signatures");
-  fs10.mkdirSync(signaturesDir, { recursive: true });
-  fs10.copyFileSync(paths.keystore, path10.join(signaturesDir, "OpenHarmony.p12"));
-  fs10.copyFileSync(paths.profileCert, path10.join(signaturesDir, "OpenHarmonyProfileRelease.pem"));
-  fs10.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") {
-    fs10.writeFileSync(
-      path10.join(signaturesDir, "OpenHarmonyApplication.cer"),
-      OPEN_HARMONY_APPLICATION_CERT
-    );
+    const dest = path12.join(signaturesDir, "OpenHarmonyApplication.cer");
+    if (applicationCertPath) {
+      fs12.copyFileSync(applicationCertPath, dest);
+    } else {
+      fs12.writeFileSync(dest, OPEN_HARMONY_APPLICATION_CERT);
+    }
   }
 }
 function resolveAppFeature(apl, override) {
@@ -1014,7 +1330,7 @@ function resolveAppFeature(apl, override) {
   return apl === "normal" ? "hos_normal_app" : "hos_system_app";
 }
 function extractLeafCertificate(chainPath) {
-  const certContent = fs10.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.`);
@@ -1024,20 +1340,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 (!fs10.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 = import_json52.default.parse(fs10.readFileSync(appJsonPath, "utf-8"));
+    appJson = import_json52.default.parse(fs12.readFileSync(appJsonPath, "utf-8"));
   } catch (e) {
     throw new OniroError(`Error parsing ${appJsonPath}: ${e.message}`, e);
   }
   let profileTemplate;
   try {
-    profileTemplate = JSON.parse(fs10.readFileSync(profileTemplatePath, "utf-8"));
+    profileTemplate = JSON.parse(fs12.readFileSync(profileTemplatePath, "utf-8"));
   } catch (e) {
     throw new OniroError(`Error parsing ${profileTemplatePath}: ${e.message}`, e);
   }
@@ -1050,7 +1366,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
@@ -1060,13 +1376,13 @@ function modifyProfileTemplate(projectDir, apl, appFeature, logger, options = {}
     profileTemplate.acls = profileTemplate.acls ?? {};
     profileTemplate.acls["allowed-acls"] = options.acls;
   }
-  fs10.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
+  fs12.writeFileSync(profileTemplatePath, JSON.stringify(profileTemplate, null, 2));
 }
-function generateP7bFile(projectDir, paths, logger) {
+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,
@@ -1086,9 +1402,9 @@ function generateP7bFile(projectDir, paths, logger) {
     "-outFile",
     outputProfilePath,
     "-keyPwd",
-    "123456",
+    passwords.key,
     "-keystorePwd",
-    "123456"
+    passwords.store
   ];
   try {
     (0, import_node_child_process2.execFileSync)("java", args, { stdio: "inherit" });
@@ -1100,11 +1416,11 @@ function generateP7bFile(projectDir, paths, logger) {
   }
 }
 function detectSigningConfigNames(projectDir) {
-  const buildProfilePath = path10.join(projectDir, "build-profile.json5");
-  if (!fs10.existsSync(buildProfilePath)) return ["default"];
+  const buildProfilePath = path12.join(projectDir, "build-profile.json5");
+  if (!fs12.existsSync(buildProfilePath)) return ["default"];
   let parsed;
   try {
-    parsed = import_json52.default.parse(fs10.readFileSync(buildProfilePath, "utf-8"));
+    parsed = import_json52.default.parse(fs12.readFileSync(buildProfilePath, "utf-8"));
   } catch {
     return ["default"];
   }
@@ -1119,16 +1435,16 @@ function detectSigningConfigNames(projectDir) {
   }
   return names.length > 0 ? names : ["default"];
 }
-function updateBuildProfile(projectDir, kind, logger) {
+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 encryptedStorePassword = encryptPwd("123456", materialDir);
-  const encryptedKeyPassword = encryptPwd("123456", materialDir);
+  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 (fs10.existsSync(buildProfilePath)) {
+  if (fs12.existsSync(buildProfilePath)) {
     try {
-      buildProfile = import_json52.default.parse(fs10.readFileSync(buildProfilePath, "utf-8"));
+      buildProfile = import_json52.default.parse(fs12.readFileSync(buildProfilePath, "utf-8"));
     } catch (e) {
       throw new OniroError(`Error parsing ${buildProfilePath}: ${e.message}`, e);
     }
@@ -1149,13 +1465,13 @@ function updateBuildProfile(projectDir, kind, logger) {
       storeFile: "./signatures/OpenHarmony.p12"
     }
   }));
-  fs10.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 (fs10.existsSync(materialDir)) {
-    fs10.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);
 }
@@ -1178,116 +1494,224 @@ function generateSigningConfigs(options) {
       "Could not detect project SDK version (compileSdkVersion missing in build-profile.json5)."
     );
   }
-  const sdkPath = path10.join(sdkHome, String(sdkVersion));
-  if (!fs10.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;
   logger.info("[sign] Starting signing configuration generation...");
-  copyFilesToProject(projectDir, paths, kind, logger);
+  copyFilesToProject(projectDir, paths, kind, logger, options.applicationCertPath);
   modifyProfileTemplate(projectDir, apl, appFeature, logger, { kind, acls: options.acls });
-  generateP7bFile(projectDir, paths, logger);
+  generateP7bFile(projectDir, paths, logger, passwords);
   prepareMaterialDirectory(projectDir, logger);
-  updateBuildProfile(projectDir, kind, logger);
+  updateBuildProfile(projectDir, kind, logger, passwords);
   logger.info("[sign] Signing configuration generated successfully.");
 }
 
 // src/emulator/install.ts
-var fs11 = __toESM(require("fs"), 1);
-var os7 = __toESM(require("os"), 1);
-var path11 = __toESM(require("path"), 1);
+var fs13 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
 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 = fs11.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 {
-    fs11.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 (fs11.existsSync(runSh)) {
-      fs11.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 {
-    fs11.rmSync(tmpDir, { recursive: true, force: true });
+    removeTempWorkDir(tmpDir, tmpRoot);
   }
 }
 function isEmulatorInstalled(config) {
-  return fs11.existsSync(path11.join(getEmulatorDir(config), "images", "run.sh"));
+  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 (fs11.existsSync(emulatorDir)) {
-    fs11.rmSync(emulatorDir, { recursive: true, force: true });
+  if (fs13.existsSync(emulatorDir)) {
+    fs13.rmSync(emulatorDir, { recursive: true, force: true });
   }
 }
 
 // src/emulator/lifecycle.ts
-var fs12 = __toESM(require("fs"), 1);
-var os8 = __toESM(require("os"), 1);
-var path12 = __toESM(require("path"), 1);
+var fs14 = __toESM(require("fs"), 1);
+var os7 = __toESM(require("os"), 1);
+var path14 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
+
+// src/hdc/exec.ts
 var import_node_child_process3 = require("child_process");
-var PID_FILE = path12.join(os8.tmpdir(), "oniro_emulator.pid");
-function execPromise(cmd, cwd, logger) {
-  return new Promise((resolve2, reject) => {
-    (0, import_node_child_process3.exec)(cmd, { cwd }, (error, stdout, stderr) => {
-      if (stdout?.trim()) logger.info(`[emulator] ${stdout.trim()}`);
-      if (stderr?.trim()) logger.warn(`[emulator] ${stderr.trim()}`);
-      if (error) {
-        logger.error(`[emulator] ${error.message}`);
-        reject(error);
-      } else {
-        resolve2();
+function runProcess(opts) {
+  const { command, args, cwd, env, onOutput } = opts;
+  const timeoutMs = opts.timeoutMs ?? 6e4;
+  const { abortSignal } = opts;
+  return new Promise((resolve4, reject) => {
+    if (abortSignal?.aborted) {
+      reject(new CancelledError(`Command aborted before start: ${command}`));
+      return;
+    }
+    const child = (0, import_node_child_process3.spawn)(command, [...args], { cwd, env, shell: false });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      abortSignal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        child.kill("SIGKILL");
+      } catch {
       }
+      reject(new CancelledError(`Command aborted: ${command} ${args.join(" ")}`));
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, timeoutMs);
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (d) => {
+      const s = d.toString();
+      stdout += s;
+      onOutput?.(s, "stdout");
+    });
+    child.stderr.on("data", (d) => {
+      const s = d.toString();
+      stderr += s;
+      onOutput?.(s, "stderr");
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new OniroError(`Failed to spawn ${command}: ${err.message}`, err));
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (timedOut) {
+        reject(
+          new OniroError(
+            `Command timed out after ${timeoutMs}ms: ${command} ${args.join(" ")}` + (stderr.trim() ? `
+${stderr.trim()}` : "")
+          )
+        );
+        return;
+      }
+      resolve4({ code: code ?? -1, stdout, stderr });
     });
   });
 }
+function hdcExec(opts) {
+  const hdc = getHdcPath(opts.config);
+  const argv = opts.deviceSerial ? ["-t", opts.deviceSerial, ...opts.args] : [...opts.args];
+  return runProcess({
+    command: hdc,
+    args: argv,
+    timeoutMs: opts.timeoutMs,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+}
+function shell(opts) {
+  const { command, ...rest } = opts;
+  return hdcExec({ ...rest, args: ["shell", command] });
+}
+function ensureOk(result, command) {
+  if (result.code !== 0) {
+    throw new CommandFailedError(command, result.code, result.stderr.trim());
+  }
+  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 = path14.join(os7.tmpdir(), "oniro_emulator.pid");
 async function attemptHdcConnection(config, address = "127.0.0.1:55555", logger = noopLogger) {
-  const hdc = getHdcPath(config);
   try {
-    await execPromise(`"${hdc}" start -r`, void 0, logger);
-    await execPromise(`"${hdc}" tconn ${address}`, void 0, logger);
-    return await new Promise((resolve2) => {
-      (0, import_node_child_process3.exec)(`"${hdc}" list targets`, (_error, stdout) => {
-        resolve2(stdout?.includes(address) ?? false);
-      });
-    });
+    await hdcExec({ config, args: ["start", "-r"], logger });
+    await hdcExec({ config, args: ["tconn", address], logger });
+    const targets = await hdcExec({ config, args: ["list", "targets"], logger });
+    return targets.stdout.includes(address);
   } catch (err) {
     logger.warn(`hdc connection attempt failed: ${err.message}`);
     return false;
   }
 }
 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 (fs12.existsSync(runBat)) {
+  if (os7.platform() === "win32") {
+    if (fs14.existsSync(runBat)) {
       return { command: "cmd.exe", args: ["/c", runBat, ...extra], cwd: imagesPath };
     }
-    if (fs12.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 (fs12.existsSync(runSh)) {
+  if (fs14.existsSync(runSh)) {
     return { command: "bash", args: [runSh, ...extra], cwd: imagesPath };
   }
-  if (fs12.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}.`);
@@ -1295,9 +1719,9 @@ function resolveLauncher(imagesPath, headless, connect) {
 async function startEmulator(opts) {
   const { config } = opts;
   const logger = opts.logger ?? noopLogger;
-  if (os8.platform() !== "win32" && fs12.existsSync(PID_FILE)) {
+  if (os7.platform() !== "win32" && fs14.existsSync(PID_FILE)) {
     try {
-      const pid = Number(fs12.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);
@@ -1313,35 +1737,35 @@ async function startEmulator(opts) {
       logger.warn(`Could not read PID file: ${err.message}`);
     }
   }
-  const imagesPath = path12.join(getEmulatorDir(config), "images");
-  if (!fs12.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 = fs12.openSync(logPath, "a");
+  const logPath = opts.logFile ?? (os7.platform() === "win32" ? "NUL" : "/dev/null");
+  const logFd = fs14.openSync(logPath, "a");
   let child;
   try {
-    child = (0, import_node_child_process3.spawn)(launcher.command, [...launcher.args], {
+    child = (0, import_node_child_process4.spawn)(launcher.command, [...launcher.args], {
       cwd: launcher.cwd,
       detached: true,
       stdio: ["ignore", logFd, logFd],
       windowsHide: true
     });
   } finally {
-    fs12.closeSync(logFd);
+    fs14.closeSync(logFd);
   }
   if (!child.pid) {
     throw new OniroError(`Failed to spawn launcher (${launcher.command} ${launcher.args.join(" ")}).`);
   }
-  fs12.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);
@@ -1381,24 +1805,24 @@ ${tail}` : ""}`);
 }
 function readTail(filePath, bytes) {
   try {
-    const stat = fs12.statSync(filePath);
+    const stat = fs14.statSync(filePath);
     const start = Math.max(0, stat.size - bytes);
-    const fd = fs12.openSync(filePath, "r");
+    const fd = fs14.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(stat.size - start);
-      fs12.readSync(fd, buf, 0, buf.length, start);
+      fs14.readSync(fd, buf, 0, buf.length, start);
       return buf.toString("utf8");
     } finally {
-      fs12.closeSync(fd);
+      fs14.closeSync(fd);
     }
   } catch {
     return "";
   }
 }
 async function stopEmulator(logger = noopLogger) {
-  if (fs12.existsSync(PID_FILE)) {
+  if (fs14.existsSync(PID_FILE)) {
     try {
-      const pid = Number(fs12.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");
@@ -1411,27 +1835,194 @@ async function stopEmulator(logger = noopLogger) {
       logger.warn(`Could not read PID file: ${err.message}`);
     }
   }
-  const killCmd = 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 execPromise(killCmd, void 0, logger);
-  } catch {
+    await runProcess({ command: killCmd, args: killArgs, logger });
+  } catch (err) {
+    logger.warn(`[emulator] could not run ${killCmd}: ${err.message}`);
   }
-  fs12.rm(PID_FILE, { force: true }, (err) => {
+  fs14.rm(PID_FILE, { force: true }, (err) => {
     if (err) logger.warn(`Could not remove PID file: ${err.message}`);
   });
 }
 
+// src/hdc/devices.ts
+var STATUS_TOKENS = /* @__PURE__ */ new Set([
+  "Connected",
+  "Offline",
+  "Unauthorized",
+  "Authorizing",
+  "Disconnected",
+  "Recovery"
+]);
+var CONNECTION_TOKENS = /* @__PURE__ */ new Set(["USB", "TCP", "UART", "BT", "UNKNOWN"]);
+function parseDeviceList(stdout) {
+  const devices = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("[Empty]")) continue;
+    const cols = trimmed.split(/\s+/);
+    const serial = cols[0];
+    if (!serial) continue;
+    const rest = cols.slice(1);
+    const connection = rest.find((c) => CONNECTION_TOKENS.has(c));
+    const status = rest.find((c) => STATUS_TOKENS.has(c)) ?? "Unknown";
+    const info = { serial, status };
+    if (connection) info.connection = connection;
+    devices.push(info);
+  }
+  return devices;
+}
+async function listDevices(config, opts = {}) {
+  const res = await hdcExec({
+    config,
+    args: ["list", "targets", "-v"],
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  return parseDeviceList(res.stdout);
+}
+async function selectDevice(config, serial, opts = {}) {
+  if (serial && serial !== "auto") return serial;
+  const envSerial = process.env.ONIRO_DEVICE_SERIAL || process.env.DEVICE_SERIAL;
+  if (envSerial && envSerial !== "auto") return envSerial;
+  const usable = (await listDevices(config, opts)).filter(
+    (d) => d.status === "Connected" || d.status === "Unknown"
+  );
+  if (usable.length === 1) return usable[0].serial;
+  if (usable.length === 0) {
+    throw new OniroError("No connected device found. Connect a device/emulator or set ONIRO_DEVICE_SERIAL.");
+  }
+  throw new OniroError(
+    `Multiple devices connected (${usable.map((d) => d.serial).join(", ")}). Set ONIRO_DEVICE_SERIAL to choose one.`
+  );
+}
+
+// src/hdc/param.ts
+async function paramGet(config, key, opts = {}) {
+  const res = await shell({
+    config,
+    command: `param get ${key}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc shell param get ${key}`);
+  return res.stdout.trim();
+}
+async function paramSet(config, key, value, opts = {}) {
+  const res = await shell({
+    config,
+    command: `param set ${key} ${value}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc shell param set ${key} ${value}`);
+}
+
+// src/hdc/files.ts
+async function sendFile(opts) {
+  const res = await hdcExec({
+    config: opts.config,
+    args: ["file", "send", opts.local, opts.remote],
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc file send ${opts.local} ${opts.remote}`);
+}
+async function recvFile(opts) {
+  const res = await hdcExec({
+    config: opts.config,
+    args: ["file", "recv", opts.remote, opts.local],
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc file recv ${opts.remote} ${opts.local}`);
+}
+
+// src/hdc/display.ts
+async function getDisplaySize(config, opts = {}) {
+  const res = await shell({
+    config,
+    command: "hidumper -s 10 -a screen",
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  if (res.code !== 0) return null;
+  const m = res.stdout.match(/render resolution=(\d+)x(\d+)/);
+  if (!m) return null;
+  return { width: Number(m[1]), height: Number(m[2]) };
+}
+
+// src/hdc/wait.ts
+function delay(ms, signal) {
+  return new Promise((resolve4, reject) => {
+    if (signal?.aborted) {
+      reject(new CancelledError("Wait cancelled."));
+      return;
+    }
+    const onAbort = () => {
+      cleanup();
+      reject(new CancelledError("Wait cancelled."));
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve4();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function waitForCondition(opts) {
+  const pollMs = opts.pollMs ?? 2e3;
+  const heartbeatEvery = opts.heartbeatEvery ?? 6;
+  const deadline = Date.now() + opts.timeoutMs;
+  let attempt = 0;
+  while (Date.now() < deadline) {
+    if (opts.abortSignal?.aborted) throw new CancelledError("Wait cancelled.");
+    attempt++;
+    let ok = false;
+    try {
+      ok = await opts.probe();
+    } catch {
+      ok = false;
+    }
+    if (ok) return;
+    if (opts.onHeartbeat && attempt % heartbeatEvery === 0) {
+      opts.onHeartbeat(attempt, Math.max(0, deadline - Date.now()));
+    }
+    await delay(pollMs, opts.abortSignal);
+  }
+  throw new OniroError(opts.timeoutMessage ?? `Condition not met within ${opts.timeoutMs}ms.`);
+}
+
+// src/hdc/app.ts
+var fs16 = __toESM(require("fs"), 1);
+var path16 = __toESM(require("path"), 1);
+var import_node_child_process5 = require("child_process");
+
 // src/hdc/project.ts
-var fs13 = __toESM(require("fs"), 1);
-var path13 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs"), 1);
+var path15 = __toESM(require("path"), 1);
 var import_json53 = __toESM(require("json5"), 1);
 function readJson5(filePath) {
-  const content = fs13.readFileSync(filePath, "utf-8");
+  const content = fs15.readFileSync(filePath, "utf-8");
   return import_json53.default.parse(content);
 }
 function getBundleName(projectDir) {
-  const appJsonPath = path13.join(projectDir, "AppScope", "app.json5");
-  if (!fs13.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);
@@ -1440,59 +2031,118 @@ function getBundleName(projectDir) {
   }
   return appJson.app.bundleName;
 }
-function getMainAbility(projectDir, moduleName = "entry") {
-  const moduleJsonPath = path13.join(projectDir, moduleName, "src", "main", "module.json5");
-  if (!fs13.existsSync(moduleJsonPath)) {
+function getMainAbility(projectDir, moduleName = "entry", abilityName) {
+  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);
-  if (!moduleJson.module?.mainElement) {
-    throw new OniroError("mainElement not found in module.json5");
-  }
-  return moduleJson.module.mainElement;
+  const module2 = moduleJson.module ?? {};
+  if (abilityName) {
+    const match = module2.abilities?.find((a) => a.name === abilityName);
+    if (match?.name) return match.name;
+    throw new OniroError(`Ability "${abilityName}" not found in module.json5 at ${moduleJsonPath}`);
+  }
+  if (module2.mainElement) return module2.mainElement;
+  const abilities = module2.abilities ?? [];
+  const visible = abilities.find((a) => a.visible && a.name);
+  if (visible?.name) return visible.name;
+  const first = abilities.find((a) => a.name);
+  if (first?.name) return first.name;
+  throw new OniroError("mainElement not found in module.json5");
 }
 
 // src/hdc/app.ts
-var fs14 = __toESM(require("fs"), 1);
-var path14 = __toESM(require("path"), 1);
-var import_node_child_process4 = require("child_process");
-function execPromise2(cmd, logger) {
-  return new Promise((resolve2, reject) => {
-    (0, import_node_child_process4.exec)(cmd, (error, stdout, stderr) => {
-      if (stdout?.trim()) logger.info(`[hdc] ${stdout.trim()}`);
-      if (stderr?.trim()) logger.warn(`[hdc] ${stderr.trim()}`);
-      if (error) {
-        logger.error(`[hdc] ${error.message}`);
-        reject(error);
-      } else {
-        resolve2();
-      }
-    });
-  });
-}
 async function installApp(opts) {
-  const logger = opts.logger ?? noopLogger;
+  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 (!fs14.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 hdc = getHdcPath(opts.config);
-  await execPromise2(`"${hdc}" install "${hapPath}"`, logger);
+  const result = await hdcExec({ config: opts.config, args: ["install", hapPath], timeoutMs: 3e5 });
+  if (result.stdout.trim()) logger.info(result.stdout.trim());
+  if (result.stderr.trim()) logger.warn(result.stderr.trim());
+  ensureOk(result, `hdc install ${hapPath}`);
+  let bundleName = "";
+  try {
+    bundleName = getBundleName(opts.projectDir);
+  } catch {
+  }
+  return { installed: true, bundleName, hapPath, output: `${result.stdout}${result.stderr}`.trim() };
+}
+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 = opts.logger ?? noopLogger;
-  const bundleName = getBundleName(opts.projectDir);
-  const mainAbility = getMainAbility(opts.projectDir, opts.moduleName);
-  const hdc = getHdcPath(opts.config);
-  await execPromise2(`"${hdc}" shell aa start -a ${mainAbility} -b ${bundleName}`, logger);
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  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],
+    deviceSerial: opts.deviceSerial
+  });
+  if (result.stdout.trim()) logger.info(result.stdout.trim());
+  if (result.stderr.trim()) logger.warn(result.stderr.trim());
+  ensureOk(result, `hdc shell aa start -a ${mainAbility} -b ${bundleName}`);
+  const failure = detectAaStartFailure(`${result.stdout}
+${result.stderr}`);
+  if (failure) {
+    throw new OniroError(`Failed to launch ${bundleName} (${mainAbility}): ${failure}`);
+  }
 }
 function listRunningProcesses(config, options = {}) {
   const logger = options.logger ?? noopLogger;
   const timeoutMs = options.timeoutMs ?? 1e3;
   const hdc = getHdcPath(config);
-  return new Promise((resolve2, reject) => {
-    const proc = (0, import_node_child_process4.spawn)(hdc, ["track-jpid"]);
+  return new Promise((resolve4, reject) => {
+    const proc = (0, import_node_child_process5.spawn)(hdc, ["track-jpid"]);
     const processes = [];
     let resolved = false;
     proc.stdout.on("data", (data) => {
@@ -1505,7 +2155,7 @@ function listRunningProcesses(config, options = {}) {
         if (options.targetProcessName && name === options.targetProcessName && !resolved) {
           resolved = true;
           proc.kill();
-          resolve2(pid);
+          resolve4(pid);
           return;
         }
       }
@@ -1526,7 +2176,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", () => {
@@ -1536,7 +2186,7 @@ function listRunningProcesses(config, options = {}) {
       if (options.targetProcessName) {
         reject(new OniroError(`Could not find process for bundle: ${options.targetProcessName}`));
       } else {
-        resolve2(processes);
+        resolve4(processes);
       }
     });
   });
@@ -1546,14 +2196,419 @@ async function findAppProcessId(config, projectDir, logger) {
   const result = await listRunningProcesses(config, { targetProcessName: bundleName, logger });
   return result;
 }
+async function findRunningProcess(opts) {
+  const safe = opts.bundle.replace(/'/g, `'\\''`);
+  const res = await shell({
+    config: opts.config,
+    command: `pidof '${safe}'`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 1e4,
+    logger: opts.logger
+  });
+  const pid = res.stdout.trim().split(/\s+/).filter(Boolean)[0];
+  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");
+  const res = await hdcExec({
+    config: opts.config,
+    args: ["uninstall", opts.bundle],
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 12e4
+  });
+  if (res.stdout.trim()) logger.info(res.stdout.trim());
+  if (res.stderr.trim()) logger.warn(res.stderr.trim());
+  ensureOk(res, `hdc uninstall ${opts.bundle}`);
+}
+async function forceStop(opts) {
+  const res = await shell({
+    config: opts.config,
+    command: `aa force-stop ${opts.bundle}`,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 3e4,
+    logger: opts.logger
+  });
+  ensureOk(res, `hdc shell aa force-stop ${opts.bundle}`);
+}
+
+// src/hdc/lifecycle.ts
+async function isReachable(config, deviceSerial) {
+  try {
+    const res = await shell({ config, command: "echo oniro_ping", deviceSerial, timeoutMs: 5e3 });
+    return res.code === 0 && res.stdout.includes("oniro_ping");
+  } catch {
+    return false;
+  }
+}
+var TCP_SERIAL_RE = /^.+:\d+$/;
+async function reconnectIfTcp(config, deviceSerial, logger) {
+  if (!deviceSerial || !TCP_SERIAL_RE.test(deviceSerial)) return;
+  try {
+    await hdcExec({ config, args: ["tconn", deviceSerial], timeoutMs: 5e3, logger });
+  } catch {
+  }
+}
+async function waitForBundle(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  await waitForCondition({
+    probe: async () => {
+      await reconnectIfTcp(opts.config, opts.deviceSerial, logger);
+      return await findRunningProcess({ config: opts.config, bundle: opts.bundle, deviceSerial: opts.deviceSerial, timeoutMs: 8e3 }) !== null;
+    },
+    timeoutMs,
+    pollMs: 2e3,
+    abortSignal: opts.abortSignal,
+    onHeartbeat: (attempt, remaining) => logger.info(`waiting for ${opts.bundle} (attempt ${attempt}, ${Math.floor(remaining / 1e3)}s left)`),
+    timeoutMessage: `Bundle ${opts.bundle} did not start within ${timeoutMs}ms.`
+  });
+}
+async function waitForBoot(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  await waitForCondition({
+    probe: async () => {
+      await reconnectIfTcp(opts.config, opts.deviceSerial, logger);
+      if (!await isReachable(opts.config, opts.deviceSerial)) return false;
+      if (!opts.untilPidOf) return true;
+      return await findRunningProcess({ config: opts.config, bundle: opts.untilPidOf, deviceSerial: opts.deviceSerial, timeoutMs: 8e3 }) !== null;
+    },
+    timeoutMs,
+    pollMs: 2e3,
+    abortSignal: opts.abortSignal,
+    onHeartbeat: (attempt, remaining) => logger.info(`waiting for boot (attempt ${attempt}, ${Math.floor(remaining / 1e3)}s left)`),
+    timeoutMessage: `Device did not boot within ${timeoutMs}ms.`
+  });
+}
+async function reboot(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "hdc");
+  const mode = opts.mode ?? "system";
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  logger.info(`Rebooting device (${mode})...`);
+  try {
+    if (mode === "system") {
+      await paramSet(opts.config, "ohos.startup.powerctrl", "reboot", {
+        deviceSerial: opts.deviceSerial,
+        timeoutMs: 15e3,
+        logger: opts.logger
+      });
+    } else {
+      await shell({ config: opts.config, command: `reboot ${mode}`, deviceSerial: opts.deviceSerial, timeoutMs: 15e3 });
+    }
+  } catch (err) {
+    logger.debug(`reboot command did not return cleanly: ${err.message}`);
+  }
+  if (mode !== "system" || !opts.waitForBundle) return;
+  try {
+    await waitForCondition({
+      probe: async () => !await isReachable(opts.config, opts.deviceSerial),
+      timeoutMs: Math.min(timeoutMs, 3e4),
+      pollMs: 1500,
+      abortSignal: opts.abortSignal,
+      timeoutMessage: "device did not become unreachable"
+    });
+  } catch {
+  }
+  await waitForBundle({
+    config: opts.config,
+    bundle: opts.waitForBundle,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs,
+    abortSignal: opts.abortSignal,
+    logger: opts.logger
+  });
+}
+
+// src/hdc/screen.ts
+var fs17 = __toESM(require("fs"), 1);
+var os8 = __toESM(require("os"), 1);
+var path17 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+function tmpName(ext) {
+  return path17.join(os8.tmpdir(), `oniro_screen_${(0, import_node_crypto.randomBytes)(6).toString("hex")}.${ext}`);
+}
+async function takeScreenshot(opts) {
+  const remote = "/data/local/tmp/oniro_screenshot.jpeg";
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const cap = await shell({ config: opts.config, command: `snapshot_display -f ${remote}`, deviceSerial: opts.deviceSerial, timeoutMs });
+  ensureOk(cap, `snapshot_display -f ${remote}`);
+  const local = tmpName("jpeg");
+  try {
+    await recvFile({ config: opts.config, remote, local, deviceSerial: opts.deviceSerial, timeoutMs });
+    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 {
+    fs17.promises.unlink(local).catch(() => {
+    });
+    void shell({ config: opts.config, command: `rm -f ${remote}`, deviceSerial: opts.deviceSerial }).catch(() => {
+    });
+  }
+}
+async function captureBurst(opts) {
+  const count = Math.max(1, Math.floor(opts.count));
+  const remoteDir = `/data/local/tmp/oniro_burst_${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  const sleepSec = opts.intervalMs > 0 ? (opts.intervalMs / 1e3).toFixed(3) : "0";
+  const loop = `mkdir -p ${remoteDir}; i=0; while [ $i -lt ${count} ]; do snapshot_display -f ${remoteDir}/f$i.jpeg; [ ${count} -gt 1 ] && sleep ${sleepSec}; i=$((i+1)); done`;
+  const cap = await shell({ config: opts.config, command: loop, deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 12e4 });
+  ensureOk(cap, "snapshot_display burst");
+  const frames = [];
+  try {
+    for (let i = 0; i < count; i++) {
+      const local = tmpName(`burst_${i}.jpeg`);
+      try {
+        await recvFile({ config: opts.config, remote: `${remoteDir}/f${i}.jpeg`, local, deviceSerial: opts.deviceSerial });
+        frames.push(await fs17.promises.readFile(local));
+      } finally {
+        fs17.promises.unlink(local).catch(() => {
+        });
+      }
+    }
+  } finally {
+    void shell({ config: opts.config, command: `rm -rf ${remoteDir}`, deviceSerial: opts.deviceSerial }).catch(() => {
+    });
+  }
+  return frames;
+}
+
+// src/hdc/input.ts
+function reqNum(value, name, type) {
+  if (value === void 0 || Number.isNaN(value)) {
+    throw new OniroError(`send input "${type}" requires a numeric ${name}.`);
+  }
+  return value;
+}
+function buildInputCommand(opts) {
+  switch (opts.type) {
+    case "click":
+    case "doubleClick":
+    case "longClick":
+      return `uitest uiInput ${opts.type} ${reqNum(opts.pxX, "pxX", opts.type)} ${reqNum(opts.pxY, "pxY", opts.type)}`;
+    case "swipe":
+    case "drag":
+    case "fling": {
+      const base = `uitest uiInput ${opts.type} ${reqNum(opts.pxX, "pxX", opts.type)} ${reqNum(opts.pxY, "pxY", opts.type)} ${reqNum(opts.pxX2, "pxX2", opts.type)} ${reqNum(opts.pxY2, "pxY2", opts.type)}`;
+      return opts.speed !== void 0 ? `${base} ${opts.speed}` : base;
+    }
+    case "keyEvent":
+      if (opts.key === void 0 || opts.key === "") throw new OniroError('send input "keyEvent" requires a key.');
+      return `uitest uiInput keyEvent ${opts.key}`;
+    case "inputText": {
+      const t = String(opts.text ?? "").replace(/'/g, `'\\''`);
+      if (opts.pxX !== void 0 && opts.pxY !== void 0) {
+        return `uitest uiInput inputText ${opts.pxX} ${opts.pxY} '${t}'`;
+      }
+      return `uitest uiInput text '${t}'`;
+    }
+  }
+}
+async function sendInput(opts) {
+  const cmd = buildInputCommand(opts);
+  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) {
+    throw new OniroError("sendGesture requires at least two waypoints.");
+  }
+  const cmds = [];
+  for (let i = 1; i < waypoints.length; i++) {
+    const a = waypoints[i - 1];
+    const b = waypoints[i];
+    const dt = b.t - a.t;
+    const dist = Math.hypot(b.x - a.x, b.y - a.y);
+    let cmd = `uitest uiInput drag ${a.x} ${a.y} ${b.x} ${b.y}`;
+    if (dt > 0 && dist > 0) cmd += ` ${Math.round(dist / (dt / 1e3))}`;
+    cmds.push(cmd);
+  }
+  return cmds;
+}
+function buildRawTouchCommand(events) {
+  if (events.length === 0) throw new OniroError("sendRawTouch requires at least one event.");
+  const ops = [];
+  let prev = null;
+  for (const ev of events) {
+    if (prev && ev.t > prev.t) ops.push(`-i ${ev.t - prev.t}`);
+    if (ev.type === "down") ops.push(`-d ${ev.x} ${ev.y}`);
+    else if (ev.type === "up") ops.push(`-u ${ev.x} ${ev.y}`);
+    else ops.push(`-m ${prev ? `${prev.x} ${prev.y} ` : ""}${ev.x} ${ev.y}`);
+    prev = ev;
+  }
+  return `uinput -T ${ops.join(" ")}`;
+}
+function waypointsToRawEvents(waypoints, holdStartMs = 0, holdEndMs = 0) {
+  if (waypoints.length < 2) throw new OniroError("sendGesture requires at least two waypoints.");
+  const first = waypoints[0];
+  const events = [{ type: "down", x: first.x, y: first.y, t: 0 }];
+  for (let i = 1; i < waypoints.length; i++) {
+    const w = waypoints[i];
+    events.push({ type: "move", x: w.x, y: w.y, t: w.t + holdStartMs });
+  }
+  const last = waypoints[waypoints.length - 1];
+  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) {
+  if ((opts.holdEndMs ?? 0) > 0) {
+    opts.logger?.warn(
+      "sendGesture: hold-end has no uitest equivalent and is ignored; use sendRawTouch for a trailing hold."
+    );
+  }
+  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 shellChecked({ config: opts.config, command: cmd, deviceSerial: opts.deviceSerial, timeoutMs: 3e4, logger: opts.logger });
+  ensureRemoteOk(res, `hdc shell ${cmd}`);
+}
+
+// src/hdc/dump.ts
+var fs18 = __toESM(require("fs"), 1);
+var os9 = __toESM(require("os"), 1);
+var path18 = __toESM(require("path"), 1);
+var import_node_crypto2 = require("crypto");
+function parseBounds(s) {
+  const m = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/.exec(s ?? "");
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4])];
+}
+var STRUCTURAL_TYPES = /* @__PURE__ */ new Set([
+  "Stack",
+  "Column",
+  "Row",
+  "Flex",
+  "__Common__",
+  "Grid",
+  "GridItem",
+  "List",
+  "ListItem",
+  "Scroll",
+  "Swiper",
+  "SwiperContent",
+  "Navigator",
+  "Tabs",
+  "TabContent",
+  "RelativeContainer",
+  "WaterFlow",
+  "FlowItem"
+]);
+var FLAG_MAP = [
+  ["clickable", "click"],
+  ["checkable", "check"],
+  ["checked", "checked"],
+  ["selected", "sel"],
+  ["focused", "focus"],
+  ["scrollable", "scroll"],
+  ["longClickable", "longClick"]
+];
+function pruneLayout(node, display) {
+  const a = node.attributes ?? {};
+  const px = parseBounds(a.bounds);
+  const out = {};
+  if (px && display) {
+    const w = display.width || 1;
+    const h = display.height || 1;
+    out.b = [
+      +(px[0] / w).toFixed(3),
+      +(px[1] / h).toFixed(3),
+      +(px[2] / w).toFixed(3),
+      +(px[3] / h).toFixed(3)
+    ];
+    out.c = [+((px[0] + px[2]) / 2 / w).toFixed(3), +((px[1] + px[3]) / 2 / h).toFixed(3)];
+  }
+  if (a.type && !STRUCTURAL_TYPES.has(a.type)) out.type = a.type;
+  if (a.text) out.text = a.text;
+  if (a.description) out.desc = a.description;
+  if (a.id) out.id = a.id;
+  if (a.key && a.key !== a.id) out.key = a.key;
+  if (a.bundleName) out.bundle = a.bundleName;
+  for (const [attr, short] of FLAG_MAP) {
+    if (a[attr] === "true") out[short] = true;
+  }
+  const children = [];
+  for (const c of node.children ?? []) {
+    const pc = pruneLayout(c, display);
+    if (pc) {
+      if (Array.isArray(pc)) children.push(...pc);
+      else children.push(pc);
+    }
+  }
+  const hasSignal = Boolean(
+    out.text || out.desc || out.id || out.key || out.click || out.scroll || out.check || out.longClick || out.bundle || out.type && out.type !== "root"
+  );
+  if (!hasSignal && children.length === 0) return null;
+  if (!hasSignal) return children.length === 1 ? children[0] : children;
+  if (children.length) out.children = children;
+  return out;
+}
+async function dumpLayout(opts) {
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  const bundleArg = opts.bundleName ? ` -b '${opts.bundleName.replace(/'/g, `'\\''`)}'` : "";
+  const dump = await shell({ config: opts.config, command: `uitest dumpLayout${bundleArg}`, deviceSerial: opts.deviceSerial, timeoutMs });
+  ensureOk(dump, "uitest dumpLayout");
+  const m = dump.stdout.match(/saved to:\s*(\S+)/i);
+  if (!m) throw new OniroError(`Could not parse dumpLayout output:
+${dump.stdout}`);
+  const remote = m[1];
+  const local = path18.join(os9.tmpdir(), `oniro_layout_${(0, import_node_crypto2.randomBytes)(6).toString("hex")}.json`);
+  try {
+    await recvFile({ config: opts.config, remote, local, deviceSerial: opts.deviceSerial, timeoutMs });
+    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 };
+    }
+    const prunedRaw = pruneLayout(parsed, display);
+    const tree = Array.isArray(prunedRaw) ? { children: prunedRaw } : prunedRaw ?? { children: [] };
+    return { display, tree };
+  } finally {
+    fs18.promises.unlink(local).catch(() => {
+    });
+    void shell({ config: opts.config, command: `rm -f ${remote}`, deviceSerial: opts.deviceSerial }).catch(() => {
+    });
+  }
+}
 
 // src/hdc/hilog.ts
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 function setHilogLevel(opts) {
   const logger = opts.logger ?? noopLogger;
   const hdc = getHdcPath(opts.config);
-  return new Promise((resolve2, reject) => {
-    const child = (0, import_node_child_process5.spawn)(hdc, ["shell", "hilog", "-b", opts.level]);
+  return new Promise((resolve4, reject) => {
+    const child = (0, import_node_child_process6.spawn)(hdc, ["shell", "hilog", "-b", opts.level]);
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -1564,7 +2619,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}`);
@@ -1575,11 +2630,16 @@ function setHilogLevel(opts) {
 }
 function streamHilog(opts) {
   const hdc = getHdcPath(opts.config);
-  const args = ["shell", "hilog"];
+  const args = [];
+  if (opts.deviceSerial) args.push("-t", opts.deviceSerial);
+  args.push("shell", "hilog");
   if (opts.processId && opts.processId.trim() !== "") {
     args.push("-P", opts.processId.trim());
   }
-  return (0, import_node_child_process5.spawn)(hdc, args);
+  if (opts.domain !== void 0 && `${opts.domain}` !== "") {
+    args.push("-D", `${opts.domain}`);
+  }
+  return (0, import_node_child_process6.spawn)(hdc, args);
 }
 var HILOG_LINE_RE = /^(\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\s+(\d+)\s+(\d+)\s+([DIWEF])\s+(\S+):\s+(.*)$/;
 function parseHilogLine(line) {
@@ -1594,30 +2654,194 @@ function parseHilogLine(line) {
     message: match[6]
   };
 }
+function entryText(e) {
+  return `${e.tag}: ${e.message}`;
+}
+function dedupEntries(entries) {
+  const out = [];
+  let lastKey = "";
+  for (const e of entries) {
+    const key = `${e.level}|${e.tag}|${e.message}`;
+    if (key === lastKey) continue;
+    out.push(e);
+    lastKey = key;
+  }
+  return out;
+}
+async function resolveProcessId(config, bundle, deviceSerial) {
+  if (!bundle) return void 0;
+  const proc = await findRunningProcess({ config, bundle, deviceSerial });
+  return proc?.pid;
+}
+function waitForLog(opts) {
+  return new Promise((resolve4, reject) => {
+    const deadline = Date.now() + opts.timeoutMs;
+    let settled = false;
+    let child = null;
+    let reconnectTimer;
+    let buf = "";
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      opts.abortSignal?.removeEventListener("abort", onAbort);
+      if (child) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        child = null;
+      }
+    };
+    const finish = (entry) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve4(entry);
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onAbort = () => fail(new CancelledError("waitForLog cancelled."));
+    const timer = setTimeout(
+      () => fail(new OniroError(`No log line matched ${String(opts.pattern)} within ${opts.timeoutMs}ms.`)),
+      opts.timeoutMs
+    );
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    const spawnStream = async () => {
+      if (settled) return;
+      const processId = await resolveProcessId(opts.config, opts.bundle, opts.deviceSerial);
+      if (settled) return;
+      const stream = streamHilog({ config: opts.config, processId, domain: opts.domain, deviceSerial: opts.deviceSerial });
+      child = stream;
+      stream.stdout.on("data", (d) => {
+        buf += d.toString();
+        let idx;
+        while ((idx = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, idx);
+          buf = buf.slice(idx + 1);
+          const entry = parseHilogLine(line);
+          if (entry && opts.pattern.test(entryText(entry))) {
+            finish(entry);
+            return;
+          }
+        }
+      });
+      const onEnd = () => {
+        if (settled || child !== stream) return;
+        child = null;
+        if (Date.now() < deadline) {
+          reconnectTimer = setTimeout(() => void spawnStream(), 1e3);
+        }
+      };
+      stream.once("close", onEnd);
+      stream.once("error", onEnd);
+    };
+    void spawnStream();
+  });
+}
+function watchLog(opts) {
+  return new Promise((resolve4, reject) => {
+    const matches = [];
+    let settled = false;
+    let child = null;
+    let buf = "";
+    const cleanup = () => {
+      clearTimeout(timer);
+      opts.abortSignal?.removeEventListener("abort", onAbort);
+      if (child) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        child = null;
+      }
+    };
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve4(opts.dedup === false ? matches : dedupEntries(matches));
+    };
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new CancelledError("watchLog cancelled."));
+    };
+    const timer = setTimeout(done, opts.durationMs);
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    void (async () => {
+      const processId = await resolveProcessId(opts.config, opts.bundle, opts.deviceSerial);
+      if (settled) return;
+      const stream = streamHilog({ config: opts.config, processId, domain: opts.domain, deviceSerial: opts.deviceSerial });
+      child = stream;
+      stream.stdout.on("data", (d) => {
+        buf += d.toString();
+        let idx;
+        while ((idx = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, idx);
+          buf = buf.slice(idx + 1);
+          const entry = parseHilogLine(line);
+          if (entry && opts.pattern.test(entryText(entry))) matches.push(entry);
+        }
+      });
+    })();
+  });
+}
+async function dumpLog(opts) {
+  let pipe = "hilog -x";
+  if (opts.domain !== void 0 && `${opts.domain}` !== "") pipe += ` -D ${opts.domain}`;
+  if (opts.bundle) {
+    const proc = await findRunningProcess({ config: opts.config, bundle: opts.bundle, deviceSerial: opts.deviceSerial });
+    if (!proc) return [];
+    pipe += ` | grep -E '\\b${proc.pid}\\b'`;
+  }
+  if (opts.grep) {
+    const safeGrep = opts.grep.replace(/'/g, `'\\''`);
+    pipe += ` | grep -E '${safeGrep}'`;
+  }
+  if (opts.lines && opts.lines > 0) pipe += ` | tail -n ${Math.floor(opts.lines)}`;
+  const res = await shell({
+    config: opts.config,
+    command: pipe,
+    deviceSerial: opts.deviceSerial,
+    timeoutMs: opts.timeoutMs ?? 3e4,
+    logger: opts.logger
+  });
+  return res.stdout.split("\n").map((line) => parseHilogLine(line)).filter((e) => e !== null);
+}
 
 // src/build/runHvigorw.ts
-var fs15 = __toESM(require("fs"), 1);
-var path15 = __toESM(require("path"), 1);
-var import_node_child_process6 = require("child_process");
+var fs19 = __toESM(require("fs"), 1);
+var path19 = __toESM(require("path"), 1);
+var import_node_child_process7 = require("child_process");
+function buildHvigorwArgs(opts) {
+  const args = [opts.task ?? "assembleHap", "--mode", "module"];
+  args.push("-p", `product=${opts.product ?? "default"}`);
+  if (opts.module) args.push("-p", `module=${opts.module}`);
+  if (opts.buildMode) args.push("-p", `buildMode=${opts.buildMode}`);
+  args.push("--stacktrace", "--no-daemon");
+  if (opts.parallel === false) args.push("--no-parallel");
+  if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+  return args;
+}
 function runHvigorw(opts) {
   const { config, projectDir } = opts;
   const logger = opts.logger ?? noopLogger;
-  if (!fs15.existsSync(path15.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 (!fs15.existsSync(getCmdToolsPath(config))) {
+  if (!fs19.existsSync(getCmdToolsPath(config))) {
     throw new CmdToolsNotInstalledError(getCmdToolsPath(config));
   }
   const hvigorw = getHvigorwPath(config, projectDir);
-  const args = [opts.task ?? "assembleHap", "--mode", "module"];
-  args.push("-p", `product=${opts.product ?? "default"}`);
-  if (opts.module) args.push("-p", `module=${opts.module}`);
-  if (opts.buildMode) args.push("-p", `buildMode=${opts.buildMode}`);
-  args.push("--stacktrace", "--no-parallel", "--no-daemon");
-  if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+  const args = buildHvigorwArgs(opts);
   if (process.platform !== "win32") {
     try {
-      fs15.chmodSync(hvigorw, 493);
+      fs19.chmodSync(hvigorw, 493);
     } catch {
     }
   }
@@ -1625,9 +2849,26 @@ 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;
+    }
     logger.info(`[build] ${hvigorw} ${args.join(" ")}`);
-    const child = (0, import_node_child_process6.spawn)(hvigorw, args, { cwd: projectDir, env, shell: false });
+    const child = (0, import_node_child_process7.spawn)(hvigorw, args, { cwd: projectDir, env, shell: false });
+    let settled = false;
+    const cleanup = () => opts.abortSignal?.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new CancelledError("hvigorw build cancelled."));
+    };
+    opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
     child.stdout.on("data", (chunk) => {
       const text = chunk.toString();
       opts.onOutput?.(text, "stdout");
@@ -1638,15 +2879,153 @@ function runHvigorw(opts) {
       opts.onOutput?.(text, "stderr");
       logger.warn(text.trimEnd());
     });
-    child.on("error", (err) => reject(new OniroError(`Failed to start hvigorw: ${err.message}`, err)));
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new OniroError(`Failed to start hvigorw: ${err.message}`, err));
+    });
     child.on("close", (code) => {
+      if (settled) return;
+      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
+var fs20 = __toESM(require("fs"), 1);
+var path20 = __toESM(require("path"), 1);
+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;
+  const maxDepth = opts.maxDepth ?? 8;
+  const result = {};
+  const walk = async (dir, depth) => {
+    if (depth > maxDepth) return;
+    const entries = await fs20.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+      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 = 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);
+      }
+    }
+  };
+  await walk(projectDir, 0);
+  return result;
+}
+
+// src/build/ohpm.ts
+var fs21 = __toESM(require("fs"), 1);
+var path21 = __toESM(require("path"), 1);
+function runOhpm(opts) {
+  return runProcess({
+    command: getOhpmPath(opts.config),
+    args: [...opts.args],
+    cwd: opts.projectDir,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+}
+async function ensureOhModules(opts) {
+  if (fs21.existsSync(path21.join(opts.projectDir, "oh_modules"))) {
+    return { installed: false };
+  }
+  const res = await runOhpm({
+    config: opts.config,
+    projectDir: opts.projectDir,
+    args: ["install", "--all"],
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  ensureOk(res, "ohpm install --all");
+  return { installed: true };
+}
+
+// src/build/codelinter.ts
+var FINDING_RE = /^(.*?):(\d+):(?:\d+:)?\s*(error|warning|warn|info)\b[:\s-]*(.*)$/i;
+var TRAILING_CODE_RE = /[([]([\w@/.\-]+)[)\]]\s*$/;
+function parseCodelinterFindings(output) {
+  const findings = [];
+  for (const raw of output.split("\n")) {
+    const m = FINDING_RE.exec(raw.trim());
+    if (!m) continue;
+    let message = m[4].trim();
+    let code = "";
+    const codeMatch = TRAILING_CODE_RE.exec(message);
+    if (codeMatch) {
+      code = codeMatch[1];
+      message = message.slice(0, codeMatch.index).trim();
+    }
+    findings.push({ file: m[1].trim(), line: Number(m[2]), severity: m[3].toLowerCase(), code, message });
+  }
+  return findings;
+}
+async function runCodelinter(opts) {
+  const res = await runProcess({
+    command: getCmdToolsBin(opts.config, "codelinter"),
+    args: opts.files?.length ? [...opts.files] : [],
+    cwd: opts.projectDir,
+    timeoutMs: opts.timeoutMs ?? 6e5,
+    abortSignal: opts.abortSignal,
+    logger: opts.logger
+  });
+  const raw = `${res.stdout}${res.stderr}`;
+  return { code: res.code, findings: parseCodelinterFindings(raw), raw };
+}
+
+// src/build/buildHap.ts
+async function buildHap(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "build");
+  const warnings = [];
+  const start = Date.now();
+  if (opts.autoInstallDeps !== false) {
+    const r = await ensureOhModules({
+      config: opts.config,
+      projectDir: opts.projectDir,
+      abortSignal: opts.abortSignal,
+      onOutput: opts.onOutput,
+      logger: opts.logger
+    });
+    if (r.installed) logger.info("ran ohpm install --all (oh_modules was missing)");
+  }
+  const { exitCode } = await runHvigorw({
+    config: opts.config,
+    projectDir: opts.projectDir,
+    product: opts.product,
+    module: opts.module,
+    buildMode: opts.mode,
+    task: opts.task,
+    parallel: opts.parallel,
+    abortSignal: opts.abortSignal,
+    onOutput: opts.onOutput,
+    logger: opts.logger
+  });
+  const discoveredHaps = await discoverHaps({ projectDir: opts.projectDir });
+  const anySigned = Object.values(discoveredHaps).some((m) => m.signed.length > 0);
+  if (!anySigned) {
+    warnings.push(
+      "No signed HAPs found \u2014 configure signingConfigs in build-profile.json5 (unsigned HAPs are rejected by most devices)."
+    );
+  }
+  return { exitCode, durationMs: Date.now() - start, discoveredHaps, warnings };
+}
+
 // src/project/validators.ts
 function isValidProjectName(name) {
   if (!name) return false;
@@ -1658,21 +3037,21 @@ function isValidBundleName(bundleName) {
 }
 
 // src/project/templates.ts
-var fs16 = __toESM(require("fs"), 1);
-var path16 = __toESM(require("path"), 1);
+var fs22 = __toESM(require("fs"), 1);
+var path22 = __toESM(require("path"), 1);
 function toHumanTemplateName(folderName) {
   return folderName.replace(/([a-z])([A-Z])/g, "$1 $2");
 }
 function listTemplates(templateRoot) {
-  if (!fs16.existsSync(templateRoot)) return [];
-  const entries = fs16.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 = path16.join(templateRoot, e.name);
-    const metaPath = path16.join(dir, "template.json");
+    const dir = path22.join(templateRoot, e.name);
+    const metaPath = path22.join(dir, "template.json");
     let meta = {};
-    if (fs16.existsSync(metaPath)) {
+    if (fs22.existsSync(metaPath)) {
       try {
-        meta = JSON.parse(fs16.readFileSync(metaPath, "utf8"));
+        meta = JSON.parse(fs22.readFileSync(metaPath, "utf8"));
       } catch {
       }
     }
@@ -1687,57 +3066,57 @@ function listTemplates(templateRoot) {
 function validateTemplateLayout(templateDir, defaultModuleName) {
   const required = [
     "build-profile.json5",
-    path16.join("AppScope", "app.json5"),
-    path16.join(defaultModuleName, "src", "main", "module.json5"),
-    path16.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) => !fs16.existsSync(path16.join(templateDir, rel)));
+  return required.filter((rel) => !fs22.existsSync(path22.join(templateDir, rel)));
 }
 
 // src/project/createScaffold.ts
-var fs18 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
+var fs24 = __toESM(require("fs"), 1);
+var path23 = __toESM(require("path"), 1);
 
 // src/project/jsonHelpers.ts
-var fs17 = __toESM(require("fs"), 1);
+var fs23 = __toESM(require("fs"), 1);
 var import_json54 = __toESM(require("json5"), 1);
 function readJson5File(filePath) {
-  return import_json54.default.parse(fs17.readFileSync(filePath, "utf8"));
+  return import_json54.default.parse(fs23.readFileSync(filePath, "utf8"));
 }
 function writeJson5File(filePath, value) {
-  fs17.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(fs17.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs23.readFileSync(filePath, "utf8"));
 }
 function writeJsonFile(filePath, value) {
-  fs17.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 fs18.promises.access(p);
+    await fs24.promises.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function copyDirRecursive(srcDir, destDir) {
-  await fs18.promises.mkdir(destDir, { recursive: true });
-  const entries = await fs18.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 = path17.join(srcDir, entry.name);
-    const dest = path17.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 fs18.promises.copyFile(src, dest);
+      await fs24.promises.copyFile(src, dest);
     }
   }
 }
@@ -1745,9 +3124,9 @@ async function normalizeJson5ToJson(projectDir, logger) {
   const stack = [projectDir];
   while (stack.length > 0) {
     const currentDir = stack.pop();
-    const entries = await fs18.promises.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs24.promises.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path17.join(currentDir, entry.name);
+      const fullPath = path23.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         stack.push(fullPath);
@@ -1769,23 +3148,23 @@ function toJavaPropertiesPath(p) {
 function createOrUpdateLocalProperties(projectDir, sdkDir) {
   const content = `sdk.dir=${toJavaPropertiesPath(sdkDir)}
 `;
-  fs18.writeFileSync(path17.join(projectDir, "local.properties"), content, "utf8");
+  fs24.writeFileSync(path23.join(projectDir, "local.properties"), content, "utf8");
 }
 function renameIfExists(fromPath, toPath) {
-  if (fs18.existsSync(fromPath) && fromPath !== toPath) {
-    fs18.renameSync(fromPath, toPath);
+  if (fs24.existsSync(fromPath) && fromPath !== toPath) {
+    fs24.renameSync(fromPath, toPath);
   }
 }
 function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
-  const appJsonPath = path17.join(projectDir, "AppScope", "app.json5");
-  if (fs18.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 = path17.join(projectDir, "AppScope", "resources", "base", "element", "string.json");
-  if (fs18.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");
@@ -1793,8 +3172,8 @@ function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
     }
     writeJsonFile(stringsPath, strings);
   }
-  const buildProfilePath = path17.join(projectDir, "build-profile.json5");
-  if (fs18.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) {
@@ -1807,23 +3186,23 @@ function updateTemplateConfigs(projectDir, args, sdkBaseDir) {
     }
     writeJson5File(buildProfilePath, buildProfile);
   }
-  const moduleJsonPath = path17.join(projectDir, args.moduleName, "src", "main", "module.json5");
-  if (fs18.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 = path17.join(projectDir, args.moduleName, "oh-package.json5");
-  if (fs18.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 = path17.join(projectDir, ".vscode");
-  fs18.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(path17.join(vscodeDir, "settings.json"), {
+  writeJsonFile(path23.join(vscodeDir, "settings.json"), {
     "oniro.hapPath": hapPath,
     "files.associations": { "*.json5": "jsonc" }
   });
@@ -1840,7 +3219,7 @@ async function createScaffold(opts) {
   if (!opts.location || !await pathExists(opts.location)) {
     throw new OniroError(`Location does not exist: ${opts.location}`);
   }
-  const templateDir = path17.join(opts.templateRoot, opts.templateId);
+  const templateDir = path23.join(opts.templateRoot, opts.templateId);
   if (!await pathExists(templateDir)) {
     throw new OniroError(`Template not found: ${templateDir}`);
   }
@@ -1853,17 +3232,17 @@ async function createScaffold(opts) {
     throw new OniroError(`Template '${opts.templateId}' is missing required files:
 - ${missing.join("\n- ")}`);
   }
-  const projectDir = path17.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 fs18.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(path17.join(projectDir, defaultModuleName), path17.join(projectDir, moduleName));
+    renameIfExists(path23.join(projectDir, defaultModuleName), path23.join(projectDir, moduleName));
   }
   updateTemplateConfigs(
     projectDir,
@@ -1879,8 +3258,225 @@ async function createScaffold(opts) {
   return { projectDir };
 }
 
+// src/project/listModules.ts
+var fs25 = __toESM(require("fs"), 1);
+var path24 = __toESM(require("path"), 1);
+function listModules(opts) {
+  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);
+  return (parsed.modules ?? []).filter((m) => Boolean(m.name)).map((m) => ({
+    name: m.name,
+    srcPath: m.srcPath ?? `./${m.name}`,
+    targets: (m.targets ?? []).map((t) => t.name).filter((n) => Boolean(n))
+  }));
+}
+
+// src/project/abilities.ts
+var fs26 = __toESM(require("fs"), 1);
+var path25 = __toESM(require("path"), 1);
+function listAbilities(opts) {
+  const moduleName = opts.moduleName ?? "entry";
+  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);
+  return (parsed.module?.abilities ?? []).filter((a) => Boolean(a.name)).map((a) => ({ name: a.name, type: a.type, visible: a.visible, srcEntry: a.srcEntry }));
+}
+
+// src/project/prepareSigning.ts
+var fs27 = __toESM(require("fs"), 1);
+var path26 = __toESM(require("path"), 1);
+function hasSigningArtifacts(dir) {
+  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;
+  } catch {
+    return false;
+  }
+}
+function prepareSigning(opts) {
+  if (hasSigningArtifacts(opts.projectDir)) {
+    return { source: "present" };
+  }
+  generateSigningConfigs({
+    projectDir: opts.projectDir,
+    sdkHome: getOhosBaseSdkHome(opts.config),
+    apl: opts.apl,
+    appFeature: opts.appFeature,
+    acls: opts.acls,
+    passwords: opts.passwords,
+    logger: opts.logger
+  });
+  return { source: "fresh" };
+}
+
+// src/device/hidumper.ts
+async function dumpScreen(opts) {
+  const res = await shell({ config: opts.config, command: "hidumper -s 10 -a screen", deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 1e4, logger: opts.logger });
+  if (res.code !== 0) return null;
+  const m = res.stdout.match(/render resolution=(\d+)x(\d+)/);
+  if (!m) return null;
+  return { width: Number(m[1]), height: Number(m[2]), raw: res.stdout };
+}
+async function dumpWindow(opts) {
+  const res = await shell({ config: opts.config, command: "hidumper -s WindowManagerService -a -a", deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 15e3, logger: opts.logger });
+  return res.stdout;
+}
+async function dumpRenderService(opts) {
+  const res = await shell({ config: opts.config, command: "hidumper -s RenderService -a allInfo", deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 15e3, logger: opts.logger });
+  return res.stdout;
+}
+
+// src/device/info.ts
+var PROPS = [
+  ["model", "const.product.model"],
+  ["manufacturer", "const.product.manufacturer"],
+  ["brand", "const.product.brand"],
+  ["osFullName", "const.ohos.fullname"],
+  ["osReleaseType", "const.ohos.releasetype"],
+  ["sdkApiVersion", "const.ohos.apiversion"],
+  ["buildVersion", "const.product.software.version"]
+];
+async function getDeviceInfo(opts) {
+  const info = { serial: opts.deviceSerial ?? "(default)", display: null };
+  for (const [field, prop] of PROPS) {
+    try {
+      const value = await paramGet(opts.config, prop, { deviceSerial: opts.deviceSerial, timeoutMs: opts.timeoutMs ?? 1e4, logger: opts.logger });
+      if (value) info[field] = value;
+    } catch {
+    }
+  }
+  const screen = await dumpScreen({ config: opts.config, deviceSerial: opts.deviceSerial, logger: opts.logger });
+  if (screen) info.display = { width: screen.width, height: screen.height };
+  return info;
+}
+
+// src/install/diffHapAssets.ts
+var import_node_stream_zip2 = __toESM(require("node-stream-zip"), 1);
+function diffEntryNames(installed, next) {
+  const installedSet = new Set(installed);
+  const nextSet = new Set(next);
+  return {
+    addedAssetPaths: [...nextSet].filter((n) => !installedSet.has(n)).sort(),
+    removedAssetPaths: [...installedSet].filter((n) => !nextSet.has(n)).sort()
+  };
+}
+async function listFileEntries(hapPath) {
+  const zip = new import_node_stream_zip2.default.async({ file: hapPath });
+  try {
+    const entries = await zip.entries();
+    return Object.values(entries).filter((e) => !e.isDirectory).map((e) => e.name);
+  } finally {
+    await zip.close();
+  }
+}
+async function diffHapAssets(opts) {
+  const [installed, next] = await Promise.all([listFileEntries(opts.installedHap), listFileEntries(opts.newHap)]);
+  return diffEntryNames(installed, next);
+}
+
+// src/install/apply.ts
+var fs28 = __toESM(require("fs"), 1);
+var path27 = __toESM(require("path"), 1);
+function decideInstallMethod(s) {
+  if (!s.signInfoInconsistent) return "replace";
+  if (s.isSystemBundle && !s.allowUninstall) return "refuse";
+  return "uninstall-install";
+}
+function decideReboot(s) {
+  if (s.assetsChanged) return { reboot: true, reason: "asset-cache" };
+  if (s.isSystemBundle && s.preInstallPid !== null && s.postInstallPid === s.preInstallPid) {
+    return { reboot: true, reason: "pid-unchanged" };
+  }
+  return { reboot: false, reason: "none" };
+}
+var SIGN_INFO_INCONSISTENT = /9568332|sign.*info.*inconsistent/i;
+async function pidOf(config, bundle, deviceSerial) {
+  const proc = await findRunningProcess({ config, bundle, deviceSerial });
+  return proc ? Number(proc.pid) : null;
+}
+async function resolveHapPath(opts) {
+  let hapPath = opts.hapPath;
+  if (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 });
+    if (opts.module) {
+      const signed = haps[opts.module]?.signed ?? [];
+      if (signed.length === 0) throw new OniroError(`No signed HAP for module ${opts.module}. Build first.`);
+      hapPath = signed[0];
+    } else {
+      const withSigned = Object.entries(haps).filter(([, m]) => m.signed.length > 0);
+      if (withSigned.length === 0) throw new OniroError("No signed HAP found. Build first.");
+      if (withSigned.length > 1) {
+        throw new OniroError(
+          `Multiple modules have signed HAPs (${withSigned.map(([k]) => k).join(", ")}). Pass module to choose.`
+        );
+      }
+      hapPath = withSigned[0][1].signed[0];
+    }
+  }
+  if (!fs28.existsSync(hapPath)) throw new OniroError(`HAP not found at ${hapPath}.`);
+  return hapPath;
+}
+async function applyChanges(opts) {
+  const logger = scopedLogger(opts.logger ?? noopLogger, "apply");
+  const { config, bundle, deviceSerial } = opts;
+  const isSystemBundle = opts.isSystemBundle ?? false;
+  const allowUninstall = opts.allowUninstall ?? false;
+  const hapPath = await resolveHapPath(opts);
+  let assetsChanged = false;
+  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;
+    } catch (err) {
+      logger.debug(`asset diff skipped: ${err.message}`);
+    }
+  }
+  const preInstallPid = await pidOf(config, bundle, deviceSerial);
+  const replaceRes = await hdcExec({ config, args: ["install", "-r", hapPath], deviceSerial, timeoutMs: 3e5 });
+  const signInfoInconsistent = SIGN_INFO_INCONSISTENT.test(`${replaceRes.stdout}${replaceRes.stderr}`);
+  const decision = decideInstallMethod({ signInfoInconsistent, isSystemBundle, allowUninstall });
+  let installMethod;
+  if (decision === "refuse") {
+    throw new OniroError(
+      `Refusing to reinstall system bundle ${bundle}: signing certs are inconsistent (9568332). Align the signing certs first \u2014 uninstalling a system bundle can brick the device. Pass allowUninstall to override.`
+    );
+  }
+  if (decision === "uninstall-install") {
+    logger.warn(`sign-info inconsistent for ${bundle}; uninstalling then installing fresh.`);
+    await uninstallApp({ config, bundle, deviceSerial });
+    ensureOk(await hdcExec({ config, args: ["install", hapPath], deviceSerial, timeoutMs: 3e5 }), `hdc install ${hapPath}`);
+    installMethod = "uninstall-install";
+  } else {
+    ensureOk(replaceRes, `hdc install -r ${hapPath}`);
+    installMethod = "replace";
+  }
+  let postInstallPid = await pidOf(config, bundle, deviceSerial);
+  const rebootDecision = decideReboot({ assetsChanged, isSystemBundle, preInstallPid, postInstallPid });
+  let method = installMethod;
+  let cacheCleared = false;
+  if (rebootDecision.reboot) {
+    logger.info(`rebooting (${rebootDecision.reason}) to apply changes to ${bundle}.`);
+    await reboot({ config, waitForBundle: bundle, deviceSerial, abortSignal: opts.abortSignal, logger: opts.logger });
+    postInstallPid = await pidOf(config, bundle, deviceSerial);
+    method = "reboot";
+    cacheCleared = rebootDecision.reason === "asset-cache";
+  }
+  return { method, preInstallPid, postInstallPid, replaced: installMethod === "replace", cacheCleared };
+}
+
 // src/index.ts
-var VERSION = "0.6.2";
+var VERSION = "0.8.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_SDKS,
@@ -1889,72 +3485,148 @@ var VERSION = "0.6.2";
   CancelledError,
   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,
+  dedupEntries,
   defaultContext,
   defaultPaths,
+  detectAaStartFailure,
   detectProjectSdkVersion,
   detectSigningConfigNames,
+  diffEntryNames,
+  diffHapAssets,
+  discoverHaps,
   downloadAndInstallSdk,
   downloadFile,
+  dumpLayout,
+  dumpLog,
+  dumpRenderService,
+  dumpScreen,
+  dumpWindow,
   encryptPwd,
+  ensureFreeSpace,
+  ensureOhModules,
+  ensureOk,
+  ensureRemoteOk,
   extractTarball,
   extractZipWithProgress,
   findAppProcessId,
   findCmdToolsSourceDir,
+  findRunningProcess,
+  forceStop,
+  formatBytes,
   generateSigningConfigs,
   getBundleName,
   getCmdToolsBin,
   getCmdToolsDownloadUrl,
   getCmdToolsPath,
   getCmdToolsStatus,
+  getDeviceInfo,
+  getDisplaySize,
   getEmulatorDir,
+  getFreeSpaceBytes,
   getHdcPath,
   getHvigorwPath,
   getInstalledSdks,
   getKey,
   getMainAbility,
   getOhosBaseSdkHome,
+  getOhpmPath,
   getOsFolder,
   getSdkFilename,
   getSdkRootDir,
   getSupportedSdksForUi,
+  hdcExec,
   installApp,
   installCmdTools,
   installEmulator,
   isCmdToolsInstalled,
   isEmulatorInstalled,
+  isOutOfSpaceError,
+  isRamBackedPath,
   isValidBundleName,
   isValidProjectName,
   launchApp,
+  listAbilities,
+  listDevices,
+  listModules,
   listRunningProcesses,
   listTemplates,
   nonInteractivePrompter,
   noopLogger,
   noopProgress,
+  paramGet,
+  paramSet,
+  parseBounds,
+  parseCodelinterFindings,
+  parseDeviceList,
   parseHilogLine,
+  parseMainAbilityFromBmDump,
+  parseRemoteExit,
   pickSigningKind,
+  prepareSigning,
+  pruneLayout,
   readJson5File,
   readJsonFile,
+  reboot,
+  recvFile,
   removeCmdTools,
   removeEmulator,
   removeSdk,
+  removeTempWorkDir,
+  resolveTmpRoot,
+  runCodelinter,
   runHvigorw,
+  runOhpm,
+  runProcess,
+  scopedLogger,
+  selectDevice,
+  sendFile,
+  sendGesture,
+  sendInput,
+  sendRawTouch,
   setHilogLevel,
+  shell,
+  shellChecked,
   startEmulator,
   staticConfig,
   stopEmulator,
   streamHilog,
+  takeScreenshot,
+  toSpaceError,
+  uninstallApp,
   validateTemplateLayout,
   verifySha256,
+  waitForBoot,
+  waitForBundle,
+  waitForCondition,
+  waitForLog,
+  watchLog,
+  waypointsToRawEvents,
   writeJson5File,
   writeJsonFile
 });