akanjs 2.0.5 → 2.0.7

package/cli/index.js

@@ -174321,6 +174321,7 @@ var appRootAllowedDirs = new Set([
   "env",
   "ios",
   "lib",
+  "mobile",
   "page",
   "private",
   "public",
@@ -176299,6 +176300,8 @@ var builderMsgTypeSet = new Set([
 ]);
 
 class IncrementalBuilderHost {
+  static #restartBaseDelayMs = 1000;
+  static #restartMaxDelayMs = 30000;
   logger = new Logger("IncrementalBuilderHost");
   entry;
   env;
@@ -176306,48 +176309,112 @@ class IncrementalBuilderHost {
   ready = false;
   #onMessage;
   #proc = null;
+  #status = "stopped";
+  #restartAttempts = 0;
+  #restartTimer = null;
+  #manualStop = false;
+  #startOptions = {};
   constructor({ app, entry, env, onMessage }) {
     this.app = app;
     this.entry = entry;
     this.env = env;
     this.#onMessage = onMessage;
   }
-  start({ onExit, onReady }) {
+  get status() {
+    return this.#status;
+  }
+  start(options = {}) {
     if (this.#proc)
       this.stop();
-    this.#proc = Bun.spawn(["bun", this.entry], {
+    this.#manualStop = false;
+    this.#startOptions = options;
+    this.#spawn(false);
+    return this;
+  }
+  #spawn(isRestart) {
+    this.#status = isRestart ? "restarting" : "starting";
+    this.ready = false;
+    let proc;
+    proc = Bun.spawn(["bun", this.entry], {
       cwd: this.app.cwdPath,
       env: { ...this.env, AKAN_WATCH: "1" },
       stdio: ["ignore", "inherit", "inherit"],
       ipc: (msg) => {
+        if (this.#proc !== proc)
+          return;
         if (!msg || typeof msg !== "object")
           return;
         if (builderMsgTypeSet.has(msg.type))
           this.#onMessage(msg);
         if (msg.type === "builder-ready" && !this.ready) {
           this.ready = true;
-          onReady?.();
+          this.#status = "ready";
+          this.#restartAttempts = 0;
+          if (isRestart)
+            this.#startOptions.onRestartReady?.();
+          else
+            this.#startOptions.onReady?.();
         }
       },
       serialization: "advanced",
       onExit: () => {
-        onExit?.();
+        if (this.#proc !== proc)
+          return;
+        this.#proc = null;
+        const wasReady = this.ready;
+        this.ready = false;
+        if (this.#manualStop || this.#status === "stopped")
+          return;
+        if (!wasReady) {
+          this.#status = "stopped";
+          this.#startOptions.onExit?.();
+          return;
+        }
+        this.#scheduleRestart();
       }
     });
-    this.logger.verbose(`builder spawned pid=${this.#proc.pid} entry=${this.entry}`);
-    return this;
+    this.#proc = proc;
+    this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
+  }
+  #scheduleRestart() {
+    if (this.#manualStop || this.#restartTimer)
+      return;
+    this.#status = "restarting";
+    const attempt = this.#restartAttempts;
+    const delay = Math.min(IncrementalBuilderHost.#restartBaseDelayMs * 2 ** attempt, IncrementalBuilderHost.#restartMaxDelayMs);
+    this.#restartAttempts = attempt + 1;
+    this.logger.warn(`builder exited after ready; restarting in ${delay}ms (attempt ${this.#restartAttempts})`);
+    this.#restartTimer = setTimeout(() => {
+      this.#restartTimer = null;
+      if (this.#manualStop)
+        return;
+      this.#spawn(true);
+    }, delay);
   }
   send(message) {
-    if (this.#proc)
+    if (!this.#proc || this.#status !== "ready") {
+      this.logger.warn(`incrementalBuilderHost is ${this.#status}; cannot send ${message.type}`);
+      return false;
+    }
+    try {
       this.#proc.send(message);
-    else
-      this.logger.warn("incrementalBuilderHost is not running");
+      return true;
+    } catch (error) {
+      this.logger.warn(`failed to send ${message.type} to builder: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
   }
   stop() {
+    this.#manualStop = true;
+    if (this.#restartTimer) {
+      clearTimeout(this.#restartTimer);
+      this.#restartTimer = null;
+    }
     if (this.#proc)
       this.#proc.kill();
     this.#proc = null;
     this.ready = false;
+    this.#status = "stopped";
   }
   static async create(app, env, onMessage) {
     const candidates = [
@@ -176365,6 +176432,8 @@ class IncrementalBuilderHost {
 var backendMsgTypeSet = new Set(["build-route"]);
 var BACKEND_RESTART_DEBOUNCE_MS = 120;
 var BACKEND_GRACEFUL_TIMEOUT_MS = 3000;
+var BACKEND_RECOVERY_BASE_DELAY_MS = 1000;
+var BACKEND_RECOVERY_MAX_DELAY_MS = 30000;
 var BUILDER_READY_TIMEOUT_MS = 15000;
 var BUILDER_START_MAX_ATTEMPTS = 3;
 var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
@@ -176488,6 +176557,8 @@ class AkanAppHost {
   #backendReady = false;
   #plannedBackendStops = new WeakSet;
   #restartTimer = null;
+  #backendRecoveryTimer = null;
+  #backendRecoveryAttempts = 0;
   #restartFiles = new Set;
   #latestPagesUpdated = null;
   #latestCssUpdated = null;
@@ -176518,6 +176589,10 @@ class AkanAppHost {
       clearTimeout(this.#restartTimer);
       this.#restartTimer = null;
     }
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
     await this.#stopBackend();
     this.#stopBuilder();
     return this;
@@ -176542,6 +176617,7 @@ class AkanAppHost {
           return;
         if (msg.type === "backend-ready") {
           this.#backendReady = true;
+          this.#backendRecoveryAttempts = 0;
           this.logger.verbose(`backend ready pid=${msg.pid}`);
           this.#replayBuilderState();
           return;
@@ -176558,7 +176634,7 @@ class AkanAppHost {
           this.#plannedBackendStops.delete(backend);
           return;
         }
-        this.#stopBuilder();
+        this.#scheduleBackendRecovery("backend-exit");
       }
     });
     this.#backend = backend;
@@ -176606,6 +176682,10 @@ class AkanAppHost {
   #scheduleBackendRestart(files) {
     for (const file of files)
       this.#restartFiles.add(file);
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
     if (this.#restartTimer)
       clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
@@ -176617,9 +176697,27 @@ class AkanAppHost {
   }
   async#restartBackend(files) {
     this.logger.verbose(`[backend-reload] restarting backend for ${files.length} file(s)`);
+    this.#backendRecoveryAttempts = 0;
     await Promise.all([this.#stopBackend(), this.#backendGraph.refresh()]);
     this.#startBackend();
   }
+  #scheduleBackendRecovery(reason) {
+    if (this.#backendRecoveryTimer || this.#backend)
+      return;
+    const attempt = this.#backendRecoveryAttempts;
+    const delay = Math.min(BACKEND_RECOVERY_BASE_DELAY_MS * 2 ** attempt, BACKEND_RECOVERY_MAX_DELAY_MS);
+    this.#backendRecoveryAttempts = attempt + 1;
+    this.logger.warn(`[backend-recovery] backend exited unexpectedly (${reason}); restarting in ${delay}ms (attempt ${this.#backendRecoveryAttempts})`);
+    this.#backendRecoveryTimer = setTimeout(() => {
+      this.#backendRecoveryTimer = null;
+      if (this.#backend)
+        return;
+      this.#backendGraph.refresh().finally(() => {
+        if (!this.#backend)
+          this.#startBackend();
+      });
+    }, delay);
+  }
   #enqueueBuilderMessage(message) {
     this.#builderMessageQueue = this.#builderMessageQueue.then(() => this.#handleBuilderMessage(message)).catch((err) => {
       this.logger.warn(`failed to handle builder message: ${err instanceof Error ? err.message : String(err)}`);
@@ -176688,7 +176786,6 @@ class AkanAppHost {
       if (!this.#builder)
         throw new Error("Builder Not Found");
       let settled = false;
-      let ready = false;
       const settle = (fn) => {
         if (settled)
           return;
@@ -176701,24 +176798,31 @@ class AkanAppHost {
       }, BUILDER_READY_TIMEOUT_MS);
       this.#builder.start({
         onExit: () => {
-          if (settled && ready) {
-            this.#stopBackend();
-            return;
-          }
           settle(() => reject(new Error(`[cli] builder exited before emitting builder-ready (attempt ${attempt})`)));
         },
         onReady: () => {
-          ready = true;
           settle(resolve);
+        },
+        onRestartReady: () => {
+          this.logger.verbose("[builder-recovery] builder ready after restart; replaying latest state");
+          this.#replayBuilderState();
         }
       });
     });
   }
   #sendToBuilder(message) {
-    if (this.#builder)
-      this.#builder.send(message);
-    else
-      this.logger.warn("akanAppHost is not running");
+    if (this.#builder?.send(message))
+      return;
+    if (message.type === "build-route") {
+      this.#sendToBackend({
+        type: "build-route-res",
+        id: message.id,
+        ok: false,
+        error: `builder is ${this.#builder?.status ?? "stopped"}; reload after the builder is ready`
+      });
+      return;
+    }
+    this.logger.warn("akanAppHost builder is not running");
   }
   #stopBuilder() {
     if (!this.#builder)
@@ -180678,9 +180782,10 @@ var resolveMobileTargetByBasePath = (targets, basePath2) => {
   if (!template)
     return;
   return {
-    name: template.name,
+    name: normalizedBasePath,
     config: {
       ...template.config,
+      name: normalizedBasePath,
       basePath: normalizedBasePath
     }
   };
@@ -180734,32 +180839,46 @@ class CapacitorApp {
   project;
   iosTargetName = "App";
   targetRoot;
+  targetRootPath;
+  targetWebRoot;
+  targetAssetRoot;
+  iosRootPath = "ios";
+  iosProjectPath = "ios/App";
+  androidRootPath = "android";
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRoot = path34.join(this.app.cwdPath, "mobile", this.target.name);
-    this.project = new MobileProject(this.targetRoot, {
-      android: { path: "android" },
-      ios: { path: "ios/App" }
+    this.targetRootPath = path34.posix.join("mobile", this.target.name);
+    this.targetRoot = path34.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path34.join(this.targetRoot, "www");
+    this.targetAssetRoot = path34.join(this.targetRoot, "assets");
+    this.project = new MobileProject(this.app.cwdPath, {
+      android: { path: this.androidRootPath },
+      ios: { path: this.iosProjectPath }
     });
   }
-  async init({ platform, regenerate = false } = {}) {
+  async init({
+    platform,
+    operation = "release",
+    env = "debug",
+    regenerate = false
+  } = {}) {
     await mkdir10(this.targetRoot, { recursive: true });
     await this.#writeCapacitorConfig();
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm4(path34.join(this.targetRoot, "ios"), { recursive: true, force: true });
+        await rm4(path34.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm4(path34.join(this.targetRoot, "android"), { recursive: true, force: true });
+        await rm4(path34.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
     if ((!platform || platform === "android") && !project.android) {
-      await this.#spawn("npx", ["cap", "add", "android"]);
+      await this.#spawnMobile("npx", ["cap", "add", "android"], { operation, env });
       await this.project.load();
     }
     if ((!platform || platform === "ios") && !project.ios) {
-      await this.#spawn("npx", ["cap", "add", "ios"]);
+      await this.#spawnMobile("npx", ["cap", "add", "ios"], { operation, env });
       await this.project.load();
     }
     return this;
@@ -180767,57 +180886,52 @@ class CapacitorApp {
   async save() {
     await this.project.commit();
   }
-  async#prepareIos({ regenerate = false } = {}) {
-    await this.init({ platform: "ios", regenerate });
+  async#prepareIos({ operation, env, regenerate = false }) {
+    await this.init({ platform: "ios", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("ios");
     await this.#applyIosMetadata();
     await this.#applyPermissions();
     await this.#applyLinks();
     await this.project.commit();
-    await this.#generateAssets();
+    await this.#generateAssets({ operation, env });
     this.app.verbose(`syncing iOS`);
-    await this.#spawn("npx", ["cap", "sync", "ios"]);
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env });
     this.app.verbose(`sync completed.`);
   }
-  async buildIos(options = {}) {
+  async buildIos({ env = "debug", regenerate = false } = {}) {
     await this.prepareWww();
-    await this.#prepareIos(options);
-    await this.#spawn("npx", ["cap", "build", "ios"], { stdio: "inherit" });
+    await this.#prepareIos({ operation: "release", env, regenerate });
+    await this.#spawnMobile("npx", ["cap", "build", "ios"], { operation: "release", env }, { stdio: "inherit" });
     this.app.verbose(`build completed iOS.`);
     return;
   }
   async syncIos() {
-    await this.#spawn("npx", ["cap", "sync", "ios"]);
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation: "local", env: "local" });
   }
   async openIos() {
-    await this.#spawn("npx", ["cap", "open", "ios"]);
+    await this.#spawnMobile("npx", ["cap", "open", "ios"], { operation: "local", env: "local" });
   }
   async runIos({ operation, env, regenerate = false }) {
     if (operation === "release")
       await this.prepareWww();
-    await this.#prepareIos({ regenerate });
+    await this.#prepareIos({ operation, env, regenerate });
     const args = ["cap", "run", "ios"];
-    if (operation !== "release")
-      args.push("--live-reload");
-    await this.#spawn("npx", args, {
-      env: this.#commandEnv(operation, env),
-      stdio: "inherit"
-    });
+    await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
-  async#prepareAndroid({ regenerate = false } = {}) {
-    await this.init({ platform: "android", regenerate });
+  async#prepareAndroid({ operation, env, regenerate = false }) {
+    await this.init({ platform: "android", operation, env, regenerate });
     await this.#prepareTargetAssets();
     await this.#prepareExternalFiles("android");
     await this.#applyAndroidMetadata();
     await this.#applyPermissions();
     await this.#applyLinks();
     await this.project.commit();
-    await this.#generateAssets();
-    await this.#spawn("npx", ["cap", "sync", "android"]);
+    await this.#generateAssets({ operation, env });
+    await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(`${this.targetRoot}/android/app/build.gradle`);
+    const appGradle = await FileEditor.create(path34.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -180852,54 +180966,49 @@ class CapacitorApp {
     }
     await appGradle.save();
   }
-  async buildAndroid(assembleType, options = {}) {
+  async buildAndroid(assembleType, { env = "debug", regenerate = false } = {}) {
     await this.prepareWww();
-    await this.#prepareAndroid(options);
+    await this.#prepareAndroid({ operation: "release", env, regenerate });
     await this.#updateAndroidBuildTypes();
     const isWindows = process.platform === "win32";
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: `${this.targetRoot}/android`
+      cwd: path34.join(this.app.cwdPath, this.androidRootPath),
+      env: this.#commandEnv("release", env)
     });
   }
   async openAndroid() {
-    await this.#spawn("npx", ["cap", "open", "android"]);
+    await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async syncAndroid(options = {}) {
     await this.prepareWww();
-    await this.#prepareAndroid(options);
+    await this.#prepareAndroid({ operation: "release", env: "debug", ...options });
     this.app.log(`Sync Android Completed.`);
   }
   async runAndroid({ operation, env, regenerate = false }) {
     if (operation === "release")
       await this.prepareWww();
-    await this.#prepareAndroid({ regenerate });
+    await this.#prepareAndroid({ operation, env, regenerate });
     this.app.logger.info(`Running Android in ${operation} mode on ${env} env`);
     const args = ["cap", "run", "android"];
-    if (operation !== "release")
-      args.push("--live-reload");
-    await this.#spawn("npx", args, {
-      env: this.#commandEnv(operation, env),
-      stdio: "inherit"
-    });
+    await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
   async releaseIos() {
     await this.prepareWww();
-    await this.#prepareIos();
+    await this.#prepareIos({ operation: "release", env: "main" });
   }
   async releaseAndroid() {
     await this.prepareWww();
-    await this.#prepareAndroid();
+    await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
     const htmlSource = path34.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
-    const wwwDir = path34.join(this.targetRoot, "www");
-    await rm4(wwwDir, { recursive: true, force: true });
-    await mkdir10(wwwDir, { recursive: true });
-    await Bun.write(path34.join(wwwDir, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await rm4(this.targetWebRoot, { recursive: true, force: true });
+    await mkdir10(this.targetWebRoot, { recursive: true });
+    await Bun.write(path34.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -180911,24 +181020,40 @@ class CapacitorApp {
   }
   async#writeCapacitorConfig() {
     await mkdir10(this.targetRoot, { recursive: true });
-    const appInfoPath = path34.relative(this.targetRoot, path34.join(this.app.cwdPath, "akan.app.json")).split(path34.sep).join("/");
-    const baseConfigPath = path34.relative(this.targetRoot, path34.join(this.app.workspace.cwdPath, "pkgs/akanjs/devkit/capacitor.base.config")).split(path34.sep).join("/");
-    const content = `import { withBase } from "${baseConfigPath.startsWith(".") ? baseConfigPath : `./${baseConfigPath}`}";
-import appInfo from "${appInfoPath}";
+    const appInfoPath = path34.relative(this.app.cwdPath, path34.join(this.app.cwdPath, "akan.app.json")).split(path34.sep).join("/");
+    const baseConfigPath = path34.relative(this.app.cwdPath, path34.join(this.app.workspace.cwdPath, "pkgs/akanjs/devkit/capacitor.base.config")).split(path34.sep).join("/");
+    const content = `import type { AppScanResult } from "akanjs/devkit";
+import { withBase } from "${baseConfigPath.startsWith(".") ? baseConfigPath : `./${baseConfigPath}`}";
+import appInfo from "${appInfoPath.startsWith(".") ? appInfoPath : `./${appInfoPath}`}";
 
-export default withBase((config) => config, appInfo, "${this.target.name}");
+export default withBase(
+  (config, target) => ({
+    ...config,
+    webDir: \`mobile/\${target.name}/www\`,
+    android: {
+      ...config.android,
+      path: "android",
+    },
+    ios: {
+      ...config.ios,
+      path: "ios",
+    },
+  }),
+  appInfo as AppScanResult,
+);
 `;
-    await Bun.write(path34.join(this.targetRoot, "capacitor.config.ts"), content);
+    await Bun.write(path34.join(this.app.cwdPath, "capacitor.config.ts"), content);
   }
   async#prepareTargetAssets() {
     if (!this.target.assets)
       return;
-    const assetsDir = path34.join(this.targetRoot, "assets");
-    await mkdir10(assetsDir, { recursive: true });
+    await mkdir10(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path34.join(this.app.cwdPath, this.target.assets.icon), path34.join(assetsDir, "icon.png"), { force: true });
+      await cp2(path34.join(this.app.cwdPath, this.target.assets.icon), path34.join(this.targetAssetRoot, "icon.png"), {
+        force: true
+      });
     if (this.target.assets.splash)
-      await cp2(path34.join(this.app.cwdPath, this.target.assets.splash), path34.join(assetsDir, "splash.png"), {
+      await cp2(path34.join(this.app.cwdPath, this.target.assets.splash), path34.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -180936,16 +181061,26 @@ export default withBase((config) => config, appInfo, "${this.target.name}");
     const files = this.target.files?.[platform];
     if (!files)
       return;
+    const platformRoot = path34.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path34.join(this.targetRoot, platform, to);
+      const targetPath = path34.join(platformRoot, to);
       await mkdir10(path34.dirname(targetPath), { recursive: true });
       await cp2(path34.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
-  async#generateAssets() {
+  async#generateAssets({ operation, env }) {
     if (!this.target.assets)
       return;
-    await this.#spawn("npx", ["@capacitor/assets", "generate"]);
+    await this.#spawnMobile("npx", [
+      "@capacitor/assets",
+      "generate",
+      "--assetPath",
+      path34.posix.join(this.targetRootPath, "assets"),
+      "--iosProject",
+      this.iosProjectPath,
+      "--androidProject",
+      this.androidRootPath
+    ], { operation, env });
   }
   async#applyIosMetadata() {
     this.project.ios.setBundleId("App", "Debug", this.target.appId);
@@ -180995,16 +181130,21 @@ export default withBase((config) => config, appInfo, "${this.target.name}");
     }
   }
   #commandEnv(operation, env) {
-    return {
-      ...process.env,
+    return this.app.getCommandEnv({
       APP_OPERATION_MODE: operation,
-      AKAN_PUBLIC_OPERATION_MODE: operation,
+      AKAN_PUBLIC_OPERATION_MODE: env === "local" ? "local" : "cloud",
       AKAN_PUBLIC_ENV: env,
       AKAN_MOBILE_TARGET: this.target.name
-    };
+    });
   }
   async#spawn(command, args = [], options = {}) {
-    return await this.app.spawn(command, args, { cwd: this.targetRoot, ...options });
+    return await this.app.spawn(command, args, { cwd: this.app.cwdPath, ...options });
+  }
+  async#spawnMobile(command, args = [], { operation, env }, options = {}) {
+    return await this.#spawn(command, args, {
+      ...options,
+      env: { ...this.#commandEnv(operation, env), ...options.env }
+    });
   }
   async addCamera() {
     await this.#setPermissionInIos({
@@ -182080,7 +182220,20 @@ var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
 
 import { select as select6 } from "@inquirer/prompts";
 
-import { compareVersions } from "compare-versions";
+function parseVersion(version) {
+  return version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
+}
+function compareSemver(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0;i < length; i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0)
+      return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
 
 class LibraryRunner extends runner("library") {
   async createLibrary(libName, workspace) {
@@ -182124,7 +182277,7 @@ class LibraryRunner extends runner("library") {
     const allDependencies = Object.fromEntries(Object.keys({ ...libDependencies, ...rootDependencies }).map((dep) => {
       const libVersion = libDependencies[dep] ?? "0.0.0";
       const rootVersion = rootDependencies[dep] ?? "0.0.0";
-      const newerVersion = compareVersions(rootVersion, libVersion) > 0 ? rootVersion : libVersion;
+      const newerVersion = compareSemver(rootVersion, libVersion) > 0 ? rootVersion : libVersion;
       return [dep, newerVersion];
     }));
     Object.keys(allDependencies).sort().forEach((dep) => {
@@ -182180,9 +182333,17 @@ import { StringOutputParser } from "@langchain/core/output_parsers";
 import { PromptTemplate as PromptTemplate2 } from "@langchain/core/prompts";
 import { RunnableSequence as RunnableSequence2 } from "@langchain/core/runnables";
 import { ChatOpenAI as ChatOpenAI3 } from "@langchain/openai";
-import openBrowser from "open";
 import ora3 from "ora";
 
+import { spawn as spawn2 } from "child_process";
+function openBrowser(url) {
+  const command3 = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  const child = spawn2(command3[0], command3.slice(1), { detached: true, stdio: "ignore" });
+  child.on("error", () => {});
+  child.unref();
+  return Promise.resolve();
+}
+
 class ApplicationRunner extends runner("application") {
   async createApplication(appName, workspace, libs = []) {
     await workspace.applyTemplate({
@@ -182261,7 +182422,7 @@ class ApplicationRunner extends runner("application") {
     const targets = await resolveMobileTargets(app, target);
     await this.#buildMobileCsr(app, env);
     await this.#runMobileTargets(targets, async (mobileTarget2) => {
-      await new CapacitorApp(app, mobileTarget2.config).buildIos({ regenerate });
+      await new CapacitorApp(app, mobileTarget2.config).buildIos({ env, regenerate });
     });
   }
   async startIos(app, {
@@ -182287,14 +182448,14 @@ class ApplicationRunner extends runner("application") {
     const targets = await resolveMobileTargets(app, target);
     await this.#buildMobileCsr(app, env);
     for (const mobileTarget2 of targets) {
-      await new CapacitorApp(app, mobileTarget2.config).buildIos({ regenerate });
+      await new CapacitorApp(app, mobileTarget2.config).buildIos({ env, regenerate });
     }
   }
   async buildAndroid(app, { target, env = "debug", regenerate = false } = {}) {
     const targets = await resolveMobileTargets(app, target);
     await this.#buildMobileCsr(app, env);
     await this.#runMobileTargets(targets, async (mobileTarget2) => {
-      await new CapacitorApp(app, mobileTarget2.config).buildAndroid("apk", { regenerate });
+      await new CapacitorApp(app, mobileTarget2.config).buildAndroid("apk", { env, regenerate });
     });
   }
   async startAndroid(app, {
@@ -182320,9 +182481,9 @@ class ApplicationRunner extends runner("application") {
     const targets = await resolveMobileTargets(app, target);
     await this.#buildMobileCsr(app, env);
     for (const mobileTarget2 of targets) {
-      await new CapacitorApp(app, mobileTarget2.config).buildAndroid(assembleType, { regenerate });
+      await new CapacitorApp(app, mobileTarget2.config).buildAndroid(assembleType, { env, regenerate });
       app.log(`Release Android ${app.name}/${mobileTarget2.name} ${assembleType} Completed.`);
-      app.log(`Path : ${app.cwdPath}/mobile/${mobileTarget2.name}/android/app/build/outputs/${assembleType === "apk" ? "apk" : "bundle"}/release`);
+      app.log(`Path : ${app.cwdPath}/android/app/build/outputs/${assembleType === "apk" ? "apk" : "bundle"}/release`);
     }
   }
   async#buildMobileCsr(app, env) {
@@ -182692,7 +182853,10 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   start: target({ short: true, desc: "Start development server (frontend SSR + backend)" }).with(App).option("open", Boolean, { desc: "open web browser?", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, open, write) {
     await this.applicationScript.start(app, { open, write });
   }),
-  startIos: target({ short: true, desc: "Start iOS app in simulator or device" }).with(App).option("target", String, { desc: "mobile target name or all" }).option("env", String, {
+  startIos: target({ short: true, desc: "Start iOS app in simulator or device" }).with(App).option("target", String, {
+    ask: "Select mobile target",
+    enum: async ({ app }) => await getMobileTargetChoices(app)
+  }).option("env", String, {
     enum: ["local", "debug", "develop", "main"],
     desc: "backend environment",
     default: "local"
@@ -182877,10 +183041,19 @@ class PackageScript extends script("package", [PackageRunner]) {
 
 import { confirm as confirm3 } from "@inquirer/prompts";
 import chalk7 from "chalk";
-import latestVersion from "latest-version";
-import open from "open";
 import * as QRcode from "qrcode";
-import { v4 as uuidv4 } from "uuid";
+
+async function getLatestPackageVersion(packageName, tag = "latest") {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName).replace(/^%40/, "@")}`;
+  const res = await fetch(url);
+  if (!res.ok)
+    throw new Error(`Failed to fetch ${packageName} metadata from npm registry`);
+  const metadata = await res.json();
+  const version = metadata["dist-tags"]?.[tag];
+  if (!version)
+    throw new Error(`No npm dist-tag "${tag}" found for ${packageName}`);
+  return version;
+}
 
 class CloudRunner extends runner("cloud") {
   async login() {
@@ -182892,7 +183065,7 @@ class CloudRunner extends runner("cloud") {
 `));
       return true;
     }
-    const remoteId = uuidv4();
+    const remoteId = crypto.randomUUID();
     const signinUrl = `${akanCloudUrl}/signin?remoteId=${remoteId}`;
     Logger.rawLog(chalk7.bold(`
 ${chalk7.green("\u27A4")} Authentication Required`));
@@ -182908,7 +183081,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
         });
       });
       Logger.rawLog(qrcode);
-      await open(signinUrl);
+      await openBrowser(signinUrl);
       Logger.rawLog(chalk7.dim("Opening browser..."));
     } catch {
       Logger.rawLog(chalk7.yellow("Could not open browser. Please visit the URL manually."));
@@ -182969,11 +183142,11 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     const tag = isOfficialRelease ? "latest" : patchVersion.split("-").at(1) ?? "dev";
     const getNextVersion = async (prefix, tag2) => {
       try {
-        const latestPublishedVersion2 = await latestVersion("akanjs", { version: tag2 });
+        const latestPublishedVersion2 = await getLatestPackageVersion("akanjs", tag2);
         const latestPatch = latestPublishedVersion2.startsWith(prefix) ? parseInt(latestPublishedVersion2.split(".").at(-1) ?? "-1") : -1;
         const nextVersion2 = `${prefix}.${latestPatch + 1}`;
         return { nextVersion: nextVersion2, latestPublishedVersion: latestPublishedVersion2 };
-      } catch (e) {
+      } catch {
         return { nextVersion: `${prefix}.0`, latestPublishedVersion: null };
       }
     };
@@ -183012,7 +183185,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
       ]);
   }
   async#updateAkanPkgs(workspace, tag = "latest") {
-    const latestPublishedVersion = await latestVersion("akanjs", { version: tag });
+    const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag);
     const rootPackageJson = await workspace.getPackageJson();
     if (!rootPackageJson.dependencies)
       throw new Error("No dependencies found in package.json");
@@ -183685,7 +183858,13 @@ var requestUnit = ({
 
 	`;
 
-import pluralize from "pluralize";
+function pluralizeName(name) {
+  if (/[^aeiou]y$/i.test(name))
+    return `${name.slice(0, -1)}ies`;
+  if (/(s|x|z|ch|sh)$/i.test(name))
+    return `${name}es`;
+  return `${name}s`;
+}
 
 class ModuleRunner extends runner("module") {
   async createModule(workspace, sysType, sysName, moduleName, description) {}
@@ -183706,7 +183885,7 @@ class ModuleRunner extends runner("module") {
     };
   }
   async createModuleTemplate(module) {
-    const names = pluralize(module.name);
+    const names = pluralizeName(module.name);
     await module.applyTemplate({
       basePath: `.`,
       template: "module",
@@ -183916,11 +184095,7 @@ class PageCommand extends command("page", [PageScript], ({ public: target }) =>
 })) {
 }
 
-import pluralize3 from "pluralize";
-
 import { input as input5 } from "@inquirer/prompts";
-import pluralize2 from "pluralize";
-
 class ScalarPrompt extends Prompter {
   sys;
   name;
@@ -183940,7 +184115,7 @@ class ScalarPrompt extends Prompter {
     await this.sys.applyTemplate({
       basePath: "./lib/__scalar",
       template: "__scalar",
-      dict: { model: this.name, models: pluralize2(this.name), sysName: this.sys.name }
+      dict: { model: this.name, models: pluralizeName(this.name), sysName: this.sys.name }
     });
     const boilerplate = await this.sys.readFile(`lib/__scalar/${this.name}/${this.name}.constant.ts`);
     return await this.#requestConstant({
@@ -184044,7 +184219,7 @@ class ScalarRunner extends runner("scalar") {
     await sys3.applyTemplate({
       basePath: "./lib/__scalar",
       template: "__scalar",
-      dict: { model: scalarName, models: pluralize3(scalarName), sysName: sys3.name },
+      dict: { model: scalarName, models: pluralizeName(scalarName), sysName: sys3.name },
       overwrite: false
     });
   }
@@ -184100,15 +184275,13 @@ class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target
 import path38 from "path";
 
 import path37 from "path";
-import latestVersion2 from "latest-version";
-
 class WorkspaceRunner extends runner("workspace") {
   async createWorkspace(repoName, appName, { dirname: dirname3 = ".", init = true, akanVersion }) {
     const cwdPath = process.cwd();
     const workspaceRoot = path37.join(cwdPath, dirname3, repoName);
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname3}/${repoName}...`);
-    const latestTypesBunVersion = await latestVersion2("@types/bun");
+    const latestTypesBunVersion = await getLatestPackageVersion("@types/bun");
     await workspace.applyTemplate({
       basePath: ".",
       template: "workspaceRoot",