@lark-apaas/fullstack-cli 1.1.70 → 1.1.71-alpha.20261103025257

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs31 from "fs";
-import path26 from "path";
+import fs33 from "fs";
+import path28 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -3493,9 +3493,9 @@ async function run3(options = {}) {
 }
 
 // src/commands/upgrade/deps/run.handler.ts
-import { spawnSync as spawnSync4 } from "child_process";
-import fs13 from "fs";
-import path10 from "path";
+import { spawnSync as spawnSync6 } from "child_process";
+import fs15 from "fs";
+import path12 from "path";
 
 // src/utils/grayscale/config.ts
 function getGrayscaleConfig(configJson) {
@@ -3656,11 +3656,317 @@ function resolveGrayscaleVersions(_cwd, configJson) {
   return versions;
 }
 
+// src/commands/upgrade/deps/drizzle-peer-migration.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import fs13 from "fs";
+import path10 from "path";
+var dataPaasSdks = /* @__PURE__ */ new Set([
+  "@lark-apaas/fullstack-nestjs-core",
+  "@lark-apaas/nestjs-datapaas",
+  "@lark-apaas/express-core",
+  "@lark-apaas/express-datapaas"
+]);
+var versionPattern = /^(\d+)\.(\d+)\.(\d+)(?:-([\da-zA-Z.-]+))?(?:\+[\da-zA-Z.-]+)?$/;
+function compareVersions(a, b) {
+  const left = a.match(versionPattern);
+  const right = b.match(versionPattern);
+  for (let index = 1; index <= 3; index++) {
+    const difference = Number(left[index]) - Number(right[index]);
+    if (difference) return difference;
+  }
+  if (!left[4] || !right[4]) return Number(!left[4]) - Number(!right[4]);
+  const leftParts = left[4].split(".");
+  const rightParts = right[4].split(".");
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index++) {
+    const l = leftParts[index];
+    const r = rightParts[index];
+    if (l === r) continue;
+    if (l === void 0 || r === void 0) return l === void 0 ? -1 : 1;
+    const lNumeric = /^\d+$/.test(l);
+    const rNumeric = /^\d+$/.test(r);
+    if (lNumeric && rNumeric) return Number(l) - Number(r);
+    if (lNumeric !== rNumeric) return lNumeric ? -1 : 1;
+    return l < r ? -1 : 1;
+  }
+  return 0;
+}
+function readPublishedSdk(pkg2, selector, cwd) {
+  const result = spawnSync4(
+    "npm",
+    ["view", `${pkg2}@${selector}`, "version", "peerDependencies", "--json"],
+    {
+      cwd,
+      encoding: "utf8",
+      timeout: 3e4,
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  if (result.error || result.status !== 0) {
+    throw new Error(
+      `Cannot resolve Drizzle peer for ${pkg2}@${selector}: ${result.error?.message ?? `npm view exited ${result.status}`}`
+    );
+  }
+  let metadata;
+  try {
+    metadata = JSON.parse(result.stdout?.toString() || "null");
+  } catch {
+    throw new Error(`Invalid npm metadata for ${pkg2}@${selector}`);
+  }
+  const candidates = (Array.isArray(metadata) ? metadata : [metadata]).map(
+    (candidate) => typeof candidate === "string" ? { version: candidate } : candidate
+  );
+  if (!candidates.length || candidates.some(
+    (candidate) => !candidate || typeof candidate.version !== "string" || !versionPattern.test(candidate.version)
+  )) {
+    throw new Error(`Missing published version for ${pkg2}@${selector}`);
+  }
+  return candidates.sort((a, b) => compareVersions(a.version, b.version)).pop();
+}
+function planDrizzlePeerMigration(targets, manifest, cwd, onlyIfPeerNeedsRepair = false) {
+  if (!targets.some((target) => dataPaasSdks.has(target.pkg))) return void 0;
+  const selected = new Map(targets.map((target) => [target.pkg, target.version]));
+  const publishedTargets = new Map(
+    targets.filter((target) => isRegistrySelector(target.version)).map((target) => [
+      target.pkg,
+      readPublishedSdk(target.pkg, target.version, cwd)
+    ])
+  );
+  for (const target of targets) {
+    if (dataPaasSdks.has(target.pkg) && !isRegistrySelector(target.version))
+      throw new Error(
+        `Cannot resolve published Drizzle peer for non-registry SDK ${target.pkg}@${target.version}`
+      );
+  }
+  const declared = { ...manifest.devDependencies, ...manifest.dependencies };
+  const peers = /* @__PURE__ */ new Map();
+  for (const pkg2 of dataPaasSdks) {
+    const selector = selected.get(pkg2) ?? declared[pkg2];
+    if (!selector) continue;
+    let sdk = publishedTargets.get(pkg2);
+    if (!selected.has(pkg2)) {
+      sdk = readRetainedSdk(pkg2, cwd);
+    }
+    sdk ?? (sdk = readPublishedSdk(pkg2, selector, cwd));
+    const peer2 = sdk.peerDependencies?.["drizzle-orm"];
+    if (typeof peer2 !== "string" || !versionPattern.test(peer2)) {
+      throw new Error(
+        `${pkg2}@${sdk.version} must declare an exact drizzle-orm peer; received ${String(peer2)}`
+      );
+    }
+    peers.set(pkg2, peer2);
+  }
+  const versions = new Set(peers.values());
+  if (versions.size !== 1) {
+    throw new Error(
+      `Incompatible Drizzle peers: ${[...peers].map(([pkg2, peer2]) => `${pkg2} requires ${peer2}`).join(", ")}. Upgrade the affected SDKs together.`
+    );
+  }
+  const peer = [...versions][0];
+  if (onlyIfPeerNeedsRepair && peerIsConsistent(manifest, peer, cwd))
+    return void 0;
+  console.log(
+    `[fullstack-cli] Drizzle peer migration: ${declared["drizzle-orm"] ?? "(not declared)"} -> ${peer}`
+  );
+  return [
+    ...targets.map(
+      (target) => `${target.pkg}@${publishedTargets.has(target.pkg) ? installSelector(target.version, publishedTargets.get(target.pkg).version) : target.version}`
+    ),
+    `drizzle-orm@=${peer}`
+  ];
+}
+function readRetainedSdk(pkg2, cwd) {
+  const installed = readOptionalJson(
+    path10.join(cwd, "node_modules", pkg2, "package.json")
+  );
+  if (installed) {
+    if (typeof installed.version !== "string" || !versionPattern.test(installed.version))
+      throw new Error(`Invalid installed SDK metadata for ${pkg2}`);
+    return installed;
+  }
+  const lock = readOptionalJson(path10.join(cwd, "package-lock.json"));
+  const locked = lock?.packages?.[`node_modules/${pkg2}`]?.version ?? lock?.dependencies?.[pkg2]?.version;
+  return typeof locked === "string" && versionPattern.test(locked) ? readPublishedSdk(pkg2, locked, cwd) : void 0;
+}
+function readOptionalJson(filename) {
+  try {
+    return JSON.parse(fs13.readFileSync(filename, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new Error(`Cannot read retained dependency metadata at ${filename}`);
+  }
+}
+function installSelector(requested, resolved) {
+  if (requested.startsWith("^") || requested.startsWith("~"))
+    return `${requested[0]}${resolved}`;
+  if (versionPattern.test(requested) || /^[a-zA-Z][\w.-]*$/.test(requested) || requested === "*")
+    return resolved;
+  return `${requested} >=${resolved}`;
+}
+function isRegistrySelector(selector) {
+  return !/^(?:[a-z][\w+.-]*:|\.?\.?\/|\/|git@)/i.test(selector) && !selector.includes("/") && selector !== "." && selector !== "..";
+}
+function peerIsConsistent(manifest, peer, cwd) {
+  const declarations = [
+    manifest.dependencies?.["drizzle-orm"],
+    manifest.devDependencies?.["drizzle-orm"]
+  ].filter(Boolean);
+  if (!declarations.length || declarations.some((version) => version !== peer && version !== `=${peer}`))
+    return false;
+  try {
+    const installed = JSON.parse(
+      fs13.readFileSync(
+        path10.join(cwd, "node_modules/drizzle-orm/package.json"),
+        "utf8"
+      )
+    );
+    if (installed.version !== peer) return false;
+    const lockPath = path10.join(cwd, "package-lock.json");
+    if (fs13.existsSync(lockPath)) {
+      const lock = JSON.parse(fs13.readFileSync(lockPath, "utf8"));
+      if ((lock.packages?.["node_modules/drizzle-orm"]?.version ?? lock.dependencies?.["drizzle-orm"]?.version) !== peer)
+        return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/upgrade/deps/apply-drizzle-peer-migration.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import fs14 from "fs";
+import path11 from "path";
+var affectedPackages = [
+  "@lark-apaas/fullstack-nestjs-core",
+  "@lark-apaas/nestjs-datapaas",
+  "@lark-apaas/express-core",
+  "@lark-apaas/express-datapaas",
+  "drizzle-orm"
+];
+function applyDrizzlePeerMigration(targets, cwd) {
+  const manifestPath = path11.join(cwd, "package.json");
+  const lockPath = path11.join(cwd, "package-lock.json");
+  const modulesPath = path11.join(cwd, "node_modules");
+  const backup = path11.join(cwd, ".fullstack-cli-peer-migration");
+  if (fs14.existsSync(path11.join(cwd, "npm-shrinkwrap.json"))) {
+    throw new Error(
+      "Drizzle peer migration requires package-lock.json; migrate npm-shrinkwrap.json manually before upgrading SDKs."
+    );
+  }
+  const originalManifest = fs14.readFileSync(manifestPath);
+  const originalLock = fs14.existsSync(lockPath) ? fs14.readFileSync(lockPath) : void 0;
+  const manifest = JSON.parse(originalManifest.toString());
+  const lock = originalLock ? JSON.parse(originalLock.toString()) : void 0;
+  if (lock && (![2, 3].includes(lock.lockfileVersion) || !lock.packages || typeof lock.packages !== "object" || Array.isArray(lock.packages))) {
+    throw new Error(
+      "Drizzle peer migration requires npm lockfileVersion 2 or 3; regenerate the lockfile with the current SDKs before upgrading."
+    );
+  }
+  const peerTarget = targets.find((target) => target.startsWith("drizzle-orm@="));
+  if (!peerTarget)
+    throw new Error("Missing resolved Drizzle peer migration target");
+  const peer = peerTarget.slice("drizzle-orm@=".length);
+  let declared = false;
+  for (const section of ["dependencies", "devDependencies"]) {
+    if (manifest[section]?.["drizzle-orm"] !== void 0) {
+      manifest[section]["drizzle-orm"] = peer;
+      declared = true;
+    }
+  }
+  if (!declared) (manifest.dependencies ?? (manifest.dependencies = {}))["drizzle-orm"] = peer;
+  if (lock) {
+    const selectedNames = new Set(
+      targets.map(
+        (target) => target.slice(0, target.indexOf("@", target.startsWith("@") ? 1 : 0))
+      )
+    );
+    const retainedNames = affectedPackages.filter(
+      (name) => name !== "drizzle-orm" && !selectedNames.has(name) && [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies"
+      ].some((section) => manifest[section]?.[name] !== void 0)
+    );
+    const retainedRoots = retainedNames.map((name) => `node_modules/${name}`);
+    const removedRoots = Object.keys(lock.packages).filter(
+      (key) => !retainedRoots.some(
+        (root) => key === root || key.startsWith(`${root}/`)
+      ) && affectedPackages.some(
+        (name) => key === `node_modules/${name}` || key.endsWith(`/node_modules/${name}`)
+      )
+    );
+    for (const key of Object.keys(lock.packages)) {
+      if (removedRoots.some((root) => key === root || key.startsWith(`${root}/`)))
+        delete lock.packages[key];
+    }
+    if (lock.lockfileVersion === 2 && lock.dependencies) {
+      for (const name of affectedPackages) {
+        if (!retainedNames.includes(name)) delete lock.dependencies[name];
+      }
+    }
+  }
+  try {
+    fs14.mkdirSync(backup);
+  } catch {
+    throw new Error(
+      `Cannot start migration; inspect the existing recovery directory ${backup} before retrying.`
+    );
+  }
+  fs14.writeFileSync(path11.join(backup, "package.json"), originalManifest);
+  if (originalLock)
+    fs14.writeFileSync(path11.join(backup, "package-lock.json"), originalLock);
+  const hadModules = fs14.existsSync(modulesPath);
+  let movedModules = false;
+  try {
+    if (hadModules) {
+      fs14.renameSync(modulesPath, path11.join(backup, "node_modules"));
+      movedModules = true;
+    }
+    fs14.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+    if (lock) fs14.writeFileSync(lockPath, JSON.stringify(lock, null, 2) + "\n");
+    const sdkTargets = targets.filter((target) => target !== peerTarget);
+    runNpm(
+      ["install", "--package-lock-only", "--ignore-scripts", ...sdkTargets],
+      cwd
+    );
+    runNpm(["ci"], cwd);
+  } catch (error) {
+    try {
+      if (movedModules || !hadModules)
+        fs14.rmSync(modulesPath, { recursive: true, force: true });
+      if (movedModules)
+        fs14.renameSync(path11.join(backup, "node_modules"), modulesPath);
+      fs14.writeFileSync(manifestPath, originalManifest);
+      if (originalLock) fs14.writeFileSync(lockPath, originalLock);
+      else fs14.rmSync(lockPath, { force: true });
+      fs14.rmSync(backup, { recursive: true, force: true });
+    } catch {
+      throw new Error(
+        `Drizzle migration failed; recovery files were preserved at ${backup}. Restore package.json, package-lock.json and node_modules before retrying.`
+      );
+    }
+    throw error;
+  }
+  fs14.rmSync(backup, { recursive: true, force: true });
+}
+function runNpm(args, cwd) {
+  const result = spawnSync5("npm", args, { cwd, stdio: "inherit" });
+  if (result.error || result.status !== 0)
+    throw new Error(
+      `Drizzle migration npm ${args[0]} failed: ${result.error?.message ?? `exit ${result.status}`}`
+    );
+}
+
 // src/commands/upgrade/deps/run.handler.ts
 function parseSemver(version) {
   const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
   if (!match) return null;
-  return [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)];
+  return [
+    parseInt(match[1], 10),
+    parseInt(match[2], 10),
+    parseInt(match[3], 10)
+  ];
 }
 function compareSemver(a, b) {
   const va = parseSemver(a);
@@ -3708,13 +4014,37 @@ function findLarkAapaasPackages(cwd, filterPackages) {
   }
   return packages;
 }
-function upgradePackages(packages, version, cwd) {
+function upgradePackages(packages, version, cwd, dryRun = false) {
+  const manifest = readPackageJson(cwd);
+  const declared = { ...manifest.devDependencies, ...manifest.dependencies };
+  const migration = planDrizzlePeerMigration(
+    packages.map((pkg2) => ({ pkg: pkg2, version: version || declared[pkg2] })),
+    manifest,
+    cwd
+  );
+  if (migration) {
+    console.log(
+      `[fullstack-cli] ${dryRun ? "Would install" : "Installing"} ${migration.join(" ")}`
+    );
+    if (dryRun) return;
+    applyDrizzlePeerMigration(migration, cwd);
+    return;
+  }
+  if (dryRun) {
+    console.log(
+      "[fullstack-cli] Dry run mode: would upgrade via npm update (no grayscale)"
+    );
+    packages.forEach(
+      (pkg2) => console.log(`  - ${pkg2} -> ${version || "latest compatible"}`)
+    );
+    return;
+  }
   if (version) {
     console.log(`[fullstack-cli] Upgrading to version ${version}...`);
     packages.forEach((pkg2) => {
       const target = `${pkg2}@${version}`;
       console.log(`[fullstack-cli]   Installing ${target}...`);
-      const result = spawnSync4("npm", ["install", target], {
+      const result = spawnSync6("npm", ["install", target], {
         cwd,
         stdio: "inherit"
       });
@@ -3726,7 +4056,7 @@ function upgradePackages(packages, version, cwd) {
     console.log("[fullstack-cli] Upgrading to latest compatible versions...");
     packages.forEach((pkg2) => {
       console.log(`[fullstack-cli]   Updating ${pkg2}...`);
-      const result = spawnSync4("npm", ["update", pkg2], {
+      const result = spawnSync6("npm", ["update", pkg2], {
         cwd,
         stdio: "inherit"
       });
@@ -3738,34 +4068,54 @@ function upgradePackages(packages, version, cwd) {
 }
 function installGrayscaleVersions(packages, grayscaleVersions, cwd, dryRun, mode) {
   const upgradePlan = [];
+  const selectedVersions = /* @__PURE__ */ new Map();
   for (const pkg2 of packages) {
     const version = grayscaleVersions.get(pkg2);
     if (version) {
+      selectedVersions.set(pkg2, version);
       let current = "";
       try {
-        const installedPkgPath = path10.join(cwd, "node_modules", pkg2, "package.json");
-        const installedPkg = JSON.parse(fs13.readFileSync(installedPkgPath, "utf-8"));
+        const installedPkgPath = path12.join(
+          cwd,
+          "node_modules",
+          pkg2,
+          "package.json"
+        );
+        const installedPkg = JSON.parse(
+          fs15.readFileSync(installedPkgPath, "utf-8")
+        );
         current = installedPkg.version || "";
       } catch (err) {
         const code = err?.code;
         if (code !== "ENOENT") {
-          console.warn(`[fullstack-cli] Failed to read installed version of ${pkg2}: ${err instanceof Error ? err.message : String(err)}`);
+          console.warn(
+            `[fullstack-cli] Failed to read installed version of ${pkg2}: ${err instanceof Error ? err.message : String(err)}`
+          );
         }
       }
       if (mode === "destroy") {
         if (!isRangeVersion(version) && current === version) {
-          console.log(`[fullstack-cli]   ${pkg2}@${version} (already installed, skip)`);
+          selectedVersions.set(pkg2, current);
+          console.log(
+            `[fullstack-cli]   ${pkg2}@${version} (already installed, skip)`
+          );
           continue;
         }
       } else {
         if (isRangeVersion(version)) {
           if (current && satisfiesCaret(current, version)) {
-            console.log(`[fullstack-cli]   ${pkg2}@${current} satisfies ${version} (skip)`);
+            selectedVersions.set(pkg2, current);
+            console.log(
+              `[fullstack-cli]   ${pkg2}@${current} satisfies ${version} (skip)`
+            );
             continue;
           }
         } else {
           if (current === version) {
-            console.log(`[fullstack-cli]   ${pkg2}@${version} (already installed, skip)`);
+            selectedVersions.set(pkg2, current);
+            console.log(
+              `[fullstack-cli]   ${pkg2}@${version} (already installed, skip)`
+            );
             continue;
           }
         }
@@ -3773,11 +4123,25 @@ function installGrayscaleVersions(packages, grayscaleVersions, cwd, dryRun, mode
       upgradePlan.push({ pkg: pkg2, version, current });
     }
   }
-  if (upgradePlan.length === 0) {
-    console.log("[fullstack-cli] No grayscale versions matched current packages");
+  const selectedTargets = packages.flatMap((pkg2) => {
+    const version = selectedVersions.get(pkg2);
+    return version ? [{ pkg: pkg2, version }] : [];
+  });
+  const migration = planDrizzlePeerMigration(
+    selectedTargets,
+    readPackageJson(cwd),
+    cwd,
+    upgradePlan.length === 0
+  );
+  if (upgradePlan.length === 0 && !migration) {
+    console.log(
+      "[fullstack-cli] No grayscale versions matched current packages"
+    );
     return;
   }
-  console.log(`[fullstack-cli] Grayscale upgrade plan (${upgradePlan.length} package(s)):`);
+  console.log(
+    `[fullstack-cli] Grayscale upgrade plan (${upgradePlan.length} package(s)):`
+  );
   upgradePlan.forEach(({ pkg: pkg2, version, current }) => {
     console.log(`  - ${pkg2} ${current} -> ${version}`);
   });
@@ -3785,63 +4149,101 @@ function installGrayscaleVersions(packages, grayscaleVersions, cwd, dryRun, mode
     console.log("[fullstack-cli] Dry run mode, skipping actual installation");
     return;
   }
-  const targets = upgradePlan.map(({ pkg: pkg2, version }) => `${pkg2}@${version}`);
+  const targets = migration ?? upgradePlan.map(({ pkg: pkg2, version }) => `${pkg2}@${version}`);
   console.log(`[fullstack-cli] Installing ${targets.join(" ")}...`);
-  const result = spawnSync4("npm", ["install", ...targets], {
+  if (migration) {
+    applyDrizzlePeerMigration(migration, cwd);
+    return;
+  }
+  const result = spawnSync6("npm", ["install", ...targets], {
     cwd,
     stdio: "inherit"
   });
   if (result.error || result.status !== 0) {
-    console.warn(`[fullstack-cli] npm install failed: ${result.error?.message ?? `exit ${result.status}`}`);
+    throw new Error(
+      `npm install failed: ${result.error?.message ?? `exit ${result.status}`}`
+    );
   }
 }
 async function run4(options = {}) {
   const cwd = process.env.INIT_CWD || process.cwd();
   console.log("[fullstack-cli] Starting dependencies upgrade...");
   try {
-    console.log("[fullstack-cli] Step 1/3: Scanning @lark-apaas dependencies...");
+    console.log(
+      "[fullstack-cli] Step 1/3: Scanning @lark-apaas dependencies..."
+    );
     const packages = findLarkAapaasPackages(cwd, options.packages);
     if (packages.length === 0) {
       console.log("[fullstack-cli] No @lark-apaas packages found");
       return;
     }
-    console.log(`[fullstack-cli] Found ${packages.length} @lark-apaas package(s):`);
+    console.log(
+      `[fullstack-cli] Found ${packages.length} @lark-apaas package(s):`
+    );
     packages.forEach((p) => console.log(`  - ${p}`));
     if (options.skipGrayscale) {
-      console.log("[fullstack-cli] Step 2/3: Skipping grayscale check (--skip-grayscale)");
+      console.log(
+        "[fullstack-cli] Step 2/3: Skipping grayscale check (--skip-grayscale)"
+      );
     } else if (options.version) {
-      console.log("[fullstack-cli] Step 2/3: Skipping grayscale check (explicit --version provided)");
+      console.log(
+        "[fullstack-cli] Step 2/3: Skipping grayscale check (explicit --version provided)"
+      );
     } else if (!options.grayscaleConfig) {
-      console.log("[fullstack-cli] Step 2/3: No grayscale config, falling back to default upgrade");
+      console.log(
+        "[fullstack-cli] Step 2/3: No grayscale config, falling back to default upgrade"
+      );
     } else {
       console.log("[fullstack-cli] Step 2/3: Checking grayscale config...");
       try {
-        const grayscaleVersions = resolveGrayscaleVersions(cwd, options.grayscaleConfig);
+        const grayscaleVersions = resolveGrayscaleVersions(
+          cwd,
+          options.grayscaleConfig
+        );
         if (grayscaleVersions) {
-          console.log("[fullstack-cli] Step 3/3: Applying grayscale versions...");
-          installGrayscaleVersions(packages, grayscaleVersions, cwd, !!options.dryRun, options.mode || "rebuild");
+          console.log(
+            "[fullstack-cli] Step 3/3: Applying grayscale versions..."
+          );
+          installGrayscaleVersions(
+            packages,
+            grayscaleVersions,
+            cwd,
+            !!options.dryRun,
+            options.mode || "rebuild"
+          );
           if (!options.dryRun) {
-            console.log(`[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s) via grayscale`);
-            console.log("[fullstack-cli] Dependencies upgrade completed successfully \u2705");
+            console.log(
+              `[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s) via grayscale`
+            );
+            console.log(
+              "[fullstack-cli] Dependencies upgrade completed successfully \u2705"
+            );
           }
         } else {
-          console.log("[fullstack-cli] Grayscale config provided but not available, skip upgrade");
+          console.log(
+            "[fullstack-cli] Grayscale config provided but not available, skip upgrade"
+          );
         }
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        console.warn(`[fullstack-cli] Grayscale check failed: ${msg}, skip upgrade`);
+        console.warn(
+          `[fullstack-cli] Grayscale check failed: ${msg}, skip upgrade`
+        );
       }
       return;
     }
     if (options.dryRun) {
-      console.log("[fullstack-cli] Dry run mode: would upgrade via npm update (no grayscale)");
-      packages.forEach((p) => console.log(`  - ${p} -> ${options.version || "latest compatible"}`));
+      upgradePackages(packages, options.version, cwd, true);
       return;
     }
     console.log("[fullstack-cli] Step 3/3: Upgrading packages...");
     upgradePackages(packages, options.version, cwd);
-    console.log(`[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s)`);
-    console.log("[fullstack-cli] Dependencies upgrade completed successfully \u2705");
+    console.log(
+      `[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s)`
+    );
+    console.log(
+      "[fullstack-cli] Dependencies upgrade completed successfully \u2705"
+    );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error("[fullstack-cli] Failed to upgrade dependencies:", message);
@@ -3861,9 +4263,9 @@ var depsCommand = {
 };
 
 // src/commands/upgrade/global-deps/run.handler.ts
-import { spawnSync as spawnSync5 } from "child_process";
-import fs14 from "fs";
-import path11 from "path";
+import { spawnSync as spawnSync7 } from "child_process";
+import fs16 from "fs";
+import path13 from "path";
 var MANAGED_GLOBAL_CLIS = [
   "@lark-apaas/fullstack-cli",
   "@lark-apaas/miaoda-cli"
@@ -3874,15 +4276,15 @@ function readGlobalInstalledVersion(pkg2) {
   if (process.env.NPM_CONFIG_PREFIX) candidates.push(process.env.NPM_CONFIG_PREFIX);
   candidates.push("/usr");
   candidates.push("/usr/local");
-  if (process.env.HOME) candidates.push(path11.join(process.env.HOME, ".npm-global"));
+  if (process.env.HOME) candidates.push(path13.join(process.env.HOME, ".npm-global"));
   const seen = /* @__PURE__ */ new Set();
   for (const prefix of candidates) {
     if (seen.has(prefix)) continue;
     seen.add(prefix);
     try {
-      const pkgPath = path11.join(prefix, "lib", "node_modules", pkg2, "package.json");
-      if (fs14.existsSync(pkgPath)) {
-        const meta = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path13.join(prefix, "lib", "node_modules", pkg2, "package.json");
+      if (fs16.existsSync(pkgPath)) {
+        const meta = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
         if (meta && typeof meta.version === "string") return meta.version;
       }
     } catch (err) {
@@ -3940,7 +4342,7 @@ async function run5(options = {}) {
     npmArgs.push("--registry", options.registry);
   }
   console.log(`[fullstack-cli] Running: npm ${npmArgs.join(" ")}`);
-  const result = spawnSync5("npm", npmArgs, { stdio: "inherit" });
+  const result = spawnSync7("npm", npmArgs, { stdio: "inherit" });
   if (result.error || result.status !== 0) {
     console.warn(
       `[fullstack-cli] npm install -g failed: ${result.error?.message ?? `exit ${result.status}`}`
@@ -3979,9 +4381,9 @@ var upgradeCommand = {
 };
 
 // src/commands/action-plugin/utils.ts
-import fs15 from "fs";
-import path12 from "path";
-import { spawnSync as spawnSync6, execSync as execSync2 } from "child_process";
+import fs17 from "fs";
+import path14 from "path";
+import { spawnSync as spawnSync8, execSync as execSync2 } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
   if (!match) {
@@ -3998,18 +4400,18 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getPackageJsonPath() {
-  return path12.join(getProjectRoot(), "package.json");
+  return path14.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
-  return path12.join(getProjectRoot(), "node_modules", pluginName);
+  return path14.join(getProjectRoot(), "node_modules", pluginName);
 }
 function readPackageJson2() {
   const pkgPath = getPackageJsonPath();
-  if (!fs15.existsSync(pkgPath)) {
+  if (!fs17.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs15.readFileSync(pkgPath, "utf-8");
+    const content = fs17.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
@@ -4017,7 +4419,7 @@ function readPackageJson2() {
 }
 function writePackageJson2(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs15.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs17.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
   const pkg2 = readPackageJson2();
@@ -4038,7 +4440,7 @@ function getInstalledPluginVersion(pluginName) {
 }
 function npmInstall(tgzPath) {
   console.log(`[action-plugin] Running npm install ${tgzPath}...`);
-  const result = spawnSync6("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
+  const result = spawnSync8("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
     cwd: getProjectRoot(),
     stdio: "inherit"
   });
@@ -4050,12 +4452,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path12.join(getPluginPath(pluginName), "package.json");
-  if (!fs15.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path14.join(getPluginPath(pluginName), "package.json");
+  if (!fs17.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs15.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs17.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -4063,49 +4465,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path12.join(pluginPath, "package.json");
-  if (!fs15.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path14.join(pluginPath, "package.json");
+  if (!fs17.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs15.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs17.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  const nodeModulesPath = path12.join(getProjectRoot(), "node_modules");
-  const targetDir = path12.join(nodeModulesPath, pluginName);
-  const scopeDir = path12.dirname(targetDir);
-  if (!fs15.existsSync(scopeDir)) {
-    fs15.mkdirSync(scopeDir, { recursive: true });
+  const nodeModulesPath = path14.join(getProjectRoot(), "node_modules");
+  const targetDir = path14.join(nodeModulesPath, pluginName);
+  const scopeDir = path14.dirname(targetDir);
+  if (!fs17.existsSync(scopeDir)) {
+    fs17.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs15.existsSync(targetDir)) {
-    fs15.rmSync(targetDir, { recursive: true });
+  if (fs17.existsSync(targetDir)) {
+    fs17.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path12.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs15.existsSync(tempDir)) {
-    fs15.rmSync(tempDir, { recursive: true });
+  const tempDir = path14.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs17.existsSync(tempDir)) {
+    fs17.rmSync(tempDir, { recursive: true });
   }
-  fs15.mkdirSync(tempDir, { recursive: true });
+  fs17.mkdirSync(tempDir, { recursive: true });
   try {
     execSync2(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path12.join(tempDir, "package");
-    if (fs15.existsSync(extractedDir)) {
-      fs15.renameSync(extractedDir, targetDir);
+    const extractedDir = path14.join(tempDir, "package");
+    if (fs17.existsSync(extractedDir)) {
+      fs17.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs15.readdirSync(tempDir);
+      const files = fs17.readdirSync(tempDir);
       if (files.length === 1) {
-        fs15.renameSync(path12.join(tempDir, files[0]), targetDir);
+        fs17.renameSync(path14.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs15.existsSync(tempDir)) {
-      fs15.rmSync(tempDir, { recursive: true });
+    if (fs17.existsSync(tempDir)) {
+      fs17.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -4114,10 +4516,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path12.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path14.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path12.join(nodeModulesPath, depName);
-    if (!fs15.existsSync(depPath)) {
+    const depPath = path14.join(nodeModulesPath, depName);
+    if (!fs17.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -4128,7 +4530,7 @@ function installMissingDeps(deps) {
     return;
   }
   console.log(`[action-plugin] Installing missing dependencies: ${deps.join(", ")}`);
-  const result = spawnSync6("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
+  const result = spawnSync8("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
     cwd: getProjectRoot(),
     stdio: "inherit"
   });
@@ -4141,16 +4543,16 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs15.existsSync(pluginPath)) {
-    fs15.rmSync(pluginPath, { recursive: true });
+  if (fs17.existsSync(pluginPath)) {
+    fs17.rmSync(pluginPath, { recursive: true });
     console.log(`[action-plugin] Removed ${pluginName}`);
   }
 }
 
 // src/commands/action-plugin/api-client.ts
 import { HttpClient as HttpClient2 } from "@lark-apaas/http-client";
-import fs16 from "fs";
-import path13 from "path";
+import fs18 from "fs";
+import path15 from "path";
 var PLUGIN_CACHE_DIR = "node_modules/.cache/fullstack-cli/plugins";
 async function getPluginVersions(keys, latestOnly = true) {
   const client = getHttpClient();
@@ -4215,19 +4617,19 @@ async function downloadFromPublic(downloadURL) {
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path13.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path15.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs16.existsSync(cacheDir)) {
-    fs16.mkdirSync(cacheDir, { recursive: true });
+  if (!fs18.existsSync(cacheDir)) {
+    fs18.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path13.join(getPluginCacheDir(), filename);
+  return path15.join(getPluginCacheDir(), filename);
 }
 var MAX_RETRIES = 2;
 async function withRetry(operation, description, maxRetries = MAX_RETRIES) {
@@ -4264,7 +4666,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     );
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs16.writeFileSync(tgzPath, tgzBuffer);
+  fs18.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -4278,18 +4680,18 @@ function getCachePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path13.join(getPluginCacheDir(), filename);
+  return path15.join(getPluginCacheDir(), filename);
 }
 function hasCachedPlugin(pluginKey, version) {
   const cachePath = getCachePath(pluginKey, version);
-  return fs16.existsSync(cachePath);
+  return fs18.existsSync(cachePath);
 }
 function listCachedPlugins() {
   const cacheDir = getPluginCacheDir();
-  if (!fs16.existsSync(cacheDir)) {
+  if (!fs18.existsSync(cacheDir)) {
     return [];
   }
-  const files = fs16.readdirSync(cacheDir);
+  const files = fs18.readdirSync(cacheDir);
   const result = [];
   for (const file of files) {
     if (!file.endsWith(".tgz")) continue;
@@ -4297,8 +4699,8 @@ function listCachedPlugins() {
     if (!match) continue;
     const [, rawName, version] = match;
     const name = rawName.replace(/^_/, "@").replace(/_/, "/");
-    const filePath = path13.join(cacheDir, file);
-    const stat = fs16.statSync(filePath);
+    const filePath = path15.join(cacheDir, file);
+    const stat = fs18.statSync(filePath);
     result.push({
       name,
       version,
@@ -4311,14 +4713,14 @@ function listCachedPlugins() {
 }
 function cleanAllCache() {
   const cacheDir = getPluginCacheDir();
-  if (!fs16.existsSync(cacheDir)) {
+  if (!fs18.existsSync(cacheDir)) {
     return 0;
   }
-  const files = fs16.readdirSync(cacheDir);
+  const files = fs18.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (file.endsWith(".tgz")) {
-      fs16.unlinkSync(path13.join(cacheDir, file));
+      fs18.unlinkSync(path15.join(cacheDir, file));
       count++;
     }
   }
@@ -4326,21 +4728,21 @@ function cleanAllCache() {
 }
 function cleanPluginCache(pluginKey, version) {
   const cacheDir = getPluginCacheDir();
-  if (!fs16.existsSync(cacheDir)) {
+  if (!fs18.existsSync(cacheDir)) {
     return 0;
   }
   const safeKey = pluginKey.replace(/[/@]/g, "_");
-  const files = fs16.readdirSync(cacheDir);
+  const files = fs18.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (version) {
       if (file === `${safeKey}@${version}.tgz`) {
-        fs16.unlinkSync(path13.join(cacheDir, file));
+        fs18.unlinkSync(path15.join(cacheDir, file));
         count++;
       }
     } else {
       if (file.startsWith(`${safeKey}@`) && file.endsWith(".tgz")) {
-        fs16.unlinkSync(path13.join(cacheDir, file));
+        fs18.unlinkSync(path15.join(cacheDir, file));
         count++;
       }
     }
@@ -4767,45 +5169,45 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs17 from "fs";
+import fs19 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path14 from "path";
+import path16 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 var SHARED_CAPABILITIES_DIR = "shared/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  const sharedDir = path14.join(getProjectRoot2(), SHARED_CAPABILITIES_DIR);
-  if (fs17.existsSync(sharedDir)) {
+  const sharedDir = path16.join(getProjectRoot2(), SHARED_CAPABILITIES_DIR);
+  if (fs19.existsSync(sharedDir)) {
     return sharedDir;
   }
-  return path14.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path16.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path14.join(getCapabilitiesDir(), `${id}.json`);
+  return path16.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path14.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path16.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs17.existsSync(getCapabilitiesDir());
+  return fs19.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs17.existsSync(dir)) {
+  if (!fs19.existsSync(dir)) {
     return [];
   }
-  const files = fs17.readdirSync(dir);
+  const files = fs19.readdirSync(dir);
   return files.filter((f) => f.endsWith(".json") && f !== "capabilities.json").map((f) => f.replace(/\.json$/, ""));
 }
 function readCapability(id) {
   const filePath = getCapabilityPath(id);
-  if (!fs17.existsSync(filePath)) {
+  if (!fs19.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs17.readFileSync(filePath, "utf-8");
+    const content = fs19.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4832,11 +5234,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs17.existsSync(manifestPath)) {
+  if (!fs19.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs17.readFileSync(manifestPath, "utf-8");
+    const content = fs19.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4853,7 +5255,7 @@ function hasValidParamsSchema(paramsSchema) {
 }
 async function loadPlugin(pluginKey) {
   try {
-    const userRequire = createRequire2(path14.join(getProjectRoot2(), "package.json"));
+    const userRequire = createRequire2(path16.join(getProjectRoot2(), "package.json"));
     const resolvedPath = userRequire.resolve(pluginKey);
     const pluginModule = await import(resolvedPath);
     const pluginPackage = pluginModule.default ?? pluginModule;
@@ -5016,8 +5418,8 @@ var capabilityCommandGroup = {
 import { execFile } from "child_process";
 
 // src/commands/component/registry-preparer.ts
-import fs18 from "fs";
-import path15 from "path";
+import fs20 from "fs";
+import path17 from "path";
 import os from "os";
 
 // src/commands/component/service.ts
@@ -5077,7 +5479,7 @@ async function sendInstallEvent(key) {
 }
 
 // src/commands/component/registry-preparer.ts
-var REGISTRY_TEMP_DIR = path15.join(os.tmpdir(), "miaoda-registry");
+var REGISTRY_TEMP_DIR = path17.join(os.tmpdir(), "miaoda-registry");
 function parseComponentKey(key) {
   const match = key.match(/^@([^/]+)\/(.+)$/);
   if (!match) {
@@ -5089,11 +5491,11 @@ function parseComponentKey(key) {
 }
 function getLocalRegistryPath(key) {
   const { scope, name } = parseComponentKey(key);
-  return path15.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
+  return path17.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
 }
 function ensureDir(dirPath) {
-  if (!fs18.existsSync(dirPath)) {
-    fs18.mkdirSync(dirPath, { recursive: true });
+  if (!fs20.existsSync(dirPath)) {
+    fs20.mkdirSync(dirPath, { recursive: true });
   }
 }
 async function prepareRecursive(key, visited) {
@@ -5126,8 +5528,8 @@ async function prepareRecursive(key, visited) {
     registryDependencies: deps.map((dep) => getLocalRegistryPath(dep))
   };
   const localPath = getLocalRegistryPath(key);
-  ensureDir(path15.dirname(localPath));
-  fs18.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
+  ensureDir(path17.dirname(localPath));
+  fs20.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
   debug("\u4FDD\u5B58\u5230: %s", localPath);
 }
 async function prepareComponentRegistryItems(id) {
@@ -5137,18 +5539,18 @@ async function prepareComponentRegistryItems(id) {
 }
 function cleanupTempDir() {
   try {
-    if (fs18.existsSync(REGISTRY_TEMP_DIR)) {
-      fs18.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
+    if (fs20.existsSync(REGISTRY_TEMP_DIR)) {
+      fs20.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
     }
   } catch {
   }
 }
 function getDownloadedRegistryItem(itemId) {
   const localPath = getLocalRegistryPath(itemId);
-  if (!fs18.existsSync(localPath)) {
+  if (!fs20.existsSync(localPath)) {
     return null;
   }
-  const content = fs18.readFileSync(localPath, "utf-8");
+  const content = fs20.readFileSync(localPath, "utf-8");
   return JSON.parse(content);
 }
 
@@ -5316,58 +5718,58 @@ var componentCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path18 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path16.join(process.cwd(), PACKAGE_JSON);
+  return path18.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs19.existsSync(pkgPath)) {
+  if (!fs21.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs19.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs21.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs21 from "fs";
-import path18 from "path";
+import fs23 from "fs";
+import path20 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs20 from "fs";
-import path17 from "path";
+import fs22 from "fs";
+import path19 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path17.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path19.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path17.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path19.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path18.join(capabilitiesDir, "capabilities.json");
-  if (!fs21.existsSync(oldFilePath)) {
+  const oldFilePath = path20.join(capabilitiesDir, "capabilities.json");
+  if (!fs23.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs21.readFileSync(oldFilePath, "utf-8");
+    const content = fs23.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) {
       return {
@@ -5418,8 +5820,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs22 from "fs";
-import path19 from "path";
+import fs24 from "fs";
+import path21 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -5649,18 +6051,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs22.existsSync(capabilitiesDir)) {
+  if (!fs24.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs22.readdirSync(capabilitiesDir);
+  const files = fs24.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path19.join(capabilitiesDir, file);
-      const content = fs22.readFileSync(filePath, "utf-8");
+      const filePath = path21.join(capabilitiesDir, file);
+      const content = fs24.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -5718,9 +6120,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path19.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path21.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs22.writeFileSync(filePath, content, "utf-8");
+    fs24.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -5732,11 +6134,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs23 from "fs";
+import fs25 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs23.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs25.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -5812,12 +6214,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path21 from "path";
+import path23 from "path";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs24 from "fs";
-import path20 from "path";
+import fs26 from "fs";
+import path22 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -5832,9 +6234,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs24.readdirSync(dir, { withFileTypes: true });
+  const entries = fs26.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path20.join(dir, entry.name);
+    const fullPath = path22.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -5850,14 +6252,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path20.join(getProjectRoot3(), "server");
-  if (!fs24.existsSync(serverDir)) {
+  const serverDir = path22.join(getProjectRoot3(), "server");
+  if (!fs26.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs24.readFileSync(filePath, "utf-8");
+  const content = fs26.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -6234,7 +6636,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path21.relative(getProjectRoot3(), filePath);
+  const relativePath = path23.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -6245,7 +6647,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path21.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path23.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -6348,17 +6750,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs25 from "fs";
-import path22 from "path";
+import fs27 from "fs";
+import path24 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path22.join(capabilitiesDir, "capabilities.json");
-  if (fs25.existsSync(oldJsonPath)) {
+  const oldJsonPath = path24.join(capabilitiesDir, "capabilities.json");
+  if (fs27.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs25.unlinkSync(oldJsonPath);
+        fs27.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -6366,11 +6768,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path22.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs25.existsSync(tsFilePath)) {
+    const tsFilePath = path24.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs27.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs25.unlinkSync(tsFilePath);
+          fs27.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -6386,8 +6788,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs26 from "fs";
-import path23 from "path";
+import fs28 from "fs";
+import path25 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -6550,15 +6952,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs26.existsSync(logDir)) {
+  if (!fs28.existsSync(logDir)) {
     return;
   }
-  const reportDir = path23.join(logDir, "migration");
-  if (!fs26.existsSync(reportDir)) {
-    fs26.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path25.join(logDir, "migration");
+  if (!fs28.existsSync(reportDir)) {
+    fs28.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path23.join(reportDir, REPORT_FILE);
-  fs26.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path25.join(reportDir, REPORT_FILE);
+  fs28.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -7090,10 +7492,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path24 from "path";
+import path26 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs27 from "fs";
+import fs29 from "fs";
 function formatStdPrefixTime(localTime) {
   const match = localTime.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
   if (!match) return localTime;
@@ -7123,11 +7525,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs27.statSync(filePath);
+  const stat = fs29.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs27.openSync(filePath, "r");
+  const fd = fs29.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7141,7 +7543,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs27.readSync(fd, buffer, 0, length, position);
+      fs29.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7183,7 +7585,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs27.closeSync(fd);
+    fs29.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -7204,21 +7606,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs28 from "fs";
+import fs30 from "fs";
 function fileExists(filePath) {
   try {
-    fs28.accessSync(filePath, fs28.constants.F_OK | fs28.constants.R_OK);
+    fs30.accessSync(filePath, fs30.constants.F_OK | fs30.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs28.statSync(filePath);
+  const stat = fs30.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs28.openSync(filePath, "r");
+  const fd = fs30.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -7228,13 +7630,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs28.readSync(fd, buffer, 0, length, position);
+      fs30.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs28.closeSync(fd);
+    fs30.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -7250,11 +7652,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs28.statSync(filePath);
+  const stat = fs30.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs28.openSync(filePath, "r");
+  const fd = fs30.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7266,7 +7668,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs28.readSync(fd, buffer, 0, length, position);
+      fs30.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7297,7 +7699,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs28.closeSync(fd);
+    fs30.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7439,7 +7841,7 @@ function readDevStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs29 from "fs";
+import fs31 from "fs";
 
 // src/commands/read-logs/structured-log.ts
 function normalizeLevelName(value) {
@@ -7515,11 +7917,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs29.statSync(filePath);
+  const stat = fs31.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs29.openSync(filePath, "r");
+  const fd = fs31.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7534,7 +7936,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs29.readSync(fd, buffer, 0, length, position);
+      fs31.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7596,7 +7998,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs29.closeSync(fd);
+    fs31.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7639,11 +8041,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs29.statSync(filePath);
+  const stat = fs31.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs29.openSync(filePath, "r");
+  const fd = fs31.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7656,7 +8058,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs29.readSync(fd, buffer, 0, length, position);
+      fs31.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7709,7 +8111,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs29.closeSync(fd);
+    fs31.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7718,11 +8120,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs29.statSync(filePath);
+  const stat = fs31.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs29.openSync(filePath, "r");
+  const fd = fs31.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7734,7 +8136,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs29.readSync(fd, buffer, 0, length, position);
+      fs31.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7781,7 +8183,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs29.closeSync(fd);
+    fs31.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -8274,30 +8676,30 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path24.isAbsolute(logDir) ? logDir : path24.join(process.cwd(), logDir);
+  const base = path26.isAbsolute(logDir) ? logDir : path26.join(process.cwd(), logDir);
   if (type === "server") {
-    return path24.join(base, "server.log");
+    return path26.join(base, "server.log");
   }
   if (type === "trace") {
-    return path24.join(base, "trace.log");
+    return path26.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path24.join(base, "server.std.log");
+    return path26.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path24.join(base, "client.std.log");
+    return path26.join(base, "client.std.log");
   }
   if (type === "dev") {
-    return path24.join(base, "dev.log");
+    return path26.join(base, "dev.log");
   }
   if (type === "dev-std") {
-    return path24.join(base, "dev.std.log");
+    return path26.join(base, "dev.std.log");
   }
   if (type === "install-dep-std") {
-    return path24.join(base, "install-dep.std.log");
+    return path26.join(base, "install-dep.std.log");
   }
   if (type === "browser") {
-    return path24.join(base, "browser.log");
+    return path26.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
@@ -8467,9 +8869,9 @@ function camelToKebab(str) {
 }
 
 // src/commands/build/upload-static.handler.ts
-import * as fs30 from "fs";
+import * as fs32 from "fs";
 import * as os2 from "os";
-import * as path25 from "path";
+import * as path27 from "path";
 import { execFileSync } from "child_process";
 function readCredentialsFromEnv() {
   const uploadPrefix = process.env.STATIC_UPLOAD_PREFIX;
@@ -8493,8 +8895,8 @@ async function uploadStatic(options) {
       endpoint = UPLOAD_STATIC_DEFAULTS.endpoint,
       region = UPLOAD_STATIC_DEFAULTS.region
     } = options;
-    const resolvedStaticDir = path25.resolve(staticDir);
-    if (!fs30.existsSync(resolvedStaticDir)) {
+    const resolvedStaticDir = path27.resolve(staticDir);
+    if (!fs32.existsSync(resolvedStaticDir)) {
       console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E0D\u5B58\u5728: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
       return;
     }
@@ -8527,8 +8929,8 @@ async function uploadStatic(options) {
       ({ AccessKeyID: accessKeyID, SecretAccessKey: secretAccessKey, SessionToken: sessionToken } = uploadCredential);
     }
     console.error(`${LOG_PREFIX} \u4E0A\u4F20\u76EE\u6807: ${uploadPrefix}`);
-    const confPath = path25.join(os2.tmpdir(), `.tosutilconfig-static-${process.pid}`);
-    fs30.writeFileSync(confPath, "");
+    const confPath = path27.join(os2.tmpdir(), `.tosutilconfig-static-${process.pid}`);
+    fs32.writeFileSync(confPath, "");
     try {
       console.error(`${LOG_PREFIX} \u914D\u7F6E tosutil...`);
       configureTosutil(resolvedTosutil, confPath, {
@@ -8542,7 +8944,7 @@ async function uploadStatic(options) {
       uploadToTos(resolvedTosutil, confPath, resolvedStaticDir, uploadPrefix);
     } finally {
       try {
-        fs30.unlinkSync(confPath);
+        fs32.unlinkSync(confPath);
       } catch {
       }
     }
@@ -8562,8 +8964,8 @@ async function uploadStatic(options) {
   }
 }
 function resolveTosutilPath(tosutilPath) {
-  if (path25.isAbsolute(tosutilPath)) {
-    return fs30.existsSync(tosutilPath) ? tosutilPath : null;
+  if (path27.isAbsolute(tosutilPath)) {
+    return fs32.existsSync(tosutilPath) ? tosutilPath : null;
   }
   try {
     const resolved = execFileSync("which", [tosutilPath], { encoding: "utf-8" }).trim();
@@ -8608,7 +9010,7 @@ async function resolveBucketId(appId) {
   return bucketId;
 }
 function isDirEmpty(dirPath) {
-  const entries = fs30.readdirSync(dirPath);
+  const entries = fs32.readdirSync(dirPath);
   return entries.length === 0;
 }
 
@@ -8704,13 +9106,13 @@ var commands = [
 
 // src/index.ts
 for (const filename of [".env.local", ".env"]) {
-  const envPath = path26.join(process.cwd(), filename);
-  if (fs31.existsSync(envPath)) {
+  const envPath = path28.join(process.cwd(), filename);
+  if (fs33.existsSync(envPath)) {
     dotenvConfig({ path: envPath });
   }
 }
-var __dirname = path26.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs31.readFileSync(path26.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path28.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs33.readFileSync(path28.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();