npm - @tamer4lynx/cli - Versions diffs - 0.0.16 → 0.0.18 - Mend

@tamer4lynx/cli 0.0.16 → 0.0.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +963 -765
package/package.json +2 -1

package/dist/index.js CHANGED Viewed

@@ -7,41 +7,64 @@ process.on("warning", (w) => {
 });
 // index.ts
-import fs29 from "fs";
-import path30 from "path";
-import { fileURLToPath } from "url";
+import fs30 from "fs";
+import path31 from "path";
 import { program } from "commander";
+// src/common/cliVersion.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function getCliVersion() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@tamer4lynx/cli" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    const next = path.dirname(dir);
+    if (next === dir) break;
+    dir = next;
+  }
+  return "0.0.0";
+}
 // src/android/create.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import os2 from "os";
 // src/android/getGradle.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import os from "os";
 import { execSync } from "child_process";
 import fetch2 from "node-fetch";
 import AdmZip from "adm-zip";
 async function downloadGradle(gradleVersion) {
   const gradleBaseUrl = `https://services.gradle.org/distributions/gradle-${gradleVersion}-bin.zip`;
-  const downloadDir = path.join(process.cwd(), "gradle");
-  const zipPath = path.join(downloadDir, `gradle-${gradleVersion}.zip`);
-  const extractedPath = path.join(downloadDir, `gradle-${gradleVersion}`);
-  if (fs.existsSync(extractedPath)) {
+  const downloadDir = path2.join(process.cwd(), "gradle");
+  const zipPath = path2.join(downloadDir, `gradle-${gradleVersion}.zip`);
+  const extractedPath = path2.join(downloadDir, `gradle-${gradleVersion}`);
+  if (fs2.existsSync(extractedPath)) {
     console.log(`\u2705 Gradle ${gradleVersion} already exists at ${extractedPath}. Skipping download.`);
     return;
   }
-  if (!fs.existsSync(downloadDir)) {
-    fs.mkdirSync(downloadDir, { recursive: true });
+  if (!fs2.existsSync(downloadDir)) {
+    fs2.mkdirSync(downloadDir, { recursive: true });
   }
   console.log(`\u{1F4E5} Downloading Gradle ${gradleVersion} from ${gradleBaseUrl}...`);
   const response = await fetch2(gradleBaseUrl);
   if (!response.ok || !response.body) {
     throw new Error(`Failed to download: ${response.statusText}`);
   }
-  const fileStream = fs.createWriteStream(zipPath);
+  const fileStream = fs2.createWriteStream(zipPath);
   await new Promise((resolve, reject) => {
     response.body?.pipe(fileStream);
     response.body?.on("error", reject);
@@ -55,26 +78,26 @@ async function downloadGradle(gradleVersion) {
     console.error(`\u274C Failed to extract Gradle zip: ${err}`);
     throw err;
   }
-  fs.unlinkSync(zipPath);
+  fs2.unlinkSync(zipPath);
   console.log(`\u2705 Gradle ${gradleVersion} extracted to ${extractedPath}`);
 }
 async function setupGradleWrapper(rootDir, gradleVersion) {
   try {
     console.log("\u{1F4E6} Setting up Gradle wrapper...");
     await downloadGradle(gradleVersion);
-    const gradleBinDir = path.join(
+    const gradleBinDir = path2.join(
       process.cwd(),
       "gradle",
       `gradle-${gradleVersion}`,
       "bin"
     );
     const gradleExecutable = os.platform() === "win32" ? "gradle.bat" : "gradle";
-    const gradleExecutablePath = path.join(gradleBinDir, gradleExecutable);
-    if (!fs.existsSync(gradleExecutablePath)) {
+    const gradleExecutablePath = path2.join(gradleBinDir, gradleExecutable);
+    if (!fs2.existsSync(gradleExecutablePath)) {
       throw new Error(`Gradle executable not found at ${gradleExecutablePath}`);
     }
     if (os.platform() !== "win32") {
-      fs.chmodSync(gradleExecutablePath, "755");
+      fs2.chmodSync(gradleExecutablePath, "755");
     }
     console.log(`\u{1F680} Executing Gradle wrapper in: ${rootDir}`);
     execSync(`"${gradleExecutablePath}" wrapper`, {
@@ -89,8 +112,8 @@ async function setupGradleWrapper(rootDir, gradleVersion) {
 }
 // src/common/hostConfig.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var DEFAULT_ABI_FILTERS = ["armeabi-v7a", "arm64-v8a"];
 var TAMER_CONFIG = "tamer.config.json";
 var LYNX_CONFIG_FILES = ["lynx.config.ts", "lynx.config.js", "lynx.config.mjs"];
@@ -99,27 +122,27 @@ var DEFAULT_IOS_DIR = "ios";
 var DEFAULT_BUNDLE_FILE = "main.lynx.bundle";
 var DEFAULT_BUNDLE_ROOT = "dist";
 function findProjectRoot(start2) {
-  let dir = path2.resolve(start2);
-  const root = path2.parse(dir).root;
+  let dir = path3.resolve(start2);
+  const root = path3.parse(dir).root;
   while (dir !== root) {
-    const p = path2.join(dir, TAMER_CONFIG);
-    if (fs2.existsSync(p)) return dir;
-    dir = path2.dirname(dir);
+    const p = path3.join(dir, TAMER_CONFIG);
+    if (fs3.existsSync(p)) return dir;
+    dir = path3.dirname(dir);
   }
   return start2;
 }
 function loadTamerConfig(cwd) {
-  const p = path2.join(cwd, TAMER_CONFIG);
-  if (!fs2.existsSync(p)) return null;
+  const p = path3.join(cwd, TAMER_CONFIG);
+  if (!fs3.existsSync(p)) return null;
   try {
-    return JSON.parse(fs2.readFileSync(p, "utf8"));
+    return JSON.parse(fs3.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
 }
 function extractDistPathRoot(configPath) {
   try {
-    const content = fs2.readFileSync(configPath, "utf8");
+    const content = fs3.readFileSync(configPath, "utf8");
     const rootMatch = content.match(/distPath\s*:\s*\{\s*root\s*:\s*['"]([^'"]+)['"]/);
     if (rootMatch?.[1]) return rootMatch[1];
     const rootMatch2 = content.match(/root\s*:\s*['"]([^'"]+)['"]/);
@@ -130,16 +153,16 @@ function extractDistPathRoot(configPath) {
 }
 function findLynxConfigInDir(dir) {
   for (const name of LYNX_CONFIG_FILES) {
-    const p = path2.join(dir, name);
-    if (fs2.existsSync(p)) return p;
+    const p = path3.join(dir, name);
+    if (fs3.existsSync(p)) return p;
   }
   return null;
 }
 function hasRspeedy(pkgDir) {
-  const pkgJsonPath = path2.join(pkgDir, "package.json");
-  if (!fs2.existsSync(pkgJsonPath)) return false;
+  const pkgJsonPath = path3.join(pkgDir, "package.json");
+  if (!fs3.existsSync(pkgJsonPath)) return false;
   try {
-    const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf8"));
+    const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     return Object.keys(deps).some((k) => k === "@lynx-js/rspeedy");
   } catch {
@@ -148,17 +171,17 @@ function hasRspeedy(pkgDir) {
 }
 function discoverLynxProject(cwd, explicitPath) {
   if (explicitPath) {
-    const resolved = path2.isAbsolute(explicitPath) ? explicitPath : path2.join(cwd, explicitPath);
-    if (fs2.existsSync(resolved)) {
+    const resolved = path3.isAbsolute(explicitPath) ? explicitPath : path3.join(cwd, explicitPath);
+    if (fs3.existsSync(resolved)) {
       const lynxConfig2 = findLynxConfigInDir(resolved);
       const bundleRoot = lynxConfig2 ? extractDistPathRoot(lynxConfig2) ?? DEFAULT_BUNDLE_ROOT : DEFAULT_BUNDLE_ROOT;
       return { dir: resolved, bundleRoot };
     }
   }
-  const rootPkgPath = path2.join(cwd, "package.json");
-  if (fs2.existsSync(rootPkgPath)) {
+  const rootPkgPath = path3.join(cwd, "package.json");
+  if (fs3.existsSync(rootPkgPath)) {
     try {
-      const rootPkg = JSON.parse(fs2.readFileSync(rootPkgPath, "utf8"));
+      const rootPkg = JSON.parse(fs3.readFileSync(rootPkgPath, "utf8"));
       const lynxConfig2 = findLynxConfigInDir(cwd);
       if (lynxConfig2 || (rootPkg.dependencies?.["@lynx-js/rspeedy"] || rootPkg.devDependencies?.["@lynx-js/rspeedy"])) {
         const bundleRoot = lynxConfig2 ? extractDistPathRoot(lynxConfig2) ?? DEFAULT_BUNDLE_ROOT : DEFAULT_BUNDLE_ROOT;
@@ -169,12 +192,12 @@ function discoverLynxProject(cwd, explicitPath) {
         for (const ws of workspaces) {
           const isGlob = typeof ws === "string" && ws.includes("*");
           const dirsToCheck = isGlob ? (() => {
-            const parentDir = path2.join(cwd, ws.replace(/\/\*$/, ""));
-            if (!fs2.existsSync(parentDir)) return [];
-            return fs2.readdirSync(parentDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path2.join(parentDir, e.name));
-          })() : [path2.join(cwd, ws)];
+            const parentDir = path3.join(cwd, ws.replace(/\/\*$/, ""));
+            if (!fs3.existsSync(parentDir)) return [];
+            return fs3.readdirSync(parentDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path3.join(parentDir, e.name));
+          })() : [path3.join(cwd, ws)];
           for (const pkgDir of dirsToCheck) {
-            if (!fs2.existsSync(pkgDir)) continue;
+            if (!fs3.existsSync(pkgDir)) continue;
             const lynxConfig3 = findLynxConfigInDir(pkgDir);
             if (lynxConfig3 || hasRspeedy(pkgDir)) {
               const bundleRoot = lynxConfig3 ? extractDistPathRoot(lynxConfig3) ?? DEFAULT_BUNDLE_ROOT : DEFAULT_BUNDLE_ROOT;
@@ -194,30 +217,30 @@ function discoverLynxProject(cwd, explicitPath) {
   return null;
 }
 function findRepoRoot(start2) {
-  let dir = path2.resolve(start2);
-  const root = path2.parse(dir).root;
+  let dir = path3.resolve(start2);
+  const root = path3.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path2.join(dir, "package.json");
-    if (fs2.existsSync(pkgPath)) {
+    const pkgPath = path3.join(dir, "package.json");
+    if (fs3.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
         if (pkg.workspaces) return dir;
       } catch {
       }
     }
-    dir = path2.dirname(dir);
+    dir = path3.dirname(dir);
   }
   return start2;
 }
 function findDevAppPackage(projectRoot) {
   const candidates = [
-    path2.join(projectRoot, "node_modules", "@tamer4lynx", "tamer-dev-app"),
-    path2.join(projectRoot, "node_modules", "tamer-dev-app"),
-    path2.join(projectRoot, "packages", "tamer-dev-app"),
-    path2.join(path2.dirname(projectRoot), "tamer-dev-app")
+    path3.join(projectRoot, "node_modules", "@tamer4lynx", "tamer-dev-app"),
+    path3.join(projectRoot, "node_modules", "tamer-dev-app"),
+    path3.join(projectRoot, "packages", "tamer-dev-app"),
+    path3.join(path3.dirname(projectRoot), "tamer-dev-app")
   ];
   for (const pkg of candidates) {
-    if (fs2.existsSync(pkg) && fs2.existsSync(path2.join(pkg, "package.json"))) {
+    if (fs3.existsSync(pkg) && fs3.existsSync(path3.join(pkg, "package.json"))) {
       return pkg;
     }
   }
@@ -225,13 +248,13 @@ function findDevAppPackage(projectRoot) {
 }
 function findDevClientPackage(projectRoot) {
   const candidates = [
-    path2.join(projectRoot, "node_modules", "@tamer4lynx", "tamer-dev-client"),
-    path2.join(projectRoot, "node_modules", "tamer-dev-client"),
-    path2.join(projectRoot, "packages", "tamer-dev-client"),
-    path2.join(path2.dirname(projectRoot), "tamer-dev-client")
+    path3.join(projectRoot, "node_modules", "@tamer4lynx", "tamer-dev-client"),
+    path3.join(projectRoot, "node_modules", "tamer-dev-client"),
+    path3.join(projectRoot, "packages", "tamer-dev-client"),
+    path3.join(path3.dirname(projectRoot), "tamer-dev-client")
   ];
   for (const pkg of candidates) {
-    if (fs2.existsSync(pkg) && fs2.existsSync(path2.join(pkg, "package.json"))) {
+    if (fs3.existsSync(pkg) && fs3.existsSync(path3.join(pkg, "package.json"))) {
       return pkg;
     }
   }
@@ -239,11 +262,11 @@ function findDevClientPackage(projectRoot) {
 }
 function findTamerHostPackage(projectRoot) {
   const candidates = [
-    path2.join(projectRoot, "node_modules", "tamer-host"),
-    path2.join(projectRoot, "packages", "tamer-host")
+    path3.join(projectRoot, "node_modules", "tamer-host"),
+    path3.join(projectRoot, "packages", "tamer-host")
   ];
   for (const pkg of candidates) {
-    if (fs2.existsSync(pkg) && fs2.existsSync(path2.join(pkg, "package.json"))) {
+    if (fs3.existsSync(pkg) && fs3.existsSync(path3.join(pkg, "package.json"))) {
       return pkg;
     }
   }
@@ -261,18 +284,18 @@ function resolveHostPaths(cwd = process.cwd()) {
   const lynxProjectDir = discovered?.dir ?? cwd;
   const bundleRoot = paths.lynxBundleRoot ?? discovered?.bundleRoot ?? DEFAULT_BUNDLE_ROOT;
   const bundleFile = paths.lynxBundleFile ?? DEFAULT_BUNDLE_FILE;
-  const lynxBundlePath = path2.join(lynxProjectDir, bundleRoot, bundleFile);
-  const androidDir = path2.join(projectRoot, androidDirRel);
+  const lynxBundlePath = path3.join(lynxProjectDir, bundleRoot, bundleFile);
+  const androidDir = path3.join(projectRoot, androidDirRel);
   const devMode = resolveDevMode(config);
   const devClientPkg = findDevClientPackage(projectRoot);
-  const devClientBundlePath = devClientPkg ? path2.join(devClientPkg, DEFAULT_BUNDLE_ROOT, "dev-client.lynx.bundle") : void 0;
+  const devClientBundlePath = devClientPkg ? path3.join(devClientPkg, DEFAULT_BUNDLE_ROOT, "dev-client.lynx.bundle") : void 0;
   return {
     projectRoot,
     androidDir,
-    iosDir: path2.join(projectRoot, iosDirRel),
-    androidAppDir: path2.join(projectRoot, androidDirRel, "app"),
-    androidAssetsDir: path2.join(projectRoot, androidDirRel, "app", "src", "main", "assets"),
-    androidKotlinDir: path2.join(projectRoot, androidDirRel, "app", "src", "main", "kotlin", packageName.replace(/\./g, "/")),
+    iosDir: path3.join(projectRoot, iosDirRel),
+    androidAppDir: path3.join(projectRoot, androidDirRel, "app"),
+    androidAssetsDir: path3.join(projectRoot, androidDirRel, "app", "src", "main", "assets"),
+    androidKotlinDir: path3.join(projectRoot, androidDirRel, "app", "src", "main", "kotlin", packageName.replace(/\./g, "/")),
     lynxProjectDir,
     lynxBundlePath,
     lynxBundleFile: bundleFile,
@@ -347,32 +370,32 @@ function normalizeAndroidAdaptiveColor(input) {
 function resolveIconPaths(projectRoot, config) {
   const raw = config.icon;
   if (!raw) return null;
-  const join = (p) => path2.isAbsolute(p) ? p : path2.join(projectRoot, p);
+  const join = (p) => path3.isAbsolute(p) ? p : path3.join(projectRoot, p);
   if (typeof raw === "string") {
     const p = join(raw);
-    return fs2.existsSync(p) ? { source: p } : null;
+    return fs3.existsSync(p) ? { source: p } : null;
   }
   const out = {};
   if (raw.source) {
     const p = join(raw.source);
-    if (fs2.existsSync(p)) out.source = p;
+    if (fs3.existsSync(p)) out.source = p;
   }
   if (raw.android) {
     const p = join(raw.android);
-    if (fs2.existsSync(p)) out.android = p;
+    if (fs3.existsSync(p)) out.android = p;
   }
   if (raw.ios) {
     const p = join(raw.ios);
-    if (fs2.existsSync(p)) out.ios = p;
+    if (fs3.existsSync(p)) out.ios = p;
   }
   const ad = raw.androidAdaptive;
   if (ad?.foreground) {
     const fg = join(ad.foreground);
-    if (fs2.existsSync(fg)) {
+    if (fs3.existsSync(fg)) {
       let usedAdaptive = false;
       if (ad.background) {
         const bg = join(ad.background);
-        if (fs2.existsSync(bg)) {
+        if (fs3.existsSync(bg)) {
           out.androidAdaptiveForeground = fg;
           out.androidAdaptiveBackground = bg;
           usedAdaptive = true;
@@ -395,19 +418,19 @@ function resolveIconPaths(projectRoot, config) {
 }
 // src/common/syncAppIcons.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function purgeAdaptiveForegroundArtifacts(drawableDir) {
   for (const base of ["ic_launcher_fg_src", "ic_launcher_fg_bm", "ic_launcher_fg_sc"]) {
     for (const ext of [".png", ".webp", ".jpg", ".jpeg", ".xml"]) {
       try {
-        fs3.unlinkSync(path3.join(drawableDir, base + ext));
+        fs4.unlinkSync(path4.join(drawableDir, base + ext));
       } catch {
       }
     }
   }
   try {
-    fs3.unlinkSync(path3.join(drawableDir, "ic_launcher_foreground.xml"));
+    fs4.unlinkSync(path4.join(drawableDir, "ic_launcher_foreground.xml"));
   } catch {
   }
 }
@@ -420,15 +443,15 @@ function writeAdaptiveForegroundLayer(drawableDir, fgSourcePath, fgExt, layout)
   purgeAdaptiveForegroundArtifacts(drawableDir);
   for (const ext of [".png", ".webp", ".jpg", ".jpeg"]) {
     try {
-      fs3.unlinkSync(path3.join(drawableDir, `ic_launcher_foreground${ext}`));
+      fs4.unlinkSync(path4.join(drawableDir, `ic_launcher_foreground${ext}`));
     } catch {
     }
   }
   if (!layout) {
-    fs3.copyFileSync(fgSourcePath, path3.join(drawableDir, `ic_launcher_foreground${fgExt}`));
+    fs4.copyFileSync(fgSourcePath, path4.join(drawableDir, `ic_launcher_foreground${fgExt}`));
     return;
   }
-  fs3.copyFileSync(fgSourcePath, path3.join(drawableDir, `ic_launcher_fg_src${fgExt}`));
+  fs4.copyFileSync(fgSourcePath, path4.join(drawableDir, `ic_launcher_fg_src${fgExt}`));
   const CANVAS_DP = 108;
   const scale = layout.scale ?? 1;
   const shrinkDp = (1 - scale) / 2 * CANVAS_DP;
@@ -452,11 +475,11 @@ function writeAdaptiveForegroundLayer(drawableDir, fgSourcePath, fgExt, layout)
         android:bottom="${insetBottom}dp"
         android:drawable="@drawable/ic_launcher_fg_src" />
 </layer-list>`;
-  fs3.writeFileSync(path3.join(drawableDir, "ic_launcher_foreground.xml"), layerXml);
+  fs4.writeFileSync(path4.join(drawableDir, "ic_launcher_foreground.xml"), layerXml);
 }
 function ensureAndroidManifestLauncherIcon(manifestPath) {
-  if (!fs3.existsSync(manifestPath)) return;
-  let content = fs3.readFileSync(manifestPath, "utf8");
+  if (!fs4.existsSync(manifestPath)) return;
+  let content = fs4.readFileSync(manifestPath, "utf8");
   if (content.includes("android:icon=")) return;
   const next = content.replace(/<application(\s[^>]*)>/, (full, attrs) => {
     if (String(attrs).includes("android:icon")) return full;
@@ -465,30 +488,30 @@ function ensureAndroidManifestLauncherIcon(manifestPath) {
         android:roundIcon="@mipmap/ic_launcher">`;
   });
   if (next !== content) {
-    fs3.writeFileSync(manifestPath, next, "utf8");
+    fs4.writeFileSync(manifestPath, next, "utf8");
     console.log("\u2705 Added android:icon / roundIcon to AndroidManifest.xml");
   }
 }
 function applyAndroidLauncherIcons(resDir, iconPaths) {
   if (!iconPaths) return false;
-  fs3.mkdirSync(resDir, { recursive: true });
+  fs4.mkdirSync(resDir, { recursive: true });
   const fgAd = iconPaths.androidAdaptiveForeground;
   const bgAd = iconPaths.androidAdaptiveBackground;
   const bgColor = iconPaths.androidAdaptiveBackgroundColor;
   if (fgAd && (bgAd || bgColor)) {
-    const drawableDir = path3.join(resDir, "drawable");
-    fs3.mkdirSync(drawableDir, { recursive: true });
-    const fgExt = path3.extname(fgAd) || ".png";
+    const drawableDir = path4.join(resDir, "drawable");
+    fs4.mkdirSync(drawableDir, { recursive: true });
+    const fgExt = path4.extname(fgAd) || ".png";
     writeAdaptiveForegroundLayer(drawableDir, fgAd, fgExt, iconPaths.androidAdaptiveForegroundLayout);
     if (bgColor) {
       for (const ext of [".png", ".webp", ".jpg", ".jpeg"]) {
         try {
-          fs3.unlinkSync(path3.join(drawableDir, `ic_launcher_background${ext}`));
+          fs4.unlinkSync(path4.join(drawableDir, `ic_launcher_background${ext}`));
         } catch {
         }
       }
       try {
-        fs3.unlinkSync(path3.join(drawableDir, "ic_launcher_background.xml"));
+        fs4.unlinkSync(path4.join(drawableDir, "ic_launcher_background.xml"));
       } catch {
       }
       const shapeXml = `<?xml version="1.0" encoding="utf-8"?>
@@ -496,44 +519,44 @@ function applyAndroidLauncherIcons(resDir, iconPaths) {
     <solid android:color="${bgColor}" />
 </shape>
 `;
-      fs3.writeFileSync(path3.join(drawableDir, "ic_launcher_background.xml"), shapeXml);
+      fs4.writeFileSync(path4.join(drawableDir, "ic_launcher_background.xml"), shapeXml);
     } else {
       try {
-        fs3.unlinkSync(path3.join(drawableDir, "ic_launcher_background.xml"));
+        fs4.unlinkSync(path4.join(drawableDir, "ic_launcher_background.xml"));
       } catch {
       }
-      const bgExt = path3.extname(bgAd) || ".png";
-      fs3.copyFileSync(bgAd, path3.join(drawableDir, `ic_launcher_background${bgExt}`));
+      const bgExt = path4.extname(bgAd) || ".png";
+      fs4.copyFileSync(bgAd, path4.join(drawableDir, `ic_launcher_background${bgExt}`));
     }
-    const anyDpi = path3.join(resDir, "mipmap-anydpi-v26");
-    fs3.mkdirSync(anyDpi, { recursive: true });
+    const anyDpi = path4.join(resDir, "mipmap-anydpi-v26");
+    fs4.mkdirSync(anyDpi, { recursive: true });
     const adaptiveXml = `<?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
     <background android:drawable="@drawable/ic_launcher_background" />
     <foreground android:drawable="@drawable/ic_launcher_foreground" />
 </adaptive-icon>
 `;
-    fs3.writeFileSync(path3.join(anyDpi, "ic_launcher.xml"), adaptiveXml);
-    fs3.writeFileSync(path3.join(anyDpi, "ic_launcher_round.xml"), adaptiveXml);
+    fs4.writeFileSync(path4.join(anyDpi, "ic_launcher.xml"), adaptiveXml);
+    fs4.writeFileSync(path4.join(anyDpi, "ic_launcher_round.xml"), adaptiveXml);
     const legacySrc = iconPaths.source ?? fgAd;
-    const legacyExt = path3.extname(legacySrc) || ".png";
+    const legacyExt = path4.extname(legacySrc) || ".png";
     const mipmapDensities = ["mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"];
     for (const d of mipmapDensities) {
-      const dir = path3.join(resDir, `mipmap-${d}`);
-      fs3.mkdirSync(dir, { recursive: true });
-      fs3.copyFileSync(legacySrc, path3.join(dir, `ic_launcher${legacyExt}`));
+      const dir = path4.join(resDir, `mipmap-${d}`);
+      fs4.mkdirSync(dir, { recursive: true });
+      fs4.copyFileSync(legacySrc, path4.join(dir, `ic_launcher${legacyExt}`));
     }
     return true;
   }
   if (iconPaths.android) {
     const src = iconPaths.android;
-    const entries = fs3.readdirSync(src, { withFileTypes: true });
+    const entries = fs4.readdirSync(src, { withFileTypes: true });
     for (const e of entries) {
-      const dest = path3.join(resDir, e.name);
+      const dest = path4.join(resDir, e.name);
       if (e.isDirectory()) {
-        fs3.cpSync(path3.join(src, e.name), dest, { recursive: true });
+        fs4.cpSync(path4.join(src, e.name), dest, { recursive: true });
       } else {
-        fs3.copyFileSync(path3.join(src, e.name), dest);
+        fs4.copyFileSync(path4.join(src, e.name), dest);
       }
     }
     return true;
@@ -541,9 +564,9 @@ function applyAndroidLauncherIcons(resDir, iconPaths) {
   if (iconPaths.source) {
     const mipmapDensities = ["mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"];
     for (const d of mipmapDensities) {
-      const dir = path3.join(resDir, `mipmap-${d}`);
-      fs3.mkdirSync(dir, { recursive: true });
-      fs3.copyFileSync(iconPaths.source, path3.join(dir, "ic_launcher.png"));
+      const dir = path4.join(resDir, `mipmap-${d}`);
+      fs4.mkdirSync(dir, { recursive: true });
+      fs4.copyFileSync(iconPaths.source, path4.join(dir, "ic_launcher.png"));
     }
     return true;
   }
@@ -551,25 +574,25 @@ function applyAndroidLauncherIcons(resDir, iconPaths) {
 }
 function applyIosAppIconAssets(appIconDir, iconPaths) {
   if (!iconPaths) return false;
-  fs3.mkdirSync(appIconDir, { recursive: true });
+  fs4.mkdirSync(appIconDir, { recursive: true });
   if (iconPaths.ios) {
-    const entries = fs3.readdirSync(iconPaths.ios, { withFileTypes: true });
+    const entries = fs4.readdirSync(iconPaths.ios, { withFileTypes: true });
     for (const e of entries) {
-      const dest = path3.join(appIconDir, e.name);
+      const dest = path4.join(appIconDir, e.name);
       if (e.isDirectory()) {
-        fs3.cpSync(path3.join(iconPaths.ios, e.name), dest, { recursive: true });
+        fs4.cpSync(path4.join(iconPaths.ios, e.name), dest, { recursive: true });
       } else {
-        fs3.copyFileSync(path3.join(iconPaths.ios, e.name), dest);
+        fs4.copyFileSync(path4.join(iconPaths.ios, e.name), dest);
       }
     }
     return true;
   }
   if (iconPaths.source) {
-    const ext = path3.extname(iconPaths.source) || ".png";
+    const ext = path4.extname(iconPaths.source) || ".png";
     const icon1024 = `Icon-1024${ext}`;
-    fs3.copyFileSync(iconPaths.source, path3.join(appIconDir, icon1024));
-    fs3.writeFileSync(
-      path3.join(appIconDir, "Contents.json"),
+    fs4.copyFileSync(iconPaths.source, path4.join(appIconDir, icon1024));
+    fs4.writeFileSync(
+      path4.join(appIconDir, "Contents.json"),
       JSON.stringify(
         {
           images: [{ filename: icon1024, idiom: "universal", platform: "ios", size: "1024x1024" }],
@@ -1121,7 +1144,7 @@ object DevServerPrefs {
 // src/android/create.ts
 function readAndSubstituteTemplate(templatePath, vars) {
-  const raw = fs4.readFileSync(templatePath, "utf-8");
+  const raw = fs5.readFileSync(templatePath, "utf-8");
   return Object.entries(vars).reduce(
     (s, [k, v]) => s.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v),
     raw
@@ -1132,7 +1155,7 @@ var create = async (opts = {}) => {
   const origCwd = process.cwd();
   if (target === "dev-app") {
     const devAppDir = findDevAppPackage(origCwd) ?? findDevAppPackage(findRepoRoot(origCwd));
-    if (!devAppDir || !fs4.existsSync(path4.join(devAppDir, "tamer.config.json"))) {
+    if (!devAppDir || !fs5.existsSync(path5.join(devAppDir, "tamer.config.json"))) {
       console.error("\u274C tamer-dev-app not found. Add @tamer4lynx/tamer-dev-app to dependencies.");
       process.exit(1);
     }
@@ -1162,30 +1185,30 @@ var create = async (opts = {}) => {
   const packagePath = packageName.replace(/\./g, "/");
   const gradleVersion = "8.14.2";
   const androidDir = config.paths?.androidDir ?? "android";
-  const rootDir = path4.join(process.cwd(), androidDir);
-  const appDir = path4.join(rootDir, "app");
-  const mainDir = path4.join(appDir, "src", "main");
-  const javaDir = path4.join(mainDir, "java", packagePath);
-  const kotlinDir = path4.join(mainDir, "kotlin", packagePath);
-  const kotlinGeneratedDir = path4.join(kotlinDir, "generated");
-  const assetsDir = path4.join(mainDir, "assets");
-  const themesDir = path4.join(mainDir, "res", "values");
-  const gradleDir = path4.join(rootDir, "gradle");
+  const rootDir = path5.join(process.cwd(), androidDir);
+  const appDir = path5.join(rootDir, "app");
+  const mainDir = path5.join(appDir, "src", "main");
+  const javaDir = path5.join(mainDir, "java", packagePath);
+  const kotlinDir = path5.join(mainDir, "kotlin", packagePath);
+  const kotlinGeneratedDir = path5.join(kotlinDir, "generated");
+  const assetsDir = path5.join(mainDir, "assets");
+  const themesDir = path5.join(mainDir, "res", "values");
+  const gradleDir = path5.join(rootDir, "gradle");
   function writeFile2(filePath, content, options) {
-    fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
-    fs4.writeFileSync(
+    fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+    fs5.writeFileSync(
       filePath,
       content.trimStart(),
       options?.encoding ?? "utf8"
     );
   }
-  if (fs4.existsSync(rootDir)) {
+  if (fs5.existsSync(rootDir)) {
     console.log(`\u{1F9F9} Removing existing directory: ${rootDir}`);
-    fs4.rmSync(rootDir, { recursive: true, force: true });
+    fs5.rmSync(rootDir, { recursive: true, force: true });
   }
   console.log(`\u{1F680} Creating a new Tamer4Lynx project in: ${rootDir}`);
   writeFile2(
-    path4.join(gradleDir, "libs.versions.toml"),
+    path5.join(gradleDir, "libs.versions.toml"),
     `
 [versions]
 agp = "8.9.1"
@@ -1246,7 +1269,7 @@ kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
 `
   );
   writeFile2(
-    path4.join(rootDir, "settings.gradle.kts"),
+    path5.join(rootDir, "settings.gradle.kts"),
     `
 pluginManagement {
     repositories {
@@ -1280,7 +1303,7 @@ println("If you have native modules please run tamer android link")
 `
   );
   writeFile2(
-    path4.join(rootDir, "build.gradle.kts"),
+    path5.join(rootDir, "build.gradle.kts"),
     `
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
@@ -1292,7 +1315,7 @@ plugins {
 `
   );
   writeFile2(
-    path4.join(rootDir, "gradle.properties"),
+    path5.join(rootDir, "gradle.properties"),
     `
 org.gradle.jvmargs=-Xmx2048m
 android.useAndroidX=true
@@ -1301,7 +1324,7 @@ android.enableJetifier=true
 `
   );
   writeFile2(
-    path4.join(appDir, "build.gradle.kts"),
+    path5.join(appDir, "build.gradle.kts"),
     `
 plugins {
     alias(libs.plugins.android.application)
@@ -1393,7 +1416,7 @@ dependencies {
 `
   );
   writeFile2(
-    path4.join(themesDir, "themes.xml"),
+    path5.join(themesDir, "themes.xml"),
     `
 <resources>
     <style name="Theme.MyApp" parent="Theme.AppCompat.Light.NoActionBar">
@@ -1427,7 +1450,7 @@ dependencies {
   const iconPaths = resolveIconPaths(process.cwd(), config);
   const manifestIconAttrs = iconPaths ? '        android:icon="@mipmap/ic_launcher"\n        android:roundIcon="@mipmap/ic_launcher"\n' : "";
   writeFile2(
-    path4.join(mainDir, "AndroidManifest.xml"),
+    path5.join(mainDir, "AndroidManifest.xml"),
     `
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 ${manifestPermissions}
@@ -1441,7 +1464,7 @@ ${manifestIconAttrs}        android:usesCleartextTraffic="true"
 `
   );
   writeFile2(
-    path4.join(kotlinGeneratedDir, "GeneratedLynxExtensions.kt"),
+    path5.join(kotlinGeneratedDir, "GeneratedLynxExtensions.kt"),
     `
 package ${packageName}.generated
@@ -1469,14 +1492,14 @@ object GeneratedLynxExtensions {
   const hostPkg = findTamerHostPackage(process.cwd());
   const devClientPkg = findDevClientPackage(process.cwd());
   if (!hasDevLauncher && hostPkg) {
-    const templateDir = path4.join(hostPkg, "android", "templates");
+    const templateDir = path5.join(hostPkg, "android", "templates");
     for (const [src, dst] of [
-      ["App.java", path4.join(javaDir, "App.java")],
-      ["TemplateProvider.java", path4.join(javaDir, "TemplateProvider.java")],
-      ["MainActivity.kt", path4.join(kotlinDir, "MainActivity.kt")]
+      ["App.java", path5.join(javaDir, "App.java")],
+      ["TemplateProvider.java", path5.join(javaDir, "TemplateProvider.java")],
+      ["MainActivity.kt", path5.join(kotlinDir, "MainActivity.kt")]
     ]) {
-      const srcPath = path4.join(templateDir, src);
-      if (fs4.existsSync(srcPath)) {
+      const srcPath = path5.join(templateDir, src);
+      if (fs5.existsSync(srcPath)) {
         writeFile2(dst, readAndSubstituteTemplate(srcPath, templateVars));
       }
     }
@@ -1485,34 +1508,34 @@ object GeneratedLynxExtensions {
       fetchAndPatchApplication(vars),
       fetchAndPatchTemplateProvider(vars)
     ]);
-    writeFile2(path4.join(javaDir, "App.java"), applicationSource);
-    writeFile2(path4.join(javaDir, "TemplateProvider.java"), templateProviderSource);
-    writeFile2(path4.join(kotlinDir, "MainActivity.kt"), getStandaloneMainActivity(vars));
+    writeFile2(path5.join(javaDir, "App.java"), applicationSource);
+    writeFile2(path5.join(javaDir, "TemplateProvider.java"), templateProviderSource);
+    writeFile2(path5.join(kotlinDir, "MainActivity.kt"), getStandaloneMainActivity(vars));
     if (hasDevLauncher) {
       if (devClientPkg) {
-        const templateDir = path4.join(devClientPkg, "android", "templates");
+        const templateDir = path5.join(devClientPkg, "android", "templates");
         for (const [src, dst] of [
-          ["ProjectActivity.kt", path4.join(kotlinDir, "ProjectActivity.kt")],
-          ["DevClientManager.kt", path4.join(kotlinDir, "DevClientManager.kt")],
-          ["DevServerPrefs.kt", path4.join(kotlinDir, "DevServerPrefs.kt")]
+          ["ProjectActivity.kt", path5.join(kotlinDir, "ProjectActivity.kt")],
+          ["DevClientManager.kt", path5.join(kotlinDir, "DevClientManager.kt")],
+          ["DevServerPrefs.kt", path5.join(kotlinDir, "DevServerPrefs.kt")]
         ]) {
-          const srcPath = path4.join(templateDir, src);
-          if (fs4.existsSync(srcPath)) {
+          const srcPath = path5.join(templateDir, src);
+          if (fs5.existsSync(srcPath)) {
             writeFile2(dst, readAndSubstituteTemplate(srcPath, templateVars));
           }
         }
       } else {
-        writeFile2(path4.join(kotlinDir, "ProjectActivity.kt"), getProjectActivity(vars));
+        writeFile2(path5.join(kotlinDir, "ProjectActivity.kt"), getProjectActivity(vars));
         const devClientManagerSource = getDevClientManager(vars);
         if (devClientManagerSource) {
-          writeFile2(path4.join(kotlinDir, "DevClientManager.kt"), devClientManagerSource);
-          writeFile2(path4.join(kotlinDir, "DevServerPrefs.kt"), getDevServerPrefs(vars));
+          writeFile2(path5.join(kotlinDir, "DevClientManager.kt"), devClientManagerSource);
+          writeFile2(path5.join(kotlinDir, "DevServerPrefs.kt"), getDevServerPrefs(vars));
         }
       }
     }
   }
   if (iconPaths) {
-    const resDir = path4.join(mainDir, "res");
+    const resDir = path5.join(mainDir, "res");
     if (applyAndroidLauncherIcons(resDir, iconPaths)) {
       if (iconPaths.androidAdaptiveForeground && (iconPaths.androidAdaptiveBackground || iconPaths.androidAdaptiveBackgroundColor)) {
         console.log("\u2705 Android adaptive launcher from tamer.config.json icon.androidAdaptive");
@@ -1523,23 +1546,23 @@ object GeneratedLynxExtensions {
       }
     }
   }
-  fs4.mkdirSync(assetsDir, { recursive: true });
-  fs4.writeFileSync(path4.join(assetsDir, ".gitkeep"), "");
+  fs5.mkdirSync(assetsDir, { recursive: true });
+  fs5.writeFileSync(path5.join(assetsDir, ".gitkeep"), "");
   console.log(`\u2705 Android Kotlin project created at ${rootDir}`);
   async function finalizeProjectSetup() {
     if (androidSdk) {
       try {
         const sdkDirContent = `sdk.dir=${androidSdk.replace(/\\/g, "/")}`;
-        writeFile2(path4.join(rootDir, "local.properties"), sdkDirContent);
+        writeFile2(path5.join(rootDir, "local.properties"), sdkDirContent);
         console.log("\u{1F4E6} Created local.properties from tamer.config.json.");
       } catch (err) {
         console.error(`\u274C Failed to create local.properties: ${err.message}`);
       }
     } else {
-      const localPropsPath = path4.join(process.cwd(), "local.properties");
-      if (fs4.existsSync(localPropsPath)) {
+      const localPropsPath = path5.join(process.cwd(), "local.properties");
+      if (fs5.existsSync(localPropsPath)) {
         try {
-          fs4.copyFileSync(localPropsPath, path4.join(rootDir, "local.properties"));
+          fs5.copyFileSync(localPropsPath, path5.join(rootDir, "local.properties"));
           console.log("\u{1F4E6} Copied existing local.properties to the android project.");
         } catch (err) {
           console.error("\u274C Failed to copy local.properties:", err);
@@ -1558,33 +1581,33 @@ object GeneratedLynxExtensions {
 var create_default = create;
 // src/android/autolink.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { execSync as execSync2 } from "child_process";
 // src/common/discoverModules.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 // src/common/config.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 var LYNX_EXT_JSON = "lynx.ext.json";
 var TAMER_JSON = "tamer.json";
 function loadLynxExtJson(packagePath) {
-  const p = path5.join(packagePath, LYNX_EXT_JSON);
-  if (!fs5.existsSync(p)) return null;
+  const p = path6.join(packagePath, LYNX_EXT_JSON);
+  if (!fs6.existsSync(p)) return null;
   try {
-    return JSON.parse(fs5.readFileSync(p, "utf8"));
+    return JSON.parse(fs6.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
 }
 function loadTamerJson(packagePath) {
-  const p = path5.join(packagePath, TAMER_JSON);
-  if (!fs5.existsSync(p)) return null;
+  const p = path6.join(packagePath, TAMER_JSON);
+  if (!fs6.existsSync(p)) return null;
   try {
-    return JSON.parse(fs5.readFileSync(p, "utf8"));
+    return JSON.parse(fs6.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
@@ -1637,7 +1660,7 @@ function loadExtensionConfig(packagePath) {
   return normalized;
 }
 function hasExtensionConfig(packagePath) {
-  return fs5.existsSync(path5.join(packagePath, LYNX_EXT_JSON)) || fs5.existsSync(path5.join(packagePath, TAMER_JSON));
+  return fs6.existsSync(path6.join(packagePath, LYNX_EXT_JSON)) || fs6.existsSync(path6.join(packagePath, TAMER_JSON));
 }
 function getAndroidModuleClassNames(config) {
   if (!config) return [];
@@ -1655,15 +1678,15 @@ function getIosElements(config) {
   return config?.elements ?? {};
 }
 function getNodeModulesPath(projectRoot) {
-  let nodeModulesPath = path5.join(projectRoot, "node_modules");
-  const workspaceRoot = path5.join(projectRoot, "..", "..");
-  const rootNodeModules = path5.join(workspaceRoot, "node_modules");
-  if (fs5.existsSync(path5.join(workspaceRoot, "package.json")) && fs5.existsSync(rootNodeModules) && path5.basename(path5.dirname(projectRoot)) === "packages") {
+  let nodeModulesPath = path6.join(projectRoot, "node_modules");
+  const workspaceRoot = path6.join(projectRoot, "..", "..");
+  const rootNodeModules = path6.join(workspaceRoot, "node_modules");
+  if (fs6.existsSync(path6.join(workspaceRoot, "package.json")) && fs6.existsSync(rootNodeModules) && path6.basename(path6.dirname(projectRoot)) === "packages") {
     nodeModulesPath = rootNodeModules;
-  } else if (!fs5.existsSync(nodeModulesPath)) {
-    const altRoot = path5.join(projectRoot, "..", "..");
-    const altNodeModules = path5.join(altRoot, "node_modules");
-    if (fs5.existsSync(path5.join(altRoot, "package.json")) && fs5.existsSync(altNodeModules)) {
+  } else if (!fs6.existsSync(nodeModulesPath)) {
+    const altRoot = path6.join(projectRoot, "..", "..");
+    const altNodeModules = path6.join(altRoot, "node_modules");
+    if (fs6.existsSync(path6.join(altRoot, "package.json")) && fs6.existsSync(altNodeModules)) {
       nodeModulesPath = altNodeModules;
     }
   }
@@ -1672,8 +1695,8 @@ function getNodeModulesPath(projectRoot) {
 function discoverNativeExtensions(projectRoot) {
   const nodeModulesPath = getNodeModulesPath(projectRoot);
   const result = [];
-  if (!fs5.existsSync(nodeModulesPath)) return result;
-  const packageDirs = fs5.readdirSync(nodeModulesPath);
+  if (!fs6.existsSync(nodeModulesPath)) return result;
+  const packageDirs = fs6.readdirSync(nodeModulesPath);
   const check = (name, packagePath) => {
     if (!hasExtensionConfig(packagePath)) return;
     const config = loadExtensionConfig(packagePath);
@@ -1683,11 +1706,11 @@ function discoverNativeExtensions(projectRoot) {
     }
   };
   for (const dirName of packageDirs) {
-    const fullPath = path5.join(nodeModulesPath, dirName);
+    const fullPath = path6.join(nodeModulesPath, dirName);
     if (dirName.startsWith("@")) {
       try {
-        for (const scopedDirName of fs5.readdirSync(fullPath)) {
-          check(`${dirName}/${scopedDirName}`, path5.join(fullPath, scopedDirName));
+        for (const scopedDirName of fs6.readdirSync(fullPath)) {
+          check(`${dirName}/${scopedDirName}`, path6.join(fullPath, scopedDirName));
         }
       } catch {
       }
@@ -1700,29 +1723,80 @@ function discoverNativeExtensions(projectRoot) {
 // src/common/discoverModules.ts
 function resolveNodeModulesPath(projectRoot) {
-  let nodeModulesPath = path6.join(projectRoot, "node_modules");
-  const workspaceRoot = path6.join(projectRoot, "..", "..");
-  const rootNodeModules = path6.join(workspaceRoot, "node_modules");
-  if (fs6.existsSync(path6.join(workspaceRoot, "package.json")) && fs6.existsSync(rootNodeModules) && path6.basename(path6.dirname(projectRoot)) === "packages") {
+  let nodeModulesPath = path7.join(projectRoot, "node_modules");
+  const workspaceRoot = path7.join(projectRoot, "..", "..");
+  const rootNodeModules = path7.join(workspaceRoot, "node_modules");
+  if (fs7.existsSync(path7.join(workspaceRoot, "package.json")) && fs7.existsSync(rootNodeModules) && path7.basename(path7.dirname(projectRoot)) === "packages") {
     nodeModulesPath = rootNodeModules;
-  } else if (!fs6.existsSync(nodeModulesPath)) {
-    const altRoot = path6.join(projectRoot, "..", "..");
-    const altNodeModules = path6.join(altRoot, "node_modules");
-    if (fs6.existsSync(path6.join(altRoot, "package.json")) && fs6.existsSync(altNodeModules)) {
+  } else if (!fs7.existsSync(nodeModulesPath)) {
+    const altRoot = path7.join(projectRoot, "..", "..");
+    const altNodeModules = path7.join(altRoot, "node_modules");
+    if (fs7.existsSync(path7.join(altRoot, "package.json")) && fs7.existsSync(altNodeModules)) {
       nodeModulesPath = altNodeModules;
     }
   }
   return nodeModulesPath;
 }
+function resolvePackageRoot(projectRoot, packageName) {
+  const nodeModulesPath = resolveNodeModulesPath(projectRoot);
+  const hasPkg = (dir) => fs7.existsSync(path7.join(dir, "package.json"));
+  if (packageName.startsWith("@")) {
+    const parts = packageName.split("/");
+    if (parts.length !== 2 || !parts[0].startsWith("@")) return null;
+    const direct2 = path7.join(nodeModulesPath, parts[0], parts[1]);
+    if (hasPkg(direct2)) return direct2;
+    const underDevClient = path7.join(
+      nodeModulesPath,
+      "@tamer4lynx",
+      "tamer-dev-client",
+      "node_modules",
+      parts[0],
+      parts[1]
+    );
+    if (hasPkg(underDevClient)) return underDevClient;
+    return null;
+  }
+  const direct = path7.join(nodeModulesPath, packageName);
+  return hasPkg(direct) ? direct : null;
+}
+function collectTransitiveTamer4LynxPackageNames(projectRoot) {
+  const hostPjPath = path7.join(projectRoot, "package.json");
+  if (!fs7.existsSync(hostPjPath)) return null;
+  const hostPj = JSON.parse(fs7.readFileSync(hostPjPath, "utf8"));
+  if (hostPj.name !== "@tamer4lynx/tamer-dev-app") return null;
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  const enqueue = (deps) => {
+    if (!deps) return;
+    for (const name of Object.keys(deps)) {
+      if (name.startsWith("@tamer4lynx/")) queue.push(name);
+    }
+  };
+  enqueue(hostPj.dependencies);
+  enqueue(hostPj.optionalDependencies);
+  while (queue.length) {
+    const name = queue.shift();
+    if (visited.has(name)) continue;
+    visited.add(name);
+    const pkgRoot = resolvePackageRoot(projectRoot, name);
+    if (!pkgRoot || !fs7.existsSync(path7.join(pkgRoot, "package.json"))) continue;
+    const sub = JSON.parse(fs7.readFileSync(path7.join(pkgRoot, "package.json"), "utf8"));
+    const merged = { ...sub.dependencies, ...sub.optionalDependencies };
+    for (const dep of Object.keys(merged)) {
+      if (dep.startsWith("@tamer4lynx/") && !visited.has(dep)) queue.push(dep);
+    }
+  }
+  return visited;
+}
 function discoverModules(projectRoot) {
   const nodeModulesPath = resolveNodeModulesPath(projectRoot);
   const packages = [];
-  if (!fs6.existsSync(nodeModulesPath)) {
+  if (!fs7.existsSync(nodeModulesPath)) {
     return [];
   }
-  const packageDirs = fs6.readdirSync(nodeModulesPath);
+  const packageDirs = fs7.readdirSync(nodeModulesPath);
   for (const dirName of packageDirs) {
-    const fullPath = path6.join(nodeModulesPath, dirName);
+    const fullPath = path7.join(nodeModulesPath, dirName);
     const checkPackage = (name, packagePath) => {
       if (!hasExtensionConfig(packagePath)) return;
       const config = loadExtensionConfig(packagePath);
@@ -1731,9 +1805,9 @@ function discoverModules(projectRoot) {
     };
     if (dirName.startsWith("@")) {
       try {
-        const scopedDirs = fs6.readdirSync(fullPath);
+        const scopedDirs = fs7.readdirSync(fullPath);
         for (const scopedDirName of scopedDirs) {
-          const scopedPackagePath = path6.join(fullPath, scopedDirName);
+          const scopedPackagePath = path7.join(fullPath, scopedDirName);
           checkPackage(`${dirName}/${scopedDirName}`, scopedPackagePath);
         }
       } catch (e) {
@@ -1744,6 +1818,10 @@ function discoverModules(projectRoot) {
       checkPackage(dirName, fullPath);
     }
   }
+  const allowed = collectTransitiveTamer4LynxPackageNames(projectRoot);
+  if (allowed) {
+    return packages.filter((p) => allowed.has(p.name));
+  }
   return packages;
 }
@@ -1795,6 +1873,8 @@ ${allModuleClasses.map((c) => `            "${c.replace(/\\/g, "\\\\").replace(/
     fun onHostViewChanged(view: android.view.View?) {
 ${hostViewLines}
     }` : "\n    fun onHostViewChanged(view: android.view.View?) {}\n";
+  const devToolBootstrapPrefix = hasDevClient ? "        com.nanofuxion.tamerdevclient.LynxDevToolBootstrap.configure(context)\n" : "";
+  const devToolBootstrapSuffix = hasDevClient ? "        com.nanofuxion.tamerdevclient.LynxDevToolBootstrap.enableLynxDebugFlags()\n" : "";
   return `package ${projectPackage}.generated
 import android.content.Context
@@ -1806,7 +1886,7 @@ ${elementImports}
 object GeneratedLynxExtensions {
     fun register(context: Context) {
-${allRegistrations}${devClientSupportedBlock}
+${devToolBootstrapPrefix}${allRegistrations}${devClientSupportedBlock}${devToolBootstrapSuffix}
     }
     fun configureViewBuilder(viewBuilder: LynxViewBuilder) {
@@ -1939,11 +2019,11 @@ var autolink = (opts) => {
   const packageName = config.android.packageName;
   const projectRoot = resolved.projectRoot;
   function updateGeneratedSection(filePath, newContent, startMarker, endMarker) {
-    if (!fs7.existsSync(filePath)) {
+    if (!fs8.existsSync(filePath)) {
       console.warn(`\u26A0\uFE0F File not found, skipping update: ${filePath}`);
       return;
     }
-    let fileContent = fs7.readFileSync(filePath, "utf8");
+    let fileContent = fs8.readFileSync(filePath, "utf8");
     const escapedStartMarker = startMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const escapedEndMarker = endMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regex = new RegExp(`${escapedStartMarker}[\\s\\S]*?${escapedEndMarker}`, "g");
@@ -1953,16 +2033,16 @@ ${endMarker}`;
     if (regex.test(fileContent)) {
       fileContent = fileContent.replace(regex, replacementBlock);
     } else {
-      console.warn(`\u26A0\uFE0F Could not find autolink markers in ${path7.basename(filePath)}. Appending to the end of the file.`);
+      console.warn(`\u26A0\uFE0F Could not find autolink markers in ${path8.basename(filePath)}. Appending to the end of the file.`);
       fileContent += `
 ${replacementBlock}
 `;
     }
-    fs7.writeFileSync(filePath, fileContent);
-    console.log(`\u2705 Updated autolinked section in ${path7.basename(filePath)}`);
+    fs8.writeFileSync(filePath, fileContent);
+    console.log(`\u2705 Updated autolinked section in ${path8.basename(filePath)}`);
   }
   function updateSettingsGradle(packages) {
-    const settingsFilePath = path7.join(appAndroidPath, "settings.gradle.kts");
+    const settingsFilePath = path8.join(appAndroidPath, "settings.gradle.kts");
     let scriptContent = `// This section is automatically generated by Tamer4Lynx.
 // Manual edits will be overwritten.`;
     const androidPackages = packages.filter((p) => p.config.android);
@@ -1970,7 +2050,7 @@ ${replacementBlock}
       androidPackages.forEach((pkg) => {
         const gradleProjectName = pkg.name.replace(/^@/, "").replace(/\//g, "_");
         const sourceDir = pkg.config.android?.sourceDir || "android";
-        const projectPath = path7.resolve(pkg.packagePath, sourceDir).replace(/\\/g, "/");
+        const projectPath = path8.resolve(pkg.packagePath, sourceDir).replace(/\\/g, "/");
         scriptContent += `
 include(":${gradleProjectName}")`;
         scriptContent += `
@@ -1983,7 +2063,7 @@ println("No native modules found by Tamer4Lynx autolinker.")`;
     updateGeneratedSection(settingsFilePath, scriptContent.trim(), "// GENERATED AUTOLINK START", "// GENERATED AUTOLINK END");
   }
   function updateAppBuildGradle(packages) {
-    const appBuildGradlePath = path7.join(appAndroidPath, "app", "build.gradle.kts");
+    const appBuildGradlePath = path8.join(appAndroidPath, "app", "build.gradle.kts");
     const androidPackages = packages.filter((p) => p.config.android);
     const implementationLines = androidPackages.map((p) => {
       const gradleProjectName = p.name.replace(/^@/, "").replace(/\//g, "_");
@@ -2001,35 +2081,35 @@ ${implementationLines || "    // No native dependencies found to link."}`;
   }
   function generateKotlinExtensionsFile(packages, projectPackage) {
     const packagePath = projectPackage.replace(/\./g, "/");
-    const generatedDir = path7.join(appAndroidPath, "app", "src", "main", "kotlin", packagePath, "generated");
-    const kotlinExtensionsPath = path7.join(generatedDir, "GeneratedLynxExtensions.kt");
+    const generatedDir = path8.join(appAndroidPath, "app", "src", "main", "kotlin", packagePath, "generated");
+    const kotlinExtensionsPath = path8.join(generatedDir, "GeneratedLynxExtensions.kt");
     const content = `/**
  * This file is generated by the Tamer4Lynx autolinker.
  * Do not edit this file manually.
  */
 ${generateLynxExtensionsKotlin(packages, projectPackage)}`;
-    fs7.mkdirSync(generatedDir, { recursive: true });
-    fs7.writeFileSync(kotlinExtensionsPath, content.trimStart());
+    fs8.mkdirSync(generatedDir, { recursive: true });
+    fs8.writeFileSync(kotlinExtensionsPath, content.trimStart());
     console.log(`\u2705 Generated Kotlin extensions at ${kotlinExtensionsPath}`);
   }
   function generateActivityLifecycleFile(packages, projectPackage) {
     const packageKotlinPath = projectPackage.replace(/\./g, "/");
-    const generatedDir = path7.join(appAndroidPath, "app", "src", "main", "kotlin", packageKotlinPath, "generated");
-    const outputPath = path7.join(generatedDir, "GeneratedActivityLifecycle.kt");
+    const generatedDir = path8.join(appAndroidPath, "app", "src", "main", "kotlin", packageKotlinPath, "generated");
+    const outputPath = path8.join(generatedDir, "GeneratedActivityLifecycle.kt");
     const content = `/**
  * This file is generated by the Tamer4Lynx autolinker.
  * Do not edit this file manually.
  */
 ${generateActivityLifecycleKotlin(packages, projectPackage)}`;
-    fs7.mkdirSync(generatedDir, { recursive: true });
-    fs7.writeFileSync(outputPath, content);
+    fs8.mkdirSync(generatedDir, { recursive: true });
+    fs8.writeFileSync(outputPath, content);
     console.log(`\u2705 Generated activity lifecycle patches at ${outputPath}`);
   }
   function syncDeepLinkIntentFilters() {
     const deepLinks = config.android?.deepLinks;
     if (!deepLinks || deepLinks.length === 0) return;
-    const manifestPath = path7.join(appAndroidPath, "app", "src", "main", "AndroidManifest.xml");
-    if (!fs7.existsSync(manifestPath)) return;
+    const manifestPath = path8.join(appAndroidPath, "app", "src", "main", "AndroidManifest.xml");
+    if (!fs8.existsSync(manifestPath)) return;
     const intentFilters = deepLinks.map((link) => {
       const dataAttrs = [
         `android:scheme="${link.scheme}"`,
@@ -2054,9 +2134,9 @@ ${generateActivityLifecycleKotlin(packages, projectPackage)}`;
     console.log("\u{1F50E} Finding Lynx extension packages (lynx.ext.json / tamer.json)...");
     let packages = discoverModules(projectRoot).filter((p) => p.config.android);
     const includeDevClient = opts?.includeDevClient === true;
-    const devClientScoped = path7.join(projectRoot, "node_modules", "@tamer4lynx", "tamer-dev-client");
-    const devClientFlat = path7.join(projectRoot, "node_modules", "tamer-dev-client");
-    const devClientPath = fs7.existsSync(path7.join(devClientScoped, "android")) ? devClientScoped : fs7.existsSync(path7.join(devClientFlat, "android")) ? devClientFlat : null;
+    const devClientScoped = path8.join(projectRoot, "node_modules", "@tamer4lynx", "tamer-dev-client");
+    const devClientFlat = path8.join(projectRoot, "node_modules", "tamer-dev-client");
+    const devClientPath = fs8.existsSync(path8.join(devClientScoped, "android")) ? devClientScoped : fs8.existsSync(path8.join(devClientFlat, "android")) ? devClientFlat : null;
     const hasDevClient = packages.some((p) => p.name === "@tamer4lynx/tamer-dev-client" || p.name === "tamer-dev-client");
     if (includeDevClient && devClientPath && !hasDevClient) {
       packages = [{
@@ -2083,8 +2163,8 @@ ${generateActivityLifecycleKotlin(packages, projectPackage)}`;
     console.log("\u2728 Autolinking complete.");
   }
   function runGradleSync() {
-    const gradlew = path7.join(appAndroidPath, process.platform === "win32" ? "gradlew.bat" : "gradlew");
-    if (!fs7.existsSync(gradlew)) return;
+    const gradlew = path8.join(appAndroidPath, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+    if (!fs8.existsSync(gradlew)) return;
     try {
       console.log("\u2139\uFE0F Running Gradle sync in android directory...");
       execSync2(process.platform === "win32" ? "gradlew.bat projects" : "./gradlew projects", {
@@ -2098,14 +2178,14 @@ ${generateActivityLifecycleKotlin(packages, projectPackage)}`;
     }
   }
   function syncVersionCatalog(packages) {
-    const libsTomlPath = path7.join(appAndroidPath, "gradle", "libs.versions.toml");
-    if (!fs7.existsSync(libsTomlPath)) return;
+    const libsTomlPath = path8.join(appAndroidPath, "gradle", "libs.versions.toml");
+    if (!fs8.existsSync(libsTomlPath)) return;
     const requiredAliases = /* @__PURE__ */ new Set();
     const requiredPluginAliases = /* @__PURE__ */ new Set();
     for (const pkg of packages) {
-      const buildPath = path7.join(pkg.packagePath, pkg.config.android?.sourceDir || "android", "build.gradle.kts");
-      if (!fs7.existsSync(buildPath)) continue;
-      const content = fs7.readFileSync(buildPath, "utf8");
+      const buildPath = path8.join(pkg.packagePath, pkg.config.android?.sourceDir || "android", "build.gradle.kts");
+      if (!fs8.existsSync(buildPath)) continue;
+      const content = fs8.readFileSync(buildPath, "utf8");
       for (const m of content.matchAll(/libs\.([\w.]+)/g)) {
         const alias = m[1];
         if (alias && alias in REQUIRED_CATALOG_ENTRIES) requiredAliases.add(alias);
@@ -2116,7 +2196,7 @@ ${generateActivityLifecycleKotlin(packages, projectPackage)}`;
       }
     }
     if (requiredAliases.size === 0 && requiredPluginAliases.size === 0) return;
-    let toml = fs7.readFileSync(libsTomlPath, "utf8");
+    let toml = fs8.readFileSync(libsTomlPath, "utf8");
     let updated = false;
     for (const alias of requiredAliases) {
       const entry = REQUIRED_CATALOG_ENTRIES[alias];
@@ -2140,14 +2220,14 @@ ${generateActivityLifecycleKotlin(packages, projectPackage)}`;
       updated = true;
     }
     if (updated) {
-      fs7.writeFileSync(libsTomlPath, toml);
+      fs8.writeFileSync(libsTomlPath, toml);
       console.log("\u2705 Synced version catalog (libs.versions.toml) for linked modules.");
     }
   }
   function ensureXElementDeps() {
-    const libsTomlPath = path7.join(appAndroidPath, "gradle", "libs.versions.toml");
-    if (fs7.existsSync(libsTomlPath)) {
-      let toml = fs7.readFileSync(libsTomlPath, "utf8");
+    const libsTomlPath = path8.join(appAndroidPath, "gradle", "libs.versions.toml");
+    if (fs8.existsSync(libsTomlPath)) {
+      let toml = fs8.readFileSync(libsTomlPath, "utf8");
       let updated = false;
       if (!toml.includes("lynx-xelement =")) {
         toml = toml.replace(
@@ -2159,13 +2239,13 @@ lynx-xelement-input = { module = "org.lynxsdk.lynx:xelement-input", version.ref
         updated = true;
       }
       if (updated) {
-        fs7.writeFileSync(libsTomlPath, toml);
+        fs8.writeFileSync(libsTomlPath, toml);
         console.log("\u2705 Added XElement entries to version catalog.");
       }
     }
-    const appBuildPath = path7.join(appAndroidPath, "app", "build.gradle.kts");
-    if (fs7.existsSync(appBuildPath)) {
-      let content = fs7.readFileSync(appBuildPath, "utf8");
+    const appBuildPath = path8.join(appAndroidPath, "app", "build.gradle.kts");
+    if (fs8.existsSync(appBuildPath)) {
+      let content = fs8.readFileSync(appBuildPath, "utf8");
       if (!content.includes("lynx.xelement")) {
         content = content.replace(
           /(implementation\(libs\.lynx\.service\.http\))/,
@@ -2173,15 +2253,15 @@ lynx-xelement-input = { module = "org.lynxsdk.lynx:xelement-input", version.ref
     implementation(libs.lynx.xelement)
     implementation(libs.lynx.xelement.input)`
         );
-        fs7.writeFileSync(appBuildPath, content);
+        fs8.writeFileSync(appBuildPath, content);
         console.log("\u2705 Added XElement dependencies to app build.gradle.kts.");
       }
     }
   }
   function ensureReleaseSigning() {
-    const appBuildPath = path7.join(appAndroidPath, "app", "build.gradle.kts");
-    if (!fs7.existsSync(appBuildPath)) return;
-    let content = fs7.readFileSync(appBuildPath, "utf8");
+    const appBuildPath = path8.join(appAndroidPath, "app", "build.gradle.kts");
+    if (!fs8.existsSync(appBuildPath)) return;
+    let content = fs8.readFileSync(appBuildPath, "utf8");
     if (content.includes('signingConfig = signingConfigs.getByName("debug")')) return;
     const releaseBlock = /(release\s*\{)([\s\S]*?)(\n        \}\s*\n(\s*\}|\s*compileOptions))/;
     const match = content.match(releaseBlock);
@@ -2192,13 +2272,13 @@ lynx-xelement-input = { module = "org.lynxsdk.lynx:xelement-input", version.ref
             signingConfig = signingConfigs.getByName("debug")
         $3`
       );
-      fs7.writeFileSync(appBuildPath, content);
+      fs8.writeFileSync(appBuildPath, content);
       console.log("\u2705 Set release signing to debug so installRelease works without a keystore.");
     }
   }
   function syncManifestPermissions(packages) {
-    const manifestPath = path7.join(appAndroidPath, "app", "src", "main", "AndroidManifest.xml");
-    if (!fs7.existsSync(manifestPath)) return;
+    const manifestPath = path8.join(appAndroidPath, "app", "src", "main", "AndroidManifest.xml");
+    if (!fs8.existsSync(manifestPath)) return;
     const allPermissions = /* @__PURE__ */ new Set();
     for (const pkg of packages) {
       const perms = pkg.config.android?.permissions;
@@ -2210,7 +2290,7 @@ lynx-xelement-input = { module = "org.lynxsdk.lynx:xelement-input", version.ref
       }
     }
     if (allPermissions.size === 0) return;
-    let manifest = fs7.readFileSync(manifestPath, "utf8");
+    let manifest = fs8.readFileSync(manifestPath, "utf8");
     const existingMatch = [...manifest.matchAll(/<uses-permission android:name="(android\.permission\.\w+)"\s*\/>/g)];
     const existing = new Set(existingMatch.map((m) => m[1]));
     const toAdd = [...allPermissions].filter((p) => !existing.has(p));
@@ -2221,7 +2301,7 @@ lynx-xelement-input = { module = "org.lynxsdk.lynx:xelement-input", version.ref
       `${newLines}
 $1$2`
     );
-    fs7.writeFileSync(manifestPath, manifest);
+    fs8.writeFileSync(manifestPath, manifest);
     console.log(`\u2705 Synced manifest permissions: ${toAdd.map((p) => p.split(".").pop()).join(", ")}`);
   }
   run();
@@ -2229,26 +2309,26 @@ $1$2`
 var autolink_default = autolink;
 // src/android/bundle.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import { execSync as execSync3 } from "child_process";
 // src/common/copyDistAssets.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 var SKIP = /* @__PURE__ */ new Set([".rspeedy", "stats.json"]);
 function copyDistAssets(distDir, destDir, bundleFile) {
-  if (!fs8.existsSync(distDir)) return;
-  for (const entry of fs8.readdirSync(distDir)) {
+  if (!fs9.existsSync(distDir)) return;
+  for (const entry of fs9.readdirSync(distDir)) {
     if (SKIP.has(entry)) continue;
-    const src = path8.join(distDir, entry);
-    const dest = path8.join(destDir, entry);
-    const stat = fs8.statSync(src);
+    const src = path9.join(distDir, entry);
+    const dest = path9.join(destDir, entry);
+    const stat = fs9.statSync(src);
     if (stat.isDirectory()) {
-      fs8.mkdirSync(dest, { recursive: true });
+      fs9.mkdirSync(dest, { recursive: true });
       copyDistAssets(src, dest, bundleFile);
     } else {
-      fs8.copyFileSync(src, dest);
+      fs9.copyFileSync(src, dest);
       if (entry !== bundleFile) {
         console.log(`\u2728 Copied asset: ${entry}`);
       }
@@ -2257,8 +2337,8 @@ function copyDistAssets(distDir, destDir, bundleFile) {
 }
 // src/common/tsconfigUtils.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 function stripJsonCommentsAndTrailingCommas(str) {
   return str.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/,\s*([\]}])/g, "$1");
 }
@@ -2270,19 +2350,19 @@ function parseTsconfigJson(raw) {
   }
 }
 function readTsconfig(filePath) {
-  if (!fs9.existsSync(filePath)) return null;
+  if (!fs10.existsSync(filePath)) return null;
   try {
-    return parseTsconfigJson(fs9.readFileSync(filePath, "utf-8"));
+    return parseTsconfigJson(fs10.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function resolveExtends(tsconfig, dir) {
   if (!tsconfig.extends) return tsconfig;
-  const basePath = path9.resolve(dir, tsconfig.extends);
+  const basePath = path10.resolve(dir, tsconfig.extends);
   const base = readTsconfig(basePath);
   if (!base) return tsconfig;
-  const baseDir = path9.dirname(basePath);
+  const baseDir = path10.dirname(basePath);
   const resolved = resolveExtends(base, baseDir);
   return {
     ...resolved,
@@ -2291,13 +2371,13 @@ function resolveExtends(tsconfig, dir) {
   };
 }
 function fixTsconfigReferencesForBuild(tsconfigPath) {
-  const dir = path9.dirname(tsconfigPath);
+  const dir = path10.dirname(tsconfigPath);
   const tsconfig = readTsconfig(tsconfigPath);
   if (!tsconfig?.references?.length) return false;
   const refsWithNoEmit = [];
   for (const ref of tsconfig.references) {
-    const refPath = path9.resolve(dir, ref.path);
-    const refConfigPath = refPath.endsWith(".json") ? refPath : path9.join(refPath, "tsconfig.json");
+    const refPath = path10.resolve(dir, ref.path);
+    const refConfigPath = refPath.endsWith(".json") ? refPath : path10.join(refPath, "tsconfig.json");
     const refConfig = readTsconfig(refConfigPath);
     if (refConfig?.compilerOptions?.noEmit === true) {
       refsWithNoEmit.push(refConfigPath);
@@ -2312,16 +2392,16 @@ function fixTsconfigReferencesForBuild(tsconfigPath) {
   const includes = [];
   const compilerOpts = { ...tsconfig.compilerOptions };
   for (const ref of tsconfig.references) {
-    const refPath = path9.resolve(dir, ref.path);
-    const refConfigPath = refPath.endsWith(".json") ? refPath : path9.join(refPath, "tsconfig.json");
+    const refPath = path10.resolve(dir, ref.path);
+    const refConfigPath = refPath.endsWith(".json") ? refPath : path10.join(refPath, "tsconfig.json");
     const refConfig = readTsconfig(refConfigPath);
     if (!refConfig) continue;
-    const refDir = path9.dirname(refConfigPath);
+    const refDir = path10.dirname(refConfigPath);
     const resolved = resolveExtends(refConfig, refDir);
     const inc = resolved.include;
     if (inc) {
       const arr = Array.isArray(inc) ? inc : [inc];
-      const baseDir = path9.relative(dir, refDir);
+      const baseDir = path10.relative(dir, refDir);
       for (const p of arr) {
         const clean = typeof p === "string" && p.startsWith("./") ? p.slice(2) : p;
         includes.push(!baseDir || baseDir === "." ? clean : `${baseDir}/${clean}`);
@@ -2339,7 +2419,7 @@ function fixTsconfigReferencesForBuild(tsconfigPath) {
   if (includes.length > 0) merged.include = [...new Set(includes)];
   compilerOpts.noEmit = true;
   merged.compilerOptions = compilerOpts;
-  fs9.writeFileSync(tsconfigPath, JSON.stringify(merged, null, 2));
+  fs10.writeFileSync(tsconfigPath, JSON.stringify(merged, null, 2));
   return true;
 }
 function addTamerTypesInclude(tsconfigPath, tamerTypesInclude) {
@@ -2350,23 +2430,23 @@ function addTamerTypesInclude(tsconfigPath, tamerTypesInclude) {
   if (arr.some((p) => (typeof p === "string" ? p : "").includes("tamer-"))) return false;
   arr.push(tamerTypesInclude);
   tsconfig.include = arr;
-  fs9.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+  fs10.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
   return true;
 }
 // src/android/syncDevClient.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 function readAndSubstituteTemplate2(templatePath, vars) {
-  const raw = fs10.readFileSync(templatePath, "utf-8");
+  const raw = fs11.readFileSync(templatePath, "utf-8");
   return Object.entries(vars).reduce(
     (s, [k, v]) => s.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v),
     raw
   );
 }
 function patchAppLogService(appPath) {
-  if (!fs10.existsSync(appPath)) return;
-  const raw = fs10.readFileSync(appPath, "utf-8");
+  if (!fs11.existsSync(appPath)) return;
+  const raw = fs11.readFileSync(appPath, "utf-8");
   const patched = raw.replace(
     /private void initLynxService\(\)\s*\{[\s\S]*?\n\s*}\s*\n\s*private void initFresco\(\)/,
     `private void initLynxService() {
@@ -2385,7 +2465,7 @@ function patchAppLogService(appPath) {
   private void initFresco()`
   );
   if (patched !== raw) {
-    fs10.writeFileSync(appPath, patched);
+    fs11.writeFileSync(appPath, patched);
   }
 }
 async function syncDevClient(opts) {
@@ -2400,9 +2480,9 @@ async function syncDevClient(opts) {
   const packageName = config.android?.packageName;
   const appName = config.android?.appName;
   const packagePath = packageName.replace(/\./g, "/");
-  const javaDir = path10.join(rootDir, "app", "src", "main", "java", packagePath);
-  const kotlinDir = path10.join(rootDir, "app", "src", "main", "kotlin", packagePath);
-  if (!fs10.existsSync(javaDir) || !fs10.existsSync(kotlinDir)) {
+  const javaDir = path11.join(rootDir, "app", "src", "main", "java", packagePath);
+  const kotlinDir = path11.join(rootDir, "app", "src", "main", "kotlin", packagePath);
+  if (!fs11.existsSync(javaDir) || !fs11.existsSync(kotlinDir)) {
     console.error("\u274C Android project not found. Run `tamer android create` first.");
     process.exit(1);
   }
@@ -2418,14 +2498,14 @@ async function syncDevClient(opts) {
   const [templateProviderSource] = await Promise.all([
     fetchAndPatchTemplateProvider(vars)
   ]);
-  fs10.writeFileSync(path10.join(javaDir, "TemplateProvider.java"), templateProviderSource);
-  fs10.writeFileSync(path10.join(kotlinDir, "MainActivity.kt"), getStandaloneMainActivity(vars));
-  patchAppLogService(path10.join(javaDir, "App.java"));
-  const appDir = path10.join(rootDir, "app");
-  const mainDir = path10.join(appDir, "src", "main");
-  const manifestPath = path10.join(mainDir, "AndroidManifest.xml");
+  fs11.writeFileSync(path11.join(javaDir, "TemplateProvider.java"), templateProviderSource);
+  fs11.writeFileSync(path11.join(kotlinDir, "MainActivity.kt"), getStandaloneMainActivity(vars));
+  patchAppLogService(path11.join(javaDir, "App.java"));
+  const appDir = path11.join(rootDir, "app");
+  const mainDir = path11.join(appDir, "src", "main");
+  const manifestPath = path11.join(mainDir, "AndroidManifest.xml");
   if (hasDevClient) {
-    const templateDir = path10.join(devClientPkg, "android", "templates");
+    const templateDir = path11.join(devClientPkg, "android", "templates");
     const templateVars = { PACKAGE_NAME: packageName, APP_NAME: appName };
     const devClientFiles = [
       "DevClientManager.kt",
@@ -2434,13 +2514,13 @@ async function syncDevClient(opts) {
       "PortraitCaptureActivity.kt"
     ];
     for (const f of devClientFiles) {
-      const src = path10.join(templateDir, f);
-      if (fs10.existsSync(src)) {
+      const src = path11.join(templateDir, f);
+      if (fs11.existsSync(src)) {
         const content = readAndSubstituteTemplate2(src, templateVars);
-        fs10.writeFileSync(path10.join(kotlinDir, f), content);
+        fs11.writeFileSync(path11.join(kotlinDir, f), content);
       }
     }
-    let manifest = fs10.readFileSync(manifestPath, "utf-8");
+    let manifest = fs11.readFileSync(manifestPath, "utf-8");
     const projectActivityEntry = '        <activity android:name=".ProjectActivity" android:exported="false" android:taskAffinity="" android:launchMode="singleTask" android:documentLaunchMode="always" android:windowSoftInputMode="adjustResize" />';
     const portraitCaptureEntry = '        <activity android:name=".PortraitCaptureActivity" android:screenOrientation="portrait" android:stateNotNeeded="true" android:theme="@style/zxing_CaptureTheme" android:windowSoftInputMode="stateAlwaysHidden" />';
     if (!manifest.includes("ProjectActivity")) {
@@ -2462,16 +2542,16 @@ $1$2`);
         '$1 android:windowSoftInputMode="adjustResize"$2'
       );
     }
-    fs10.writeFileSync(manifestPath, manifest);
+    fs11.writeFileSync(manifestPath, manifest);
     console.log("\u2705 Synced dev client (TemplateProvider, MainActivity, ProjectActivity, DevClientManager)");
   } else {
     for (const f of ["DevClientManager.kt", "DevServerPrefs.kt", "ProjectActivity.kt", "PortraitCaptureActivity.kt", "DevLauncherActivity.kt"]) {
       try {
-        fs10.rmSync(path10.join(kotlinDir, f));
+        fs11.rmSync(path11.join(kotlinDir, f));
       } catch {
       }
     }
-    let manifest = fs10.readFileSync(manifestPath, "utf-8");
+    let manifest = fs11.readFileSync(manifestPath, "utf-8");
     manifest = manifest.replace(/\s*<activity android:name="\.ProjectActivity"[^\/]*\/>\n?/g, "");
     manifest = manifest.replace(/\s*<activity android:name="\.PortraitCaptureActivity"[^\/]*\/>\n?/g, "");
     const mainActivityTag = manifest.match(/<activity[^>]*android:name="\.MainActivity"[^>]*>/);
@@ -2481,7 +2561,7 @@ $1$2`);
         '$1 android:windowSoftInputMode="adjustResize"$2'
       );
     }
-    fs10.writeFileSync(manifestPath, manifest);
+    fs11.writeFileSync(manifestPath, manifest);
     console.log("\u2705 Synced (dev client disabled - use -d for debug build with dev client)");
   }
 }
@@ -2505,15 +2585,15 @@ async function bundleAndDeploy(opts = {}) {
   await syncDevClient_default({ includeDevClient });
   const iconPaths = resolveIconPaths(projectRoot, resolved.config);
   if (iconPaths) {
-    const resDir = path11.join(resolved.androidAppDir, "src", "main", "res");
+    const resDir = path12.join(resolved.androidAppDir, "src", "main", "res");
     if (applyAndroidLauncherIcons(resDir, iconPaths)) {
       console.log("\u2705 Synced Android launcher icon(s) from tamer.config.json");
-      ensureAndroidManifestLauncherIcon(path11.join(resolved.androidAppDir, "src", "main", "AndroidManifest.xml"));
+      ensureAndroidManifestLauncherIcon(path12.join(resolved.androidAppDir, "src", "main", "AndroidManifest.xml"));
     }
   }
   try {
-    const lynxTsconfig = path11.join(lynxProjectDir, "tsconfig.json");
-    if (fs11.existsSync(lynxTsconfig)) {
+    const lynxTsconfig = path12.join(lynxProjectDir, "tsconfig.json");
+    if (fs12.existsSync(lynxTsconfig)) {
       fixTsconfigReferencesForBuild(lynxTsconfig);
     }
     console.log("\u{1F4E6} Building Lynx bundle...");
@@ -2523,8 +2603,8 @@ async function bundleAndDeploy(opts = {}) {
     console.error("\u274C Build process failed.");
     process.exit(1);
   }
-  if (includeDevClient && devClientBundlePath && !fs11.existsSync(devClientBundlePath)) {
-    const devClientDir = path11.dirname(path11.dirname(devClientBundlePath));
+  if (includeDevClient && devClientBundlePath && !fs12.existsSync(devClientBundlePath)) {
+    const devClientDir = path12.dirname(path12.dirname(devClientBundlePath));
     try {
       console.log("\u{1F4E6} Building dev launcher (tamer-dev-client)...");
       execSync3("npm run build", { stdio: "inherit", cwd: devClientDir });
@@ -2535,22 +2615,22 @@ async function bundleAndDeploy(opts = {}) {
     }
   }
   try {
-    fs11.mkdirSync(destinationDir, { recursive: true });
+    fs12.mkdirSync(destinationDir, { recursive: true });
     if (release) {
-      const devClientAsset = path11.join(destinationDir, "dev-client.lynx.bundle");
-      if (fs11.existsSync(devClientAsset)) {
-        fs11.rmSync(devClientAsset);
+      const devClientAsset = path12.join(destinationDir, "dev-client.lynx.bundle");
+      if (fs12.existsSync(devClientAsset)) {
+        fs12.rmSync(devClientAsset);
         console.log(`\u2728 Removed dev-client.lynx.bundle from assets (production build)`);
       }
-    } else if (includeDevClient && devClientBundlePath && fs11.existsSync(devClientBundlePath)) {
-      fs11.copyFileSync(devClientBundlePath, path11.join(destinationDir, "dev-client.lynx.bundle"));
+    } else if (includeDevClient && devClientBundlePath && fs12.existsSync(devClientBundlePath)) {
+      fs12.copyFileSync(devClientBundlePath, path12.join(destinationDir, "dev-client.lynx.bundle"));
       console.log(`\u2728 Copied dev-client.lynx.bundle to assets`);
     }
-    if (!fs11.existsSync(lynxBundlePath)) {
+    if (!fs12.existsSync(lynxBundlePath)) {
       console.error(`\u274C Build output not found at: ${lynxBundlePath}`);
       process.exit(1);
     }
-    const distDir = path11.dirname(lynxBundlePath);
+    const distDir = path12.dirname(lynxBundlePath);
     copyDistAssets(distDir, destinationDir, resolved.lynxBundleFile);
     console.log(`\u2728 Copied ${resolved.lynxBundleFile} to assets`);
   } catch (error) {
@@ -2561,7 +2641,7 @@ async function bundleAndDeploy(opts = {}) {
 var bundle_default = bundleAndDeploy;
 // src/android/build.ts
-import path12 from "path";
+import path13 from "path";
 import { execSync as execSync4 } from "child_process";
 async function buildApk(opts = {}) {
   let resolved;
@@ -2573,7 +2653,7 @@ async function buildApk(opts = {}) {
   const release = opts.release === true || opts.production === true;
   await bundle_default({ release, production: opts.production });
   const androidDir = resolved.androidDir;
-  const gradlew = path12.join(androidDir, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+  const gradlew = path13.join(androidDir, process.platform === "win32" ? "gradlew.bat" : "gradlew");
   const variant = release ? "Release" : "Debug";
   const task = opts.install ? `install${variant}` : `assemble${variant}`;
   console.log(`
@@ -2598,13 +2678,13 @@ async function buildApk(opts = {}) {
 var build_default = buildApk;
 // src/ios/create.ts
-import fs13 from "fs";
-import path14 from "path";
+import fs14 from "fs";
+import path15 from "path";
 // src/ios/getPod.ts
 import { execSync as execSync5 } from "child_process";
-import fs12 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path14 from "path";
 function isCocoaPodsInstalled() {
   try {
     execSync5("command -v pod >/dev/null 2>&1");
@@ -2626,8 +2706,8 @@ async function setupCocoaPods(rootDir) {
   }
   try {
     console.log("\u{1F4E6} CocoaPods is installed. Proceeding with dependency installation...");
-    const podfilePath = path13.join(rootDir, "Podfile");
-    if (!fs12.existsSync(podfilePath)) {
+    const podfilePath = path14.join(rootDir, "Podfile");
+    if (!fs13.existsSync(podfilePath)) {
       throw new Error(`Podfile not found at ${podfilePath}`);
     }
     console.log(`\u{1F680} Executing pod install in: ${rootDir}`);
@@ -2653,7 +2733,7 @@ async function setupCocoaPods(rootDir) {
 // src/ios/create.ts
 import { randomBytes } from "crypto";
 function readAndSubstituteTemplate3(templatePath, vars) {
-  const raw = fs13.readFileSync(templatePath, "utf-8");
+  const raw = fs14.readFileSync(templatePath, "utf-8");
   return Object.entries(vars).reduce(
     (s, [k, v]) => s.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v),
     raw
@@ -2676,17 +2756,17 @@ var create2 = () => {
     process.exit(1);
   }
   const iosDir = config.paths?.iosDir ?? "ios";
-  const rootDir = path14.join(process.cwd(), iosDir);
-  const projectDir = path14.join(rootDir, appName);
-  const xcodeprojDir = path14.join(rootDir, `${appName}.xcodeproj`);
+  const rootDir = path15.join(process.cwd(), iosDir);
+  const projectDir = path15.join(rootDir, appName);
+  const xcodeprojDir = path15.join(rootDir, `${appName}.xcodeproj`);
   const bridgingHeader = `${appName}-Bridging-Header.h`;
   function writeFile2(filePath, content) {
-    fs13.mkdirSync(path14.dirname(filePath), { recursive: true });
-    fs13.writeFileSync(filePath, content.trimStart(), "utf8");
+    fs14.mkdirSync(path15.dirname(filePath), { recursive: true });
+    fs14.writeFileSync(filePath, content.trimStart(), "utf8");
   }
-  if (fs13.existsSync(rootDir)) {
+  if (fs14.existsSync(rootDir)) {
     console.log(`\u{1F9F9} Removing existing directory: ${rootDir}`);
-    fs13.rmSync(rootDir, { recursive: true, force: true });
+    fs14.rmSync(rootDir, { recursive: true, force: true });
   }
   console.log(`\u{1F680} Creating a new Tamer4Lynx project in: ${rootDir}`);
   const ids = {
@@ -2722,9 +2802,11 @@ var create2 = () => {
     targetDebugConfig: generateId(),
     targetReleaseConfig: generateId()
   };
-  writeFile2(path14.join(rootDir, "Podfile"), `
+  writeFile2(path15.join(rootDir, "Podfile"), `
 source 'https://cdn.cocoapods.org/'
+install! 'cocoapods', :incremental_installation => true, :generate_multiple_pod_projects => true
 platform :ios, '13.0'
 target '${appName}' do
@@ -2807,15 +2889,15 @@ end
   const hostPkg = findTamerHostPackage(process.cwd());
   const templateVars = { PACKAGE_NAME: bundleId, APP_NAME: appName, BUNDLE_ID: bundleId };
   if (hostPkg) {
-    const templateDir = path14.join(hostPkg, "ios", "templates");
+    const templateDir = path15.join(hostPkg, "ios", "templates");
     for (const f of ["AppDelegate.swift", "SceneDelegate.swift", "ViewController.swift", "LynxProvider.swift", "LynxInitProcessor.swift"]) {
-      const srcPath = path14.join(templateDir, f);
-      if (fs13.existsSync(srcPath)) {
-        writeFile2(path14.join(projectDir, f), readAndSubstituteTemplate3(srcPath, templateVars));
+      const srcPath = path15.join(templateDir, f);
+      if (fs14.existsSync(srcPath)) {
+        writeFile2(path15.join(projectDir, f), readAndSubstituteTemplate3(srcPath, templateVars));
       }
     }
   } else {
-    writeFile2(path14.join(projectDir, "AppDelegate.swift"), `
+    writeFile2(path15.join(projectDir, "AppDelegate.swift"), `
 import UIKit
 @UIApplicationMain
@@ -2830,7 +2912,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
   }
 }
 	`);
-    writeFile2(path14.join(projectDir, "SceneDelegate.swift"), `
+    writeFile2(path15.join(projectDir, "SceneDelegate.swift"), `
 import UIKit
 class SceneDelegate: UIResponder, UIWindowSceneDelegate {
@@ -2844,7 +2926,7 @@ class SceneDelegate: UIResponder, UIWindowSceneDelegate {
   }
 }
 	`);
-    writeFile2(path14.join(projectDir, "ViewController.swift"), `
+    writeFile2(path15.join(projectDir, "ViewController.swift"), `
 import UIKit
 import Lynx
 import tamerinsets
@@ -2917,7 +2999,7 @@ class ViewController: UIViewController {
   }
 }
 	`);
-    writeFile2(path14.join(projectDir, "LynxProvider.swift"), `
+    writeFile2(path15.join(projectDir, "LynxProvider.swift"), `
 import Foundation
 class LynxProvider: NSObject, LynxTemplateProvider {
@@ -2936,7 +3018,7 @@ class LynxProvider: NSObject, LynxTemplateProvider {
     }
 }
 	`);
-    writeFile2(path14.join(projectDir, "LynxInitProcessor.swift"), `
+    writeFile2(path15.join(projectDir, "LynxInitProcessor.swift"), `
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
@@ -2976,7 +3058,7 @@ final class LynxInitProcessor {
 }
 	`);
   }
-  writeFile2(path14.join(projectDir, bridgingHeader), `
+  writeFile2(path15.join(projectDir, bridgingHeader), `
 #import <Lynx/LynxConfig.h>
 #import <Lynx/LynxEnv.h>
 #import <Lynx/LynxTemplateProvider.h>
@@ -2985,7 +3067,7 @@ final class LynxInitProcessor {
 #import <SDWebImage/SDWebImage.h>
 #import <SDWebImageWebPCoder/SDWebImageWebPCoder.h>
 	`);
-  writeFile2(path14.join(projectDir, "Info.plist"), `
+  writeFile2(path15.join(projectDir, "Info.plist"), `
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -3043,21 +3125,21 @@ final class LynxInitProcessor {
 </dict>
 </plist>
 	`);
-  const appIconDir = path14.join(projectDir, "Assets.xcassets", "AppIcon.appiconset");
-  fs13.mkdirSync(appIconDir, { recursive: true });
+  const appIconDir = path15.join(projectDir, "Assets.xcassets", "AppIcon.appiconset");
+  fs14.mkdirSync(appIconDir, { recursive: true });
   const iconPaths = resolveIconPaths(process.cwd(), config);
   if (applyIosAppIconAssets(appIconDir, iconPaths)) {
     console.log(iconPaths?.ios ? "\u2705 Copied iOS icon from tamer.config.json icon.ios" : "\u2705 Copied app icon from tamer.config.json icon.source");
   } else {
-    writeFile2(path14.join(appIconDir, "Contents.json"), `
+    writeFile2(path15.join(appIconDir, "Contents.json"), `
 {
   "images" : [ { "idiom" : "universal", "platform" : "ios", "size" : "1024x1024" } ],
   "info" : { "author" : "xcode", "version" : 1 }
 }
 	`);
   }
-  fs13.mkdirSync(xcodeprojDir, { recursive: true });
-  writeFile2(path14.join(xcodeprojDir, "project.pbxproj"), `
+  fs14.mkdirSync(xcodeprojDir, { recursive: true });
+  writeFile2(path15.join(xcodeprojDir, "project.pbxproj"), `
 // !$*UTF8*$!
 {
 	archiveVersion = 1;
@@ -3343,8 +3425,8 @@ final class LynxInitProcessor {
 var create_default2 = create2;
 // src/ios/autolink.ts
-import fs15 from "fs";
-import path16 from "path";
+import fs16 from "fs";
+import path17 from "path";
 import { execSync as execSync6 } from "child_process";
 // src/common/hostNativeModulesManifest.ts
@@ -3355,8 +3437,8 @@ function buildHostNativeModulesManifestJson(moduleClassNames) {
 }
 // src/ios/syncHost.ts
-import fs14 from "fs";
-import path15 from "path";
+import fs15 from "fs";
+import path16 from "path";
 import crypto from "crypto";
 function deterministicUUID(seed) {
   return crypto.createHash("sha256").update(seed).digest("hex").substring(0, 24).toUpperCase();
@@ -3404,7 +3486,7 @@ function getLaunchScreenStoryboard() {
 `;
 }
 function addLaunchScreenToXcodeProject(pbxprojPath, appName) {
-  let content = fs14.readFileSync(pbxprojPath, "utf8");
+  let content = fs15.readFileSync(pbxprojPath, "utf8");
   if (content.includes("LaunchScreen.storyboard")) return;
   const baseFileRefUUID = deterministicUUID(`launchScreenBase:${appName}`);
   const variantGroupUUID = deterministicUUID(`launchScreenGroup:${appName}`);
@@ -3441,11 +3523,11 @@ function addLaunchScreenToXcodeProject(pbxprojPath, appName) {
   );
   content = content.replace(groupPattern, `$1
 				${variantGroupUUID} /* LaunchScreen.storyboard */,`);
-  fs14.writeFileSync(pbxprojPath, content, "utf8");
+  fs15.writeFileSync(pbxprojPath, content, "utf8");
   console.log("\u2705 Registered LaunchScreen.storyboard in Xcode project");
 }
 function addSwiftSourceToXcodeProject(pbxprojPath, appName, filename) {
-  let content = fs14.readFileSync(pbxprojPath, "utf8");
+  let content = fs15.readFileSync(pbxprojPath, "utf8");
   const escaped = filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   if (new RegExp(`path = "?${escaped}"?;`).test(content)) return;
   const fileRefUUID = deterministicUUID(`fileRef:${appName}:${filename}`);
@@ -3470,11 +3552,11 @@ function addSwiftSourceToXcodeProject(pbxprojPath, appName, filename) {
   );
   content = content.replace(groupPattern, `$1
 				${fileRefUUID} /* ${filename} */,`);
-  fs14.writeFileSync(pbxprojPath, content, "utf8");
+  fs15.writeFileSync(pbxprojPath, content, "utf8");
   console.log(`\u2705 Registered ${filename} in Xcode project sources`);
 }
 function addResourceToXcodeProject(pbxprojPath, appName, filename) {
-  let content = fs14.readFileSync(pbxprojPath, "utf8");
+  let content = fs15.readFileSync(pbxprojPath, "utf8");
   const escaped = filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   if (new RegExp(`path = "?${escaped}"?;`).test(content)) return;
   const fileRefUUID = deterministicUUID(`fileRef:${appName}:${filename}`);
@@ -3499,12 +3581,12 @@ function addResourceToXcodeProject(pbxprojPath, appName, filename) {
   );
   content = content.replace(groupPattern, `$1
 				${fileRefUUID} /* ${filename} */,`);
-  fs14.writeFileSync(pbxprojPath, content, "utf8");
+  fs15.writeFileSync(pbxprojPath, content, "utf8");
   console.log(`\u2705 Registered ${filename} in Xcode project resources`);
 }
 function writeFile(filePath, content) {
-  fs14.mkdirSync(path15.dirname(filePath), { recursive: true });
-  fs14.writeFileSync(filePath, content, "utf8");
+  fs15.mkdirSync(path16.dirname(filePath), { recursive: true });
+  fs15.writeFileSync(filePath, content, "utf8");
 }
 function getAppDelegateSwift() {
   return `import UIKit
@@ -3721,8 +3803,8 @@ class ViewController: UIViewController {
 `;
 }
 function patchInfoPlist(infoPlistPath) {
-  if (!fs14.existsSync(infoPlistPath)) return;
-  let content = fs14.readFileSync(infoPlistPath, "utf8");
+  if (!fs15.existsSync(infoPlistPath)) return;
+  let content = fs15.readFileSync(infoPlistPath, "utf8");
   content = content.replace(/\s*<key>UIMainStoryboardFile<\/key>\s*<string>[^<]*<\/string>/g, "");
   if (!content.includes("UILaunchStoryboardName")) {
     content = content.replace("</dict>\n</plist>", `	<key>UILaunchStoryboardName</key>
@@ -3754,7 +3836,7 @@ function patchInfoPlist(infoPlistPath) {
 </plist>`);
     console.log("\u2705 Added UIApplicationSceneManifest to Info.plist");
   }
-  fs14.writeFileSync(infoPlistPath, content, "utf8");
+  fs15.writeFileSync(infoPlistPath, content, "utf8");
 }
 function getSimpleLynxProviderSwift() {
   return `import Foundation
@@ -3779,9 +3861,9 @@ class LynxProvider: NSObject, LynxTemplateProvider {
 }
 function readTemplateOrFallback(devClientPkg, templateName, fallback, vars = {}) {
   if (devClientPkg) {
-    const tplPath = path15.join(devClientPkg, "ios", "templates", templateName);
-    if (fs14.existsSync(tplPath)) {
-      let content = fs14.readFileSync(tplPath, "utf8");
+    const tplPath = path16.join(devClientPkg, "ios", "templates", templateName);
+    if (fs15.existsSync(tplPath)) {
+      let content = fs15.readFileSync(tplPath, "utf8");
       for (const [k, v] of Object.entries(vars)) {
         content = content.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v);
       }
@@ -3799,19 +3881,19 @@ function syncHostIos(opts) {
   if (!appName) {
     throw new Error('"ios.appName" must be defined in tamer.config.json');
   }
-  const projectDir = path15.join(resolved.iosDir, appName);
-  const infoPlistPath = path15.join(projectDir, "Info.plist");
-  if (!fs14.existsSync(projectDir)) {
+  const projectDir = path16.join(resolved.iosDir, appName);
+  const infoPlistPath = path16.join(projectDir, "Info.plist");
+  if (!fs15.existsSync(projectDir)) {
     throw new Error(`iOS project not found at ${projectDir}. Run \`tamer ios create\` first.`);
   }
-  const pbxprojPath = path15.join(resolved.iosDir, `${appName}.xcodeproj`, "project.pbxproj");
-  const baseLprojDir = path15.join(projectDir, "Base.lproj");
-  const launchScreenPath = path15.join(baseLprojDir, "LaunchScreen.storyboard");
+  const pbxprojPath = path16.join(resolved.iosDir, `${appName}.xcodeproj`, "project.pbxproj");
+  const baseLprojDir = path16.join(projectDir, "Base.lproj");
+  const launchScreenPath = path16.join(baseLprojDir, "LaunchScreen.storyboard");
   patchInfoPlist(infoPlistPath);
-  writeFile(path15.join(projectDir, "AppDelegate.swift"), getAppDelegateSwift());
-  writeFile(path15.join(projectDir, "SceneDelegate.swift"), getSceneDelegateSwift());
-  if (!fs14.existsSync(launchScreenPath)) {
-    fs14.mkdirSync(baseLprojDir, { recursive: true });
+  writeFile(path16.join(projectDir, "AppDelegate.swift"), getAppDelegateSwift());
+  writeFile(path16.join(projectDir, "SceneDelegate.swift"), getSceneDelegateSwift());
+  if (!fs15.existsSync(launchScreenPath)) {
+    fs15.mkdirSync(baseLprojDir, { recursive: true });
     writeFile(launchScreenPath, getLaunchScreenStoryboard());
     addLaunchScreenToXcodeProject(pbxprojPath, appName);
   }
@@ -3820,33 +3902,33 @@ function syncHostIos(opts) {
     const devClientPkg2 = findDevClientPackage(resolved.projectRoot);
     const segment = resolved.lynxProjectDir.split("/").filter(Boolean).pop() ?? "";
     const tplVars = { PROJECT_BUNDLE_SEGMENT: segment };
-    writeFile(path15.join(projectDir, "ViewController.swift"), getDevViewControllerSwift());
-    writeFile(path15.join(projectDir, "LynxProvider.swift"), getSimpleLynxProviderSwift());
+    writeFile(path16.join(projectDir, "ViewController.swift"), getDevViewControllerSwift());
+    writeFile(path16.join(projectDir, "LynxProvider.swift"), getSimpleLynxProviderSwift());
     addSwiftSourceToXcodeProject(pbxprojPath, appName, "LynxProvider.swift");
     const devTPContent = readTemplateOrFallback(devClientPkg2, "DevTemplateProvider.swift", "", tplVars);
     if (devTPContent) {
-      writeFile(path15.join(projectDir, "DevTemplateProvider.swift"), devTPContent);
+      writeFile(path16.join(projectDir, "DevTemplateProvider.swift"), devTPContent);
       addSwiftSourceToXcodeProject(pbxprojPath, appName, "DevTemplateProvider.swift");
     }
     const projectVCContent = readTemplateOrFallback(devClientPkg2, "ProjectViewController.swift", "", tplVars);
     if (projectVCContent) {
-      writeFile(path15.join(projectDir, "ProjectViewController.swift"), projectVCContent);
+      writeFile(path16.join(projectDir, "ProjectViewController.swift"), projectVCContent);
       addSwiftSourceToXcodeProject(pbxprojPath, appName, "ProjectViewController.swift");
     }
     const devCMContent = readTemplateOrFallback(devClientPkg2, "DevClientManager.swift", "", tplVars);
     if (devCMContent) {
-      writeFile(path15.join(projectDir, "DevClientManager.swift"), devCMContent);
+      writeFile(path16.join(projectDir, "DevClientManager.swift"), devCMContent);
       addSwiftSourceToXcodeProject(pbxprojPath, appName, "DevClientManager.swift");
     }
     const qrContent = readTemplateOrFallback(devClientPkg2, "QRScannerViewController.swift", "", tplVars);
     if (qrContent) {
-      writeFile(path15.join(projectDir, "QRScannerViewController.swift"), qrContent);
+      writeFile(path16.join(projectDir, "QRScannerViewController.swift"), qrContent);
       addSwiftSourceToXcodeProject(pbxprojPath, appName, "QRScannerViewController.swift");
     }
     console.log("\u2705 Synced iOS host app (embedded dev mode) \u2014 ViewController, DevTemplateProvider, ProjectViewController, DevClientManager, QRScannerViewController");
   } else {
-    writeFile(path15.join(projectDir, "ViewController.swift"), getViewControllerSwift());
-    writeFile(path15.join(projectDir, "LynxProvider.swift"), getSimpleLynxProviderSwift());
+    writeFile(path16.join(projectDir, "ViewController.swift"), getViewControllerSwift());
+    writeFile(path16.join(projectDir, "LynxProvider.swift"), getSimpleLynxProviderSwift());
     addSwiftSourceToXcodeProject(pbxprojPath, appName, "LynxProvider.swift");
     console.log("\u2705 Synced iOS host app controller files");
   }
@@ -3854,7 +3936,7 @@ function syncHostIos(opts) {
 var syncHost_default = syncHostIos;
 // src/ios/autolink.ts
-var autolink2 = () => {
+var autolink2 = (syncHostOpts) => {
   let resolved;
   try {
     resolved = resolveHostPaths();
@@ -3865,11 +3947,11 @@ var autolink2 = () => {
   const projectRoot = resolved.projectRoot;
   const iosProjectPath = resolved.iosDir;
   function updateGeneratedSection(filePath, newContent, startMarker, endMarker) {
-    if (!fs15.existsSync(filePath)) {
+    if (!fs16.existsSync(filePath)) {
       console.warn(`\u26A0\uFE0F File not found, skipping update: ${filePath}`);
       return;
     }
-    let fileContent = fs15.readFileSync(filePath, "utf8");
+    let fileContent = fs16.readFileSync(filePath, "utf8");
     const escapedStartMarker = startMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const escapedEndMarker = endMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regex = new RegExp(`${escapedStartMarker}[\\s\\S]*?${escapedEndMarker}`, "g");
@@ -3889,33 +3971,33 @@ ${replacementBlock}
 `;
       }
     } else {
-      console.warn(`\u26A0\uFE0F Could not find autolink markers in ${path16.basename(filePath)}. Appending to the end of the file.`);
+      console.warn(`\u26A0\uFE0F Could not find autolink markers in ${path17.basename(filePath)}. Appending to the end of the file.`);
       fileContent += `
 ${replacementBlock}
 `;
     }
-    fs15.writeFileSync(filePath, fileContent, "utf8");
-    console.log(`\u2705 Updated autolinked section in ${path16.basename(filePath)}`);
+    fs16.writeFileSync(filePath, fileContent, "utf8");
+    console.log(`\u2705 Updated autolinked section in ${path17.basename(filePath)}`);
   }
   function resolvePodDirectory(pkg) {
-    const configuredDir = path16.join(pkg.packagePath, pkg.config.ios?.podspecPath || ".");
-    if (fs15.existsSync(configuredDir)) {
+    const configuredDir = path17.join(pkg.packagePath, pkg.config.ios?.podspecPath || ".");
+    if (fs16.existsSync(configuredDir)) {
       return configuredDir;
     }
-    const iosDir = path16.join(pkg.packagePath, "ios");
-    if (fs15.existsSync(iosDir)) {
+    const iosDir = path17.join(pkg.packagePath, "ios");
+    if (fs16.existsSync(iosDir)) {
       const stack = [iosDir];
       while (stack.length > 0) {
         const current = stack.pop();
         try {
-          const entries = fs15.readdirSync(current, { withFileTypes: true });
+          const entries = fs16.readdirSync(current, { withFileTypes: true });
           const podspec = entries.find((entry) => entry.isFile() && entry.name.endsWith(".podspec"));
           if (podspec) {
             return current;
           }
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              stack.push(path16.join(current, entry.name));
+              stack.push(path17.join(current, entry.name));
             }
           }
         } catch {
@@ -3926,9 +4008,9 @@ ${replacementBlock}
   }
   function resolvePodName(pkg) {
     const fullPodspecDir = resolvePodDirectory(pkg);
-    if (fs15.existsSync(fullPodspecDir)) {
+    if (fs16.existsSync(fullPodspecDir)) {
       try {
-        const files = fs15.readdirSync(fullPodspecDir);
+        const files = fs16.readdirSync(fullPodspecDir);
         const podspecFile = files.find((f) => f.endsWith(".podspec"));
         if (podspecFile) return podspecFile.replace(".podspec", "");
       } catch {
@@ -3937,13 +4019,13 @@ ${replacementBlock}
     return pkg.name.split("/").pop().replace(/-/g, "");
   }
   function updatePodfile(packages) {
-    const podfilePath = path16.join(iosProjectPath, "Podfile");
+    const podfilePath = path17.join(iosProjectPath, "Podfile");
     let scriptContent = `  # This section is automatically generated by Tamer4Lynx.
   # Manual edits will be overwritten.`;
     const iosPackages = packages.filter((p) => p.config.ios);
     if (iosPackages.length > 0) {
       iosPackages.forEach((pkg) => {
-        const relativePath = path16.relative(iosProjectPath, resolvePodDirectory(pkg));
+        const relativePath = path17.relative(iosProjectPath, resolvePodDirectory(pkg));
         const podName = resolvePodName(pkg);
         scriptContent += `
   pod '${podName}', :path => '${relativePath}'`;
@@ -3955,9 +4037,9 @@ ${replacementBlock}
     updateGeneratedSection(podfilePath, scriptContent.trim(), "# GENERATED AUTOLINK DEPENDENCIES START", "# GENERATED AUTOLINK DEPENDENCIES END");
   }
   function ensureXElementPod() {
-    const podfilePath = path16.join(iosProjectPath, "Podfile");
-    if (!fs15.existsSync(podfilePath)) return;
-    let content = fs15.readFileSync(podfilePath, "utf8");
+    const podfilePath = path17.join(iosProjectPath, "Podfile");
+    if (!fs16.existsSync(podfilePath)) return;
+    let content = fs16.readFileSync(podfilePath, "utf8");
     if (content.includes("pod 'XElement'")) return;
     const lynxVersionMatch = content.match(/pod\s+'Lynx',\s*'([^']+)'/);
     const lynxVersion = lynxVersionMatch?.[1] ?? "3.6.0";
@@ -3982,13 +4064,51 @@ ${replacementBlock}
 `;
       }
     }
-    fs15.writeFileSync(podfilePath, content, "utf8");
+    fs16.writeFileSync(podfilePath, content, "utf8");
     console.log(`\u2705 Added XElement pod (v${lynxVersion}) to Podfile`);
   }
+  function ensureLynxDevToolPods(packages) {
+    const hasDevClient = packages.some(
+      (p) => p.name === "@tamer4lynx/tamer-dev-client" || p.name === "tamer-dev-client"
+    );
+    if (!hasDevClient) return;
+    const podfilePath = path17.join(iosProjectPath, "Podfile");
+    if (!fs16.existsSync(podfilePath)) return;
+    let content = fs16.readFileSync(podfilePath, "utf8");
+    if (content.includes("pod 'LynxDevtool'") || content.includes('pod "LynxDevtool"')) return;
+    const lynxVersionMatch = content.match(/pod\s+'Lynx',\s*'([^']+)'/);
+    const lynxVersion = lynxVersionMatch?.[1] ?? "3.6.0";
+    if (!content.includes("'Devtool'") && !content.includes('"Devtool"')) {
+      content = content.replace(
+        /(\s+'Http',\s*\n)(\s*\])/,
+        "$1    'Devtool',\n$2"
+      );
+    }
+    const devtoolLine = `  pod 'LynxDevtool', '${lynxVersion}'
+  `;
+    if (content.includes("# GENERATED AUTOLINK DEPENDENCIES START")) {
+      content = content.replace(/(# GENERATED AUTOLINK DEPENDENCIES START)/, `${devtoolLine}$1`);
+    } else {
+      const insertAfter = /pod\s+'LynxService'[^\n]*(?:\n\s*'[^']*',?\s*)*\]\s*/;
+      const serviceMatch = content.match(insertAfter);
+      if (serviceMatch) {
+        const idx = serviceMatch.index + serviceMatch[0].length;
+        content = content.slice(0, idx) + `
+  pod 'LynxDevtool', '${lynxVersion}'` + content.slice(idx);
+      } else {
+        content += `
+  pod 'LynxDevtool', '${lynxVersion}'
+`;
+      }
+    }
+    fs16.writeFileSync(podfilePath, content, "utf8");
+    console.log(`\u2705 Added Lynx DevTool pods (v${lynxVersion}) to Podfile`);
+  }
   function ensureLynxPatchInPodfile() {
-    const podfilePath = path16.join(iosProjectPath, "Podfile");
-    if (!fs15.existsSync(podfilePath)) return;
-    let content = fs15.readFileSync(podfilePath, "utf8");
+    const podfilePath = path17.join(iosProjectPath, "Podfile");
+    if (!fs16.existsSync(podfilePath)) return;
+    let content = fs16.readFileSync(podfilePath, "utf8");
     if (content.includes("content.gsub(/\\btypeof\\(/, '__typeof__(')")) return;
     const patch = `
   Dir.glob(File.join(installer.sandbox.root, 'Lynx/platform/darwin/**/*.{m,mm}')).each do |lynx_source|
@@ -4000,13 +4120,13 @@ ${replacementBlock}
   end`;
     content = content.replace(/(\n  end\s*\n)(end\s*)$/, `$1${patch}
 $2`);
-    fs15.writeFileSync(podfilePath, content, "utf8");
+    fs16.writeFileSync(podfilePath, content, "utf8");
     console.log("\u2705 Added Lynx typeof patch to Podfile post_install.");
   }
   function ensurePodBuildSettings() {
-    const podfilePath = path16.join(iosProjectPath, "Podfile");
-    if (!fs15.existsSync(podfilePath)) return;
-    let content = fs15.readFileSync(podfilePath, "utf8");
+    const podfilePath = path17.join(iosProjectPath, "Podfile");
+    if (!fs16.existsSync(podfilePath)) return;
+    let content = fs16.readFileSync(podfilePath, "utf8");
     let changed = false;
     if (!content.includes("CLANG_ENABLE_EXPLICIT_MODULES")) {
       content = content.replace(
@@ -4049,7 +4169,7 @@ $2`);
       changed = true;
     }
     if (changed) {
-      fs15.writeFileSync(podfilePath, content, "utf8");
+      fs16.writeFileSync(podfilePath, content, "utf8");
       console.log("\u2705 Added Xcode compatibility build settings to Podfile post_install.");
     }
   }
@@ -4057,10 +4177,10 @@ $2`);
     const appNameFromConfig = resolved.config.ios?.appName;
     const candidatePaths = [];
     if (appNameFromConfig) {
-      candidatePaths.push(path16.join(iosProjectPath, appNameFromConfig, "LynxInitProcessor.swift"));
+      candidatePaths.push(path17.join(iosProjectPath, appNameFromConfig, "LynxInitProcessor.swift"));
     }
-    candidatePaths.push(path16.join(iosProjectPath, "LynxInitProcessor.swift"));
-    const found = candidatePaths.find((p) => fs15.existsSync(p));
+    candidatePaths.push(path17.join(iosProjectPath, "LynxInitProcessor.swift"));
+    const found = candidatePaths.find((p) => fs16.existsSync(p));
     const lynxInitPath = found ?? candidatePaths[0];
     const iosPackages = packages.filter((p) => getIosModuleClassNames(p.config.ios).length > 0 || Object.keys(getIosElements(p.config.ios)).length > 0);
     const seenModules = /* @__PURE__ */ new Set();
@@ -4099,7 +4219,7 @@ $2`);
         const podName = resolvePodName(pkg);
         return `import ${podName}`;
       }).join("\n");
-      const fileContent = fs15.readFileSync(filePath, "utf8");
+      const fileContent = fs16.readFileSync(filePath, "utf8");
       if (fileContent.indexOf(startMarker) !== -1) {
         updateGeneratedSection(filePath, imports, startMarker, endMarker);
         return;
@@ -4136,8 +4256,8 @@ ${after}`;
 ${fileContent}`;
         }
       }
-      fs15.writeFileSync(filePath, newContent, "utf8");
-      console.log(`\u2705 Updated imports in ${path16.basename(filePath)}`);
+      fs16.writeFileSync(filePath, newContent, "utf8");
+      console.log(`\u2705 Updated imports in ${path17.basename(filePath)}`);
     }
     updateImportsSection(lynxInitPath, importPackages);
     if (importPackages.length === 0) {
@@ -4181,7 +4301,7 @@ ${androidNames.map((n) => `            "${n.replace(/\\/g, "\\\\").replace(/"/g,
     } else {
       devClientSupportedBody = "        // @tamer4lynx/tamer-dev-client not linked";
     }
-    if (fs15.readFileSync(lynxInitPath, "utf8").includes("GENERATED DEV_CLIENT_SUPPORTED START")) {
+    if (fs16.readFileSync(lynxInitPath, "utf8").includes("GENERATED DEV_CLIENT_SUPPORTED START")) {
       updateGeneratedSection(lynxInitPath, devClientSupportedBody, "// GENERATED DEV_CLIENT_SUPPORTED START", "// GENERATED DEV_CLIENT_SUPPORTED END");
     }
   }
@@ -4189,13 +4309,13 @@ ${androidNames.map((n) => `            "${n.replace(/\\/g, "\\\\").replace(/"/g,
     const appNameFromConfig = resolved.config.ios?.appName;
     const candidates = [];
     if (appNameFromConfig) {
-      candidates.push(path16.join(iosProjectPath, appNameFromConfig, "Info.plist"));
+      candidates.push(path17.join(iosProjectPath, appNameFromConfig, "Info.plist"));
     }
-    candidates.push(path16.join(iosProjectPath, "Info.plist"));
-    return candidates.find((p) => fs15.existsSync(p)) ?? null;
+    candidates.push(path17.join(iosProjectPath, "Info.plist"));
+    return candidates.find((p) => fs16.existsSync(p)) ?? null;
   }
   function readPlistXml(plistPath) {
-    return fs15.readFileSync(plistPath, "utf8");
+    return fs16.readFileSync(plistPath, "utf8");
   }
   function syncInfoPlistPermissions(packages) {
     const plistPath = findInfoPlist();
@@ -4226,7 +4346,7 @@ ${androidNames.map((n) => `            "${n.replace(/\\/g, "\\\\").replace(/"/g,
       added++;
     }
     if (added > 0) {
-      fs15.writeFileSync(plistPath, plist, "utf8");
+      fs16.writeFileSync(plistPath, plist, "utf8");
       console.log(`\u2705 Synced ${added} Info.plist permission description(s)`);
     }
   }
@@ -4273,16 +4393,16 @@ ${schemesXml}
 $1`
       );
     }
-    fs15.writeFileSync(plistPath, plist, "utf8");
+    fs16.writeFileSync(plistPath, plist, "utf8");
     console.log(`\u2705 Synced ${urlSchemes.length} iOS URL scheme(s) into Info.plist`);
   }
   function runPodInstall(forcePath) {
-    const podfilePath = forcePath ?? path16.join(iosProjectPath, "Podfile");
-    if (!fs15.existsSync(podfilePath)) {
+    const podfilePath = forcePath ?? path17.join(iosProjectPath, "Podfile");
+    if (!fs16.existsSync(podfilePath)) {
       console.log("\u2139\uFE0F No Podfile found in ios directory; skipping `pod install`.");
       return;
     }
-    const cwd = path16.dirname(podfilePath);
+    const cwd = path17.dirname(podfilePath);
     try {
       console.log(`\u2139\uFE0F Running \`pod install\` in ${cwd}...`);
       try {
@@ -4305,9 +4425,10 @@ $1`
     } else {
       console.log("\u2139\uFE0F No Tamer4Lynx native packages found.");
     }
-    syncHost_default();
+    syncHost_default(syncHostOpts);
     updatePodfile(packages);
     ensureXElementPod();
+    ensureLynxDevToolPods(discoverModules(projectRoot));
     ensureLynxPatchInPodfile();
     ensurePodBuildSettings();
     updateLynxInitProcessor(packages);
@@ -4316,8 +4437,8 @@ $1`
     syncInfoPlistUrlSchemes();
     const appNameFromConfig = resolved.config.ios?.appName;
     if (appNameFromConfig) {
-      const appPodfile = path16.join(iosProjectPath, appNameFromConfig, "Podfile");
-      if (fs15.existsSync(appPodfile)) {
+      const appPodfile = path17.join(iosProjectPath, appNameFromConfig, "Podfile");
+      if (fs16.existsSync(appPodfile)) {
         runPodInstall(appPodfile);
         console.log("\u2728 Autolinking complete for iOS.");
         return;
@@ -4332,13 +4453,13 @@ $1`
     const appFolder = resolved.config.ios?.appName;
     if (!hasDevClient || !appFolder) return;
     const androidNames = getDedupedAndroidModuleClassNames(allPkgs);
-    const appDir = path16.join(iosProjectPath, appFolder);
-    fs15.mkdirSync(appDir, { recursive: true });
-    const manifestPath = path16.join(appDir, TAMER_HOST_NATIVE_MODULES_FILENAME);
-    fs15.writeFileSync(manifestPath, buildHostNativeModulesManifestJson(androidNames), "utf8");
+    const appDir = path17.join(iosProjectPath, appFolder);
+    fs16.mkdirSync(appDir, { recursive: true });
+    const manifestPath = path17.join(appDir, TAMER_HOST_NATIVE_MODULES_FILENAME);
+    fs16.writeFileSync(manifestPath, buildHostNativeModulesManifestJson(androidNames), "utf8");
     console.log(`\u2705 Wrote ${TAMER_HOST_NATIVE_MODULES_FILENAME} (native module ids for dev-client checks)`);
-    const pbxprojPath = path16.join(iosProjectPath, `${appFolder}.xcodeproj`, "project.pbxproj");
-    if (fs15.existsSync(pbxprojPath)) {
+    const pbxprojPath = path17.join(iosProjectPath, `${appFolder}.xcodeproj`, "project.pbxproj");
+    if (fs16.existsSync(pbxprojPath)) {
       addResourceToXcodeProject(pbxprojPath, appFolder, TAMER_HOST_NATIVE_MODULES_FILENAME);
     }
   }
@@ -4347,8 +4468,8 @@ $1`
 var autolink_default2 = autolink2;
 // src/ios/bundle.ts
-import fs16 from "fs";
-import path17 from "path";
+import fs17 from "fs";
+import path18 from "path";
 import { execSync as execSync7 } from "child_process";
 function bundleAndDeploy2(opts = {}) {
   const release = opts.release === true || opts.production === true;
@@ -4366,20 +4487,19 @@ function bundleAndDeploy2(opts = {}) {
   const includeDevClient = !release && !!devClientPkg;
   const appName = resolved.config.ios.appName;
   const sourceBundlePath = resolved.lynxBundlePath;
-  const destinationDir = path17.join(resolved.iosDir, appName);
-  const destinationBundlePath = path17.join(destinationDir, resolved.lynxBundleFile);
-  syncHost_default({ release, includeDevClient });
-  autolink_default2();
+  const destinationDir = path18.join(resolved.iosDir, appName);
+  const destinationBundlePath = path18.join(destinationDir, resolved.lynxBundleFile);
+  autolink_default2({ release, includeDevClient });
   const iconPaths = resolveIconPaths(resolved.projectRoot, resolved.config);
   if (iconPaths) {
-    const appIconDir = path17.join(destinationDir, "Assets.xcassets", "AppIcon.appiconset");
+    const appIconDir = path18.join(destinationDir, "Assets.xcassets", "AppIcon.appiconset");
     if (applyIosAppIconAssets(appIconDir, iconPaths)) {
       console.log("\u2705 Synced iOS AppIcon from tamer.config.json");
     }
   }
   try {
-    const lynxTsconfig = path17.join(resolved.lynxProjectDir, "tsconfig.json");
-    if (fs16.existsSync(lynxTsconfig)) {
+    const lynxTsconfig = path18.join(resolved.lynxProjectDir, "tsconfig.json");
+    if (fs17.existsSync(lynxTsconfig)) {
       fixTsconfigReferencesForBuild(lynxTsconfig);
     }
     console.log("\u{1F4E6} Building Lynx bundle...");
@@ -4390,40 +4510,40 @@ function bundleAndDeploy2(opts = {}) {
     process.exit(1);
   }
   try {
-    if (!fs16.existsSync(sourceBundlePath)) {
+    if (!fs17.existsSync(sourceBundlePath)) {
       console.error(`\u274C Build output not found at: ${sourceBundlePath}`);
       process.exit(1);
     }
-    if (!fs16.existsSync(destinationDir)) {
+    if (!fs17.existsSync(destinationDir)) {
       console.error(`Destination directory not found at: ${destinationDir}`);
       process.exit(1);
     }
-    const distDir = path17.dirname(sourceBundlePath);
+    const distDir = path18.dirname(sourceBundlePath);
     console.log(`\u{1F69A} Copying bundle and assets to iOS project...`);
     copyDistAssets(distDir, destinationDir, resolved.lynxBundleFile);
     console.log(`\u2728 Successfully copied bundle to: ${destinationBundlePath}`);
-    const pbxprojPath = path17.join(resolved.iosDir, `${appName}.xcodeproj`, "project.pbxproj");
-    if (fs16.existsSync(pbxprojPath)) {
+    const pbxprojPath = path18.join(resolved.iosDir, `${appName}.xcodeproj`, "project.pbxproj");
+    if (fs17.existsSync(pbxprojPath)) {
       const skip = /* @__PURE__ */ new Set([".rspeedy", "stats.json"]);
-      for (const entry of fs16.readdirSync(distDir)) {
-        if (skip.has(entry) || fs16.statSync(path17.join(distDir, entry)).isDirectory()) continue;
+      for (const entry of fs17.readdirSync(distDir)) {
+        if (skip.has(entry) || fs17.statSync(path18.join(distDir, entry)).isDirectory()) continue;
         addResourceToXcodeProject(pbxprojPath, appName, entry);
       }
     }
     if (includeDevClient && devClientPkg) {
-      const devClientBundle = path17.join(destinationDir, "dev-client.lynx.bundle");
+      const devClientBundle = path18.join(destinationDir, "dev-client.lynx.bundle");
       console.log("\u{1F4E6} Building dev-client bundle...");
       try {
         execSync7("npm run build", { stdio: "inherit", cwd: devClientPkg });
       } catch {
         console.warn("\u26A0\uFE0F  dev-client build failed; skipping dev-client bundle");
       }
-      const builtBundle = path17.join(devClientPkg, "dist", "dev-client.lynx.bundle");
-      if (fs16.existsSync(builtBundle)) {
-        fs16.copyFileSync(builtBundle, devClientBundle);
+      const builtBundle = path18.join(devClientPkg, "dist", "dev-client.lynx.bundle");
+      if (fs17.existsSync(builtBundle)) {
+        fs17.copyFileSync(builtBundle, devClientBundle);
         console.log("\u2728 Copied dev-client.lynx.bundle to iOS project");
-        const pbxprojPath2 = path17.join(resolved.iosDir, `${appName}.xcodeproj`, "project.pbxproj");
-        if (fs16.existsSync(pbxprojPath2)) {
+        const pbxprojPath2 = path18.join(resolved.iosDir, `${appName}.xcodeproj`, "project.pbxproj");
+        if (fs17.existsSync(pbxprojPath2)) {
           addResourceToXcodeProject(pbxprojPath2, appName, "dev-client.lynx.bundle");
         }
       }
@@ -4437,9 +4557,10 @@ function bundleAndDeploy2(opts = {}) {
 var bundle_default2 = bundleAndDeploy2;
 // src/ios/build.ts
-import fs17 from "fs";
-import path18 from "path";
+import fs18 from "fs";
+import path19 from "path";
 import os3 from "os";
+import { randomBytes as randomBytes2 } from "crypto";
 import { execSync as execSync8 } from "child_process";
 function hostArch() {
   return os3.arch() === "arm64" ? "arm64" : "x86_64";
@@ -4457,6 +4578,31 @@ function findBootedSimulator() {
   }
   return null;
 }
+function findFirstConnectedIosDeviceUdid() {
+  const jsonPath = path19.join(os3.tmpdir(), `t4l-devicectl-${randomBytes2(8).toString("hex")}.json`);
+  try {
+    execSync8(`xcrun devicectl list devices --json-output "${jsonPath}"`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (!fs18.existsSync(jsonPath)) return null;
+    const raw = fs18.readFileSync(jsonPath, "utf8");
+    fs18.unlinkSync(jsonPath);
+    const data = JSON.parse(raw);
+    const devices = data.result?.devices ?? [];
+    for (const d of devices) {
+      const udid = d.hardwareProperties?.udid ?? d.identifier;
+      if (typeof udid === "string" && udid.length >= 20) {
+        return udid;
+      }
+    }
+  } catch {
+    try {
+      if (fs18.existsSync(jsonPath)) fs18.unlinkSync(jsonPath);
+    } catch {
+    }
+  }
+  return null;
+}
 async function buildIpa(opts = {}) {
   const resolved = resolveHostPaths();
   if (!resolved.config.ios?.appName) {
@@ -4469,17 +4615,19 @@ async function buildIpa(opts = {}) {
   const configuration = release ? "Release" : "Debug";
   bundle_default2({ release, production: opts.production });
   const scheme = appName;
-  const workspacePath = path18.join(iosDir, `${appName}.xcworkspace`);
-  const projectPath = path18.join(iosDir, `${appName}.xcodeproj`);
-  const xcproject = fs17.existsSync(workspacePath) ? workspacePath : projectPath;
+  const workspacePath = path19.join(iosDir, `${appName}.xcworkspace`);
+  const projectPath = path19.join(iosDir, `${appName}.xcodeproj`);
+  const xcproject = fs18.existsSync(workspacePath) ? workspacePath : projectPath;
   const flag = xcproject.endsWith(".xcworkspace") ? "-workspace" : "-project";
-  const derivedDataPath = path18.join(iosDir, "build");
-  const sdk = opts.install ? "iphonesimulator" : "iphoneos";
-  const signingArgs = opts.install ? "" : " CODE_SIGNING_ALLOWED=NO CODE_SIGNING_REQUIRED=NO";
-  const archFlag = opts.install ? `-arch ${hostArch()} ` : "";
+  const derivedDataPath = path19.join(iosDir, "build");
+  const production = opts.production === true;
+  const sdk = production ? "iphoneos" : opts.install ? "iphonesimulator" : "iphoneos";
+  const signingArgs = production || opts.install ? "" : " CODE_SIGNING_ALLOWED=NO CODE_SIGNING_REQUIRED=NO";
+  const archFlag = opts.install && !production ? `-arch ${hostArch()} ` : "";
   const extraSettings = [
     "ONLY_ACTIVE_ARCH=YES",
-    "CLANG_ENABLE_EXPLICIT_MODULES=NO"
+    "CLANG_ENABLE_EXPLICIT_MODULES=NO",
+    ...configuration === "Debug" ? ["COMPILER_INDEX_STORE_ENABLE=NO"] : []
   ].join(" ");
   console.log(`
 \u{1F528} Building ${configuration} (${sdk})...`);
@@ -4489,38 +4637,77 @@ async function buildIpa(opts = {}) {
   );
   console.log(`\u2705 Build completed.`);
   if (opts.install) {
-    const appGlob = path18.join(
-      derivedDataPath,
-      "Build",
-      "Products",
-      `${configuration}-iphonesimulator`,
-      `${appName}.app`
-    );
-    if (!fs17.existsSync(appGlob)) {
-      console.error(`\u274C Built app not found at: ${appGlob}`);
-      process.exit(1);
-    }
-    const udid = findBootedSimulator();
-    if (!udid) {
-      console.error("\u274C No booted simulator found. Start one with: xcrun simctl boot <udid>");
-      process.exit(1);
-    }
-    console.log(`\u{1F4F2} Installing on simulator ${udid}...`);
-    execSync8(`xcrun simctl install "${udid}" "${appGlob}"`, { stdio: "inherit" });
-    if (bundleId) {
-      console.log(`\u{1F680} Launching ${bundleId}...`);
-      execSync8(`xcrun simctl launch "${udid}" "${bundleId}"`, { stdio: "inherit" });
-      console.log("\u2705 App launched.");
+    if (production) {
+      const appPath = path19.join(
+        derivedDataPath,
+        "Build",
+        "Products",
+        `${configuration}-iphoneos`,
+        `${appName}.app`
+      );
+      if (!fs18.existsSync(appPath)) {
+        console.error(`\u274C Built app not found at: ${appPath}`);
+        process.exit(1);
+      }
+      const udid = findFirstConnectedIosDeviceUdid();
+      if (!udid) {
+        console.error(
+          "\u274C No connected iOS device found. Connect an iPhone/iPad with a trusted cable, unlock it, and ensure Developer Mode is on (iOS 16+). Requires Xcode 15+ (`xcrun devicectl`)."
+        );
+        process.exit(1);
+      }
+      console.log(`\u{1F4F2} Installing on device ${udid}...`);
+      execSync8(`xcrun devicectl device install app --device "${udid}" "${appPath}"`, {
+        stdio: "inherit"
+      });
+      if (bundleId) {
+        console.log(`\u{1F680} Launching ${bundleId}...`);
+        try {
+          execSync8(
+            `xcrun devicectl device process launch --device "${udid}" "${bundleId}"`,
+            { stdio: "inherit" }
+          );
+          console.log("\u2705 App launched.");
+        } catch {
+          console.log("\u2705 Installed. Launch manually on the device if auto-launch failed.");
+        }
+      } else {
+        console.log('\u2705 App installed. (Set "ios.bundleId" in tamer.config.json to auto-launch.)');
+      }
     } else {
-      console.log('\u2705 App installed. (Set "ios.bundleId" in tamer.config.json to auto-launch.)');
+      const appGlob = path19.join(
+        derivedDataPath,
+        "Build",
+        "Products",
+        `${configuration}-iphonesimulator`,
+        `${appName}.app`
+      );
+      if (!fs18.existsSync(appGlob)) {
+        console.error(`\u274C Built app not found at: ${appGlob}`);
+        process.exit(1);
+      }
+      const udid = findBootedSimulator();
+      if (!udid) {
+        console.error("\u274C No booted simulator found. Start one with: xcrun simctl boot <udid>");
+        process.exit(1);
+      }
+      console.log(`\u{1F4F2} Installing on simulator ${udid}...`);
+      execSync8(`xcrun simctl install "${udid}" "${appGlob}"`, { stdio: "inherit" });
+      if (bundleId) {
+        console.log(`\u{1F680} Launching ${bundleId}...`);
+        execSync8(`xcrun simctl launch "${udid}" "${bundleId}"`, { stdio: "inherit" });
+        console.log("\u2705 App launched.");
+      } else {
+        console.log('\u2705 App installed. (Set "ios.bundleId" in tamer.config.json to auto-launch.)');
+      }
     }
   }
 }
 var build_default2 = buildIpa;
 // src/common/init.tsx
-import fs18 from "fs";
-import path19 from "path";
+import fs19 from "fs";
+import path20 from "path";
 import { useState as useState4, useEffect as useEffect2, useCallback as useCallback3 } from "react";
 import { render, Text as Text9, Box as Box8 } from "ink";
@@ -4678,7 +4865,9 @@ function Wizard({ step, total, title, children }) {
 import "react";
 import { Box as Box7, Text as Text8 } from "ink";
 import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var LOG_DISPLAY_MAX = 120;
 function ServerDashboard({
+  cliVersion,
   projectName,
   port,
   lanIp,
@@ -4691,7 +4880,6 @@ function ServerDashboard({
   buildError,
   wsConnections,
   logLines,
-  showLogs,
   qrLines,
   phase,
   startError
@@ -4710,6 +4898,10 @@ function ServerDashboard({
       projectName,
       ")"
     ] }),
+    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+      "t4l v",
+      cliVersion
+    ] }),
     verbose ? /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Logs: verbose (native + JS)" }) : null,
     /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "row", columnGap: 3, alignItems: "flex-start", children: [
       qrLines.length > 0 ? /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", flexShrink: 0, children: [
@@ -4746,7 +4938,7 @@ function ServerDashboard({
             bonjour ? /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "mDNS: _tamer._tcp" }) : null,
             /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", children: [
               /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Build" }),
-              buildPhase === "building" ? /* @__PURE__ */ jsx8(TuiSpinner, { label: "Building\u2026" }) : buildPhase === "error" ? /* @__PURE__ */ jsx8(Text8, { color: "red", children: buildError ?? "Build failed" }) : /* @__PURE__ */ jsx8(Text8, { color: "green", children: "Ready" })
+              buildPhase === "building" ? /* @__PURE__ */ jsx8(TuiSpinner, { label: "building\u2026" }) : buildPhase === "error" ? /* @__PURE__ */ jsx8(Text8, { color: "red", children: buildError ?? "Build failed" }) : buildPhase === "success" ? /* @__PURE__ */ jsx8(Text8, { color: "green", children: "Lynx bundle ready" }) : /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2014" })
             ] }),
             /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", children: [
               /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Connections" }),
@@ -4759,15 +4951,15 @@ function ServerDashboard({
         }
       )
     ] }),
-    showLogs && logLines.length > 0 ? /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", borderStyle: "single", paddingX: 1, children: [
-      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-        "Build / output (last ",
-        logLines.length,
-        " lines)"
-      ] }),
-      logLines.slice(-12).map((line, i) => /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: line }, i))
-    ] }) : null,
-    /* @__PURE__ */ jsx8(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "r rebuild \xB7 l toggle logs \xB7 q quit" }) })
+    /* @__PURE__ */ jsx8(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "r rebuild \xB7 c clear output \xB7 Ctrl+C or q quit" }) }),
+    logLines.length > 0 ? /* @__PURE__ */ jsxs8(Box7, { marginTop: 1, flexDirection: "column", children: [
+      logLines.length > LOG_DISPLAY_MAX ? /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "\u2026 ",
+        logLines.length - LOG_DISPLAY_MAX,
+        " earlier lines omitted"
+      ] }) : null,
+      logLines.slice(-LOG_DISPLAY_MAX).map((line, i) => /* @__PURE__ */ jsx8(Text8, { children: line }, i))
+    ] }) : null
   ] });
 }
@@ -4833,22 +5025,22 @@ function InitWizard() {
       paths: { androidDir: "android", iosDir: "ios" }
     };
     if (lynxProject.trim()) config.lynxProject = lynxProject.trim();
-    const configPath = path19.join(process.cwd(), "tamer.config.json");
-    fs18.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    const configPath = path20.join(process.cwd(), "tamer.config.json");
+    fs19.writeFileSync(configPath, JSON.stringify(config, null, 2));
     const lines = [`Generated tamer.config.json at ${configPath}`];
     const tamerTypesInclude = "node_modules/@tamer4lynx/tamer-*/src/**/*.d.ts";
     const tsconfigCandidates = lynxProject.trim() ? [
-      path19.join(process.cwd(), lynxProject.trim(), "tsconfig.json"),
-      path19.join(process.cwd(), "tsconfig.json")
-    ] : [path19.join(process.cwd(), "tsconfig.json")];
+      path20.join(process.cwd(), lynxProject.trim(), "tsconfig.json"),
+      path20.join(process.cwd(), "tsconfig.json")
+    ] : [path20.join(process.cwd(), "tsconfig.json")];
     for (const tsconfigPath of tsconfigCandidates) {
-      if (!fs18.existsSync(tsconfigPath)) continue;
+      if (!fs19.existsSync(tsconfigPath)) continue;
       try {
         if (fixTsconfigReferencesForBuild(tsconfigPath)) {
-          lines.push(`Flattened ${path19.relative(process.cwd(), tsconfigPath)} (fixed TS6310)`);
+          lines.push(`Flattened ${path20.relative(process.cwd(), tsconfigPath)} (fixed TS6310)`);
         }
         if (addTamerTypesInclude(tsconfigPath, tamerTypesInclude)) {
-          lines.push(`Updated ${path19.relative(process.cwd(), tsconfigPath)} for tamer types`);
+          lines.push(`Updated ${path20.relative(process.cwd(), tsconfigPath)} for tamer types`);
         }
         break;
       } catch (e) {
@@ -5008,8 +5200,8 @@ async function init() {
 }
 // src/common/create.ts
-import fs19 from "fs";
-import path20 from "path";
+import fs20 from "fs";
+import path21 from "path";
 import readline from "readline";
 var rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
 function ask(question) {
@@ -5071,13 +5263,13 @@ async function create3(opts) {
   const simpleModuleName = extName.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Module";
   const fullModuleClassName = `${packageName}.${simpleModuleName}`;
   const cwd = process.cwd();
-  const root = path20.join(cwd, extName);
-  if (fs19.existsSync(root)) {
+  const root = path21.join(cwd, extName);
+  if (fs20.existsSync(root)) {
     console.error(`\u274C Directory ${extName} already exists.`);
     rl.close();
     process.exit(1);
   }
-  fs19.mkdirSync(root, { recursive: true });
+  fs20.mkdirSync(root, { recursive: true });
   const lynxExt = {
     platforms: {
       android: {
@@ -5092,7 +5284,7 @@ async function create3(opts) {
       web: {}
     }
   };
-  fs19.writeFileSync(path20.join(root, "lynx.ext.json"), JSON.stringify(lynxExt, null, 2));
+  fs20.writeFileSync(path21.join(root, "lynx.ext.json"), JSON.stringify(lynxExt, null, 2));
   const pkg = {
     name: extName,
     version: "0.0.1",
@@ -5105,20 +5297,20 @@ async function create3(opts) {
     engines: { node: ">=18" }
   };
   if (includeModule) pkg.types = "src/index.d.ts";
-  fs19.writeFileSync(path20.join(root, "package.json"), JSON.stringify(pkg, null, 2));
+  fs20.writeFileSync(path21.join(root, "package.json"), JSON.stringify(pkg, null, 2));
   const pkgPath = packageName.replace(/\./g, "/");
   const hasSrc = includeModule || includeElement || includeService;
   if (hasSrc) {
-    fs19.mkdirSync(path20.join(root, "src"), { recursive: true });
+    fs20.mkdirSync(path21.join(root, "src"), { recursive: true });
   }
   if (includeModule) {
-    fs19.writeFileSync(path20.join(root, "src", "index.d.ts"), `/** @lynxmodule */
+    fs20.writeFileSync(path21.join(root, "src", "index.d.ts"), `/** @lynxmodule */
 export declare class ${simpleModuleName} {
   // Add your module methods here
 }
 `);
-    fs19.mkdirSync(path20.join(root, "android", "src", "main", "kotlin", pkgPath), { recursive: true });
-    fs19.writeFileSync(path20.join(root, "android", "build.gradle.kts"), `plugins {
+    fs20.mkdirSync(path21.join(root, "android", "src", "main", "kotlin", pkgPath), { recursive: true });
+    fs20.writeFileSync(path21.join(root, "android", "build.gradle.kts"), `plugins {
     id("com.android.library")
     id("org.jetbrains.kotlin.android")
 }
@@ -5139,7 +5331,7 @@ dependencies {
     implementation(libs.lynx.jssdk)
 }
 `);
-    fs19.writeFileSync(path20.join(root, "android", "src", "main", "AndroidManifest.xml"), `<?xml version="1.0" encoding="utf-8"?>
+    fs20.writeFileSync(path21.join(root, "android", "src", "main", "AndroidManifest.xml"), `<?xml version="1.0" encoding="utf-8"?>
 <manifest />
 `);
     const ktContent = `package ${packageName}
@@ -5156,8 +5348,8 @@ class ${simpleModuleName}(context: Context) : LynxModule(context) {
     }
 }
 `;
-    fs19.writeFileSync(path20.join(root, "android", "src", "main", "kotlin", pkgPath, `${simpleModuleName}.kt`), ktContent);
-    fs19.mkdirSync(path20.join(root, "ios", extName, extName, "Classes"), { recursive: true });
+    fs20.writeFileSync(path21.join(root, "android", "src", "main", "kotlin", pkgPath, `${simpleModuleName}.kt`), ktContent);
+    fs20.mkdirSync(path21.join(root, "ios", extName, extName, "Classes"), { recursive: true });
     const podspec = `Pod::Spec.new do |s|
   s.name             = '${extName}'
   s.version          = '0.0.1'
@@ -5171,7 +5363,7 @@ class ${simpleModuleName}(context: Context) : LynxModule(context) {
   s.dependency       'Lynx'
 end
 `;
-    fs19.writeFileSync(path20.join(root, "ios", extName, `${extName}.podspec`), podspec);
+    fs20.writeFileSync(path21.join(root, "ios", extName, `${extName}.podspec`), podspec);
     const swiftContent = `import Foundation
 @objc public class ${simpleModuleName}: NSObject {
@@ -5180,18 +5372,18 @@ end
     }
 }
 `;
-    fs19.writeFileSync(path20.join(root, "ios", extName, extName, "Classes", `${simpleModuleName}.swift`), swiftContent);
+    fs20.writeFileSync(path21.join(root, "ios", extName, extName, "Classes", `${simpleModuleName}.swift`), swiftContent);
   }
   if (includeElement && !includeModule) {
     const elementName = extName.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-    fs19.writeFileSync(path20.join(root, "src", "index.tsx"), `import type { FC } from '@lynx-js/react';
+    fs20.writeFileSync(path21.join(root, "src", "index.tsx"), `import type { FC } from '@lynx-js/react';
 export const ${elementName}: FC = () => {
   return null;
 };
 `);
   }
-  fs19.writeFileSync(path20.join(root, "index.js"), `'use strict';
+  fs20.writeFileSync(path21.join(root, "index.js"), `'use strict';
 module.exports = {};
 `);
   const tsconfigCompiler = {
@@ -5204,11 +5396,11 @@ module.exports = {};
     tsconfigCompiler.jsx = "preserve";
     tsconfigCompiler.jsxImportSource = "@lynx-js/react";
   }
-  fs19.writeFileSync(path20.join(root, "tsconfig.json"), JSON.stringify({
+  fs20.writeFileSync(path21.join(root, "tsconfig.json"), JSON.stringify({
     compilerOptions: tsconfigCompiler,
     include: includeElement ? ["src", "src/**/*.tsx"] : ["src"]
   }, null, 2));
-  fs19.writeFileSync(path20.join(root, "README.md"), `# ${extName}
+  fs20.writeFileSync(path21.join(root, "README.md"), `# ${extName}
 Lynx extension for ${extName}.
@@ -5233,8 +5425,8 @@ This package uses \`lynx.ext.json\` (RFC-compliant) for autolinking.
 var create_default3 = create3;
 // src/common/codegen.ts
-import fs20 from "fs";
-import path21 from "path";
+import fs21 from "fs";
+import path22 from "path";
 function codegen() {
   const cwd = process.cwd();
   const config = loadExtensionConfig(cwd);
@@ -5242,9 +5434,9 @@ function codegen() {
     console.error("\u274C No lynx.ext.json or tamer.json found. Run from an extension package root.");
     process.exit(1);
   }
-  const srcDir = path21.join(cwd, "src");
-  const generatedDir = path21.join(cwd, "generated");
-  fs20.mkdirSync(generatedDir, { recursive: true });
+  const srcDir = path22.join(cwd, "src");
+  const generatedDir = path22.join(cwd, "generated");
+  fs21.mkdirSync(generatedDir, { recursive: true });
   const dtsFiles = findDtsFiles(srcDir);
   const modules = extractLynxModules(dtsFiles);
   if (modules.length === 0) {
@@ -5254,28 +5446,28 @@ function codegen() {
   for (const mod of modules) {
     const tsContent = `export type { ${mod} } from '../src/index.js';
 `;
-    const outPath = path21.join(generatedDir, `${mod}.ts`);
-    fs20.writeFileSync(outPath, tsContent);
+    const outPath = path22.join(generatedDir, `${mod}.ts`);
+    fs21.writeFileSync(outPath, tsContent);
     console.log(`\u2705 Generated ${outPath}`);
   }
   if (config.android) {
-    const androidGenerated = path21.join(cwd, "android", "src", "main", "kotlin", config.android.moduleClassName.replace(/\./g, "/").replace(/[^/]+$/, ""), "generated");
-    fs20.mkdirSync(androidGenerated, { recursive: true });
+    const androidGenerated = path22.join(cwd, "android", "src", "main", "kotlin", config.android.moduleClassName.replace(/\./g, "/").replace(/[^/]+$/, ""), "generated");
+    fs21.mkdirSync(androidGenerated, { recursive: true });
     console.log(`\u2139\uFE0F Android generated dir: ${androidGenerated} (spec generation coming soon)`);
   }
   if (config.ios) {
-    const iosGenerated = path21.join(cwd, "ios", "generated");
-    fs20.mkdirSync(iosGenerated, { recursive: true });
+    const iosGenerated = path22.join(cwd, "ios", "generated");
+    fs21.mkdirSync(iosGenerated, { recursive: true });
     console.log(`\u2139\uFE0F iOS generated dir: ${iosGenerated} (spec generation coming soon)`);
   }
   console.log("\u2728 Codegen complete.");
 }
 function findDtsFiles(dir) {
   const result = [];
-  if (!fs20.existsSync(dir)) return result;
-  const entries = fs20.readdirSync(dir, { withFileTypes: true });
+  if (!fs21.existsSync(dir)) return result;
+  const entries = fs21.readdirSync(dir, { withFileTypes: true });
   for (const e of entries) {
-    const full = path21.join(dir, e.name);
+    const full = path22.join(dir, e.name);
     if (e.isDirectory()) result.push(...findDtsFiles(full));
     else if (e.name.endsWith(".d.ts")) result.push(full);
   }
@@ -5285,7 +5477,7 @@ function extractLynxModules(files) {
   const modules = [];
   const seen = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const content = fs20.readFileSync(file, "utf8");
+    const content = fs21.readFileSync(file, "utf8");
     const regex = /\/\*\*\s*@lynxmodule\s*\*\/\s*export\s+declare\s+class\s+(\w+)/g;
     let m;
     while ((m = regex.exec(content)) !== null) {
@@ -5302,14 +5494,16 @@ var codegen_default = codegen;
 // src/common/devServer.tsx
 import { useState as useState5, useEffect as useEffect3, useRef, useCallback as useCallback4 } from "react";
 import { spawn } from "child_process";
-import fs21 from "fs";
+import fs22 from "fs";
 import http from "http";
 import os4 from "os";
-import path22 from "path";
+import path23 from "path";
 import { render as render2, useInput, useApp } from "ink";
-import { WebSocketServer } from "ws";
+import { WebSocket, WebSocketServer } from "ws";
 import { jsx as jsx10 } from "react/jsx-runtime";
 var DEFAULT_PORT = 3e3;
+var TAMER_CLI_VERSION = getCliVersion();
+var MAX_LOG_LINES = 800;
 var STATIC_MIME = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -5321,13 +5515,13 @@ var STATIC_MIME = {
   ".pdf": "application/pdf"
 };
 function sendFileFromDisk(res, absPath) {
-  fs21.readFile(absPath, (err, data) => {
+  fs22.readFile(absPath, (err, data) => {
     if (err) {
       res.writeHead(404);
       res.end("Not found");
       return;
     }
-    const ext = path22.extname(absPath).toLowerCase();
+    const ext = path23.extname(absPath).toLowerCase();
     res.setHeader("Content-Type", STATIC_MIME[ext] ?? "application/octet-stream");
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.end(data);
@@ -5364,9 +5558,9 @@ function getLanIp() {
   return "localhost";
 }
 function detectPackageManager(cwd) {
-  const dir = path22.resolve(cwd);
-  if (fs21.existsSync(path22.join(dir, "pnpm-lock.yaml"))) return { cmd: "pnpm", args: ["run", "build"] };
-  if (fs21.existsSync(path22.join(dir, "bun.lockb")) || fs21.existsSync(path22.join(dir, "bun.lock")))
+  const dir = path23.resolve(cwd);
+  if (fs22.existsSync(path23.join(dir, "pnpm-lock.yaml"))) return { cmd: "pnpm", args: ["run", "build"] };
+  if (fs22.existsSync(path23.join(dir, "bun.lockb")) || fs22.existsSync(path23.join(dir, "bun.lock")))
     return { cmd: "bun", args: ["run", "build"] };
   return { cmd: "npm", args: ["run", "build"] };
 }
@@ -5383,7 +5577,6 @@ var initialUi = () => ({
   buildPhase: "idle",
   wsConnections: 0,
   logLines: [],
-  showLogs: false,
   qrLines: []
 });
 function DevServerApp({ verbose }) {
@@ -5396,13 +5589,20 @@ function DevServerApp({ verbose }) {
   const cleanupRef = useRef(null);
   const rebuildRef = useRef(() => Promise.resolve());
   const quitOnceRef = useRef(false);
-  const appendLog = useCallback4((chunk) => {
-    const lines = chunk.split(/\r?\n/).filter(Boolean);
+  const appendLogLine = useCallback4((line) => {
     setUi((prev) => ({
       ...prev,
-      logLines: [...prev.logLines, ...lines].slice(-400)
+      logLines: [...prev.logLines, line].slice(-MAX_LOG_LINES)
     }));
   }, []);
+  const appendLog = useCallback4(
+    (chunk) => {
+      for (const line of chunk.split(/\r?\n/)) {
+        appendLogLine(line);
+      }
+    },
+    [appendLogLine]
+  );
   const handleQuit = useCallback4(() => {
     if (quitOnceRef.current) return;
     quitOnceRef.current = true;
@@ -5410,7 +5610,7 @@ function DevServerApp({ verbose }) {
     exit();
   }, [exit]);
   useInput((input, key) => {
-    if (key.ctrl && key.name === "c") {
+    if (key.ctrl && input === "c") {
       handleQuit();
       return;
     }
@@ -5422,8 +5622,9 @@ function DevServerApp({ verbose }) {
       void rebuildRef.current();
       return;
     }
-    if (input === "l") {
-      setUi((s) => ({ ...s, showLogs: !s.showLogs }));
+    if (input === "c") {
+      setUi((s) => ({ ...s, logLines: [] }));
+      return;
     }
   });
   useEffect3(() => {
@@ -5446,8 +5647,8 @@ function DevServerApp({ verbose }) {
       try {
         const resolved = resolveHostPaths();
         const { projectRoot, lynxProjectDir, lynxBundlePath, lynxBundleFile, config } = resolved;
-        const distDir = path22.dirname(lynxBundlePath);
-        const projectName = path22.basename(lynxProjectDir);
+        const distDir = path23.dirname(lynxBundlePath);
+        const projectName = path23.basename(lynxProjectDir);
         const basePath = `/${projectName}`;
         setUi((s) => ({ ...s, projectName, lynxBundleFile }));
         const preferredPort = config.devServer?.port ?? config.devServer?.httpPort ?? DEFAULT_PORT;
@@ -5457,18 +5658,18 @@ function DevServerApp({ verbose }) {
         }
         const iconPaths = resolveIconPaths(projectRoot, config);
         let iconFilePath = null;
-        if (iconPaths?.source && fs21.statSync(iconPaths.source).isFile()) {
+        if (iconPaths?.source && fs22.statSync(iconPaths.source).isFile()) {
           iconFilePath = iconPaths.source;
-        } else if (iconPaths?.androidAdaptiveForeground && fs21.statSync(iconPaths.androidAdaptiveForeground).isFile()) {
+        } else if (iconPaths?.androidAdaptiveForeground && fs22.statSync(iconPaths.androidAdaptiveForeground).isFile()) {
           iconFilePath = iconPaths.androidAdaptiveForeground;
         } else if (iconPaths?.android) {
-          const androidIcon = path22.join(iconPaths.android, "mipmap-xxxhdpi", "ic_launcher.png");
-          if (fs21.existsSync(androidIcon)) iconFilePath = androidIcon;
+          const androidIcon = path23.join(iconPaths.android, "mipmap-xxxhdpi", "ic_launcher.png");
+          if (fs22.existsSync(androidIcon)) iconFilePath = androidIcon;
         } else if (iconPaths?.ios) {
-          const iosIcon = path22.join(iconPaths.ios, "Icon-1024.png");
-          if (fs21.existsSync(iosIcon)) iconFilePath = iosIcon;
+          const iosIcon = path23.join(iconPaths.ios, "Icon-1024.png");
+          if (fs22.existsSync(iosIcon)) iconFilePath = iosIcon;
         }
-        const iconExt = iconFilePath ? path22.extname(iconFilePath) || ".png" : "";
+        const iconExt = iconFilePath ? path23.extname(iconFilePath) || ".png" : "";
         const runBuild = () => {
           return new Promise((resolve, reject) => {
             const { cmd, args } = detectPackageManager(lynxProjectDir);
@@ -5477,19 +5678,15 @@ function DevServerApp({ verbose }) {
               stdio: "pipe",
               shell: process.platform === "win32"
             });
-            let stderr = "";
-            buildProcess.stdout?.on("data", (d) => {
-              appendLog(d.toString());
-            });
+            let stderrRaw = "";
+            buildProcess.stdout?.resume();
             buildProcess.stderr?.on("data", (d) => {
-              const t = d.toString();
-              stderr += t;
-              appendLog(t);
+              stderrRaw += d.toString();
             });
             buildProcess.on("close", (code) => {
               buildProcess = null;
               if (code === 0) resolve();
-              else reject(new Error(stderr || `Build exited ${code}`));
+              else reject(new Error(stderrRaw.trim() || `Build exited ${code}`));
             });
           });
         };
@@ -5554,7 +5751,7 @@ function DevServerApp({ verbose }) {
             return;
           }
           if (iconFilePath && (reqPath === `${basePath}/icon` || reqPath === `${basePath}/icon${iconExt}`)) {
-            fs21.readFile(iconFilePath, (err, data) => {
+            fs22.readFile(iconFilePath, (err, data) => {
               if (err) {
                 res.writeHead(404);
                 res.end();
@@ -5580,20 +5777,20 @@ function DevServerApp({ verbose }) {
               res.end();
               return;
             }
-            const safe = path22.normalize(rel).replace(/^(\.\.(\/|\\|$))+/, "");
-            if (path22.isAbsolute(safe) || safe.startsWith("..")) {
+            const safe = path23.normalize(rel).replace(/^(\.\.(\/|\\|$))+/, "");
+            if (path23.isAbsolute(safe) || safe.startsWith("..")) {
               res.writeHead(403);
               res.end();
               return;
             }
-            const allowedRoot = path22.resolve(lynxProjectDir, rootSub);
-            const abs = path22.resolve(allowedRoot, safe);
-            if (!abs.startsWith(allowedRoot + path22.sep) && abs !== allowedRoot) {
+            const allowedRoot = path23.resolve(lynxProjectDir, rootSub);
+            const abs = path23.resolve(allowedRoot, safe);
+            if (!abs.startsWith(allowedRoot + path23.sep) && abs !== allowedRoot) {
               res.writeHead(403);
               res.end();
               return;
             }
-            if (!fs21.existsSync(abs) || !fs21.statSync(abs).isFile()) {
+            if (!fs22.existsSync(abs) || !fs22.statSync(abs).isFile()) {
               res.writeHead(404);
               res.end("Not found");
               return;
@@ -5607,14 +5804,14 @@ function DevServerApp({ verbose }) {
             reqPath = basePath + (reqPath.startsWith("/") ? reqPath : "/" + reqPath);
           }
           const relPath = reqPath.replace(basePath, "").replace(/^\//, "") || lynxBundleFile;
-          const filePath = path22.resolve(distDir, relPath);
-          const distResolved = path22.resolve(distDir);
-          if (!filePath.startsWith(distResolved + path22.sep) && filePath !== distResolved) {
+          const filePath = path23.resolve(distDir, relPath);
+          const distResolved = path23.resolve(distDir);
+          if (!filePath.startsWith(distResolved + path23.sep) && filePath !== distResolved) {
             res.writeHead(403);
             res.end();
             return;
           }
-          fs21.readFile(filePath, (err, data) => {
+          fs22.readFile(filePath, (err, data) => {
             if (err) {
               res.writeHead(404);
               res.end("Not found");
@@ -5626,6 +5823,14 @@ function DevServerApp({ verbose }) {
           });
         });
         const wssInst = new WebSocketServer({ noServer: true });
+        const syncWsClientCount = () => {
+          if (!alive) return;
+          let n = 0;
+          wssInst.clients.forEach((c) => {
+            if (c.readyState === WebSocket.OPEN) n++;
+          });
+          setUi((s) => ({ ...s, wsConnections: n }));
+        };
         rebuildRef.current = async () => {
           try {
             await doBuild();
@@ -5647,12 +5852,15 @@ function DevServerApp({ verbose }) {
         });
         wssInst.on("connection", (ws, req) => {
           const clientIp = req.socket.remoteAddress ?? "unknown";
-          setUi((s) => ({ ...s, wsConnections: s.wsConnections + 1 }));
           appendLog(`[WS] connected: ${clientIp}`);
           ws.send(JSON.stringify({ type: "connected" }));
+          syncWsClientCount();
           ws.on("close", () => {
-            setUi((s) => ({ ...s, wsConnections: Math.max(0, s.wsConnections - 1) }));
             appendLog(`[WS] disconnected: ${clientIp}`);
+            queueMicrotask(() => syncWsClientCount());
+          });
+          ws.on("error", () => {
+            queueMicrotask(() => syncWsClientCount());
           });
           ws.on("message", (data) => {
             try {
@@ -5675,10 +5883,10 @@ function DevServerApp({ verbose }) {
         }
         if (chokidar) {
           const watchPaths = [
-            path22.join(lynxProjectDir, "src"),
-            path22.join(lynxProjectDir, "lynx.config.ts"),
-            path22.join(lynxProjectDir, "lynx.config.js")
-          ].filter((p) => fs21.existsSync(p));
+            path23.join(lynxProjectDir, "src"),
+            path23.join(lynxProjectDir, "lynx.config.ts"),
+            path23.join(lynxProjectDir, "lynx.config.js")
+          ].filter((p) => fs22.existsSync(p));
           if (watchPaths.length > 0) {
             const w = chokidar.watch(watchPaths, { ignoreInitial: true });
             w.on("change", async () => {
@@ -5758,10 +5966,11 @@ function DevServerApp({ verbose }) {
       alive = false;
       void cleanupRef.current?.();
     };
-  }, [appendLog, verbose]);
+  }, [appendLog, appendLogLine, verbose]);
   return /* @__PURE__ */ jsx10(
     ServerDashboard,
     {
+      cliVersion: TAMER_CLI_VERSION,
       projectName: ui.projectName,
       port: ui.port,
       lanIp: ui.lanIp,
@@ -5774,7 +5983,6 @@ function DevServerApp({ verbose }) {
       buildError: ui.buildError,
       wsConnections: ui.wsConnections,
       logLines: ui.logLines,
-      showLogs: ui.showLogs,
       qrLines: ui.qrLines,
       phase: ui.phase,
       startError: ui.startError
@@ -5798,10 +6006,10 @@ async function start(opts) {
 var start_default = start;
 // src/common/injectHost.ts
-import fs22 from "fs";
-import path23 from "path";
+import fs23 from "fs";
+import path24 from "path";
 function readAndSubstitute(templatePath, vars) {
-  const raw = fs22.readFileSync(templatePath, "utf-8");
+  const raw = fs23.readFileSync(templatePath, "utf-8");
   return Object.entries(vars).reduce(
     (s, [k, v]) => s.replace(new RegExp(`\\{\\{${k}\\}\\}`, "g"), v),
     raw
@@ -5822,32 +6030,32 @@ async function injectHostAndroid(opts) {
     process.exit(1);
   }
   const androidDir = config.paths?.androidDir ?? "android";
-  const rootDir = path23.join(projectRoot, androidDir);
+  const rootDir = path24.join(projectRoot, androidDir);
   const packagePath = packageName.replace(/\./g, "/");
-  const javaDir = path23.join(rootDir, "app", "src", "main", "java", packagePath);
-  const kotlinDir = path23.join(rootDir, "app", "src", "main", "kotlin", packagePath);
-  if (!fs22.existsSync(javaDir) || !fs22.existsSync(kotlinDir)) {
+  const javaDir = path24.join(rootDir, "app", "src", "main", "java", packagePath);
+  const kotlinDir = path24.join(rootDir, "app", "src", "main", "kotlin", packagePath);
+  if (!fs23.existsSync(javaDir) || !fs23.existsSync(kotlinDir)) {
     console.error("\u274C Android project not found. Run `t4l android create` first or ensure android/ exists.");
     process.exit(1);
   }
-  const templateDir = path23.join(hostPkg, "android", "templates");
+  const templateDir = path24.join(hostPkg, "android", "templates");
   const vars = { PACKAGE_NAME: packageName, APP_NAME: appName };
   const files = [
-    { src: "App.java", dst: path23.join(javaDir, "App.java") },
-    { src: "TemplateProvider.java", dst: path23.join(javaDir, "TemplateProvider.java") },
-    { src: "MainActivity.kt", dst: path23.join(kotlinDir, "MainActivity.kt") }
+    { src: "App.java", dst: path24.join(javaDir, "App.java") },
+    { src: "TemplateProvider.java", dst: path24.join(javaDir, "TemplateProvider.java") },
+    { src: "MainActivity.kt", dst: path24.join(kotlinDir, "MainActivity.kt") }
   ];
   for (const { src, dst } of files) {
-    const srcPath = path23.join(templateDir, src);
-    if (!fs22.existsSync(srcPath)) continue;
-    if (fs22.existsSync(dst) && !opts?.force) {
-      console.log(`\u23ED\uFE0F  Skipping ${path23.basename(dst)} (use --force to overwrite)`);
+    const srcPath = path24.join(templateDir, src);
+    if (!fs23.existsSync(srcPath)) continue;
+    if (fs23.existsSync(dst) && !opts?.force) {
+      console.log(`\u23ED\uFE0F  Skipping ${path24.basename(dst)} (use --force to overwrite)`);
       continue;
     }
     const content = readAndSubstitute(srcPath, vars);
-    fs22.mkdirSync(path23.dirname(dst), { recursive: true });
-    fs22.writeFileSync(dst, content);
-    console.log(`\u2705 Injected ${path23.basename(dst)}`);
+    fs23.mkdirSync(path24.dirname(dst), { recursive: true });
+    fs23.writeFileSync(dst, content);
+    console.log(`\u2705 Injected ${path24.basename(dst)}`);
   }
 }
 async function injectHostIos(opts) {
@@ -5865,13 +6073,13 @@ async function injectHostIos(opts) {
     process.exit(1);
   }
   const iosDir = config.paths?.iosDir ?? "ios";
-  const rootDir = path23.join(projectRoot, iosDir);
-  const projectDir = path23.join(rootDir, appName);
-  if (!fs22.existsSync(projectDir)) {
+  const rootDir = path24.join(projectRoot, iosDir);
+  const projectDir = path24.join(rootDir, appName);
+  if (!fs23.existsSync(projectDir)) {
     console.error("\u274C iOS project not found. Run `t4l ios create` first or ensure ios/ exists.");
     process.exit(1);
   }
-  const templateDir = path23.join(hostPkg, "ios", "templates");
+  const templateDir = path24.join(hostPkg, "ios", "templates");
   const vars = { PACKAGE_NAME: bundleId, APP_NAME: appName, BUNDLE_ID: bundleId };
   const files = [
     "AppDelegate.swift",
@@ -5881,22 +6089,22 @@ async function injectHostIos(opts) {
     "LynxInitProcessor.swift"
   ];
   for (const f of files) {
-    const srcPath = path23.join(templateDir, f);
-    const dstPath = path23.join(projectDir, f);
-    if (!fs22.existsSync(srcPath)) continue;
-    if (fs22.existsSync(dstPath) && !opts?.force) {
+    const srcPath = path24.join(templateDir, f);
+    const dstPath = path24.join(projectDir, f);
+    if (!fs23.existsSync(srcPath)) continue;
+    if (fs23.existsSync(dstPath) && !opts?.force) {
       console.log(`\u23ED\uFE0F  Skipping ${f} (use --force to overwrite)`);
       continue;
     }
     const content = readAndSubstitute(srcPath, vars);
-    fs22.writeFileSync(dstPath, content);
+    fs23.writeFileSync(dstPath, content);
     console.log(`\u2705 Injected ${f}`);
   }
 }
 // src/common/buildEmbeddable.ts
-import fs23 from "fs";
-import path24 from "path";
+import fs24 from "fs";
+import path25 from "path";
 import { execSync as execSync9 } from "child_process";
 var EMBEDDABLE_DIR = "embeddable";
 var LIB_PACKAGE = "com.tamer.embeddable";
@@ -5973,14 +6181,14 @@ object LynxEmbeddable {
 }
 `;
 function generateAndroidLibrary(outDir, androidDir, projectRoot, lynxBundlePath, lynxBundleFile, modules, abiFilters) {
-  const libDir = path24.join(androidDir, "lib");
-  const libSrcMain = path24.join(libDir, "src", "main");
-  const assetsDir = path24.join(libSrcMain, "assets");
-  const kotlinDir = path24.join(libSrcMain, "kotlin", LIB_PACKAGE.replace(/\./g, "/"));
-  const generatedDir = path24.join(kotlinDir, "generated");
-  fs23.mkdirSync(path24.join(androidDir, "gradle"), { recursive: true });
-  fs23.mkdirSync(generatedDir, { recursive: true });
-  fs23.mkdirSync(assetsDir, { recursive: true });
+  const libDir = path25.join(androidDir, "lib");
+  const libSrcMain = path25.join(libDir, "src", "main");
+  const assetsDir = path25.join(libSrcMain, "assets");
+  const kotlinDir = path25.join(libSrcMain, "kotlin", LIB_PACKAGE.replace(/\./g, "/"));
+  const generatedDir = path25.join(kotlinDir, "generated");
+  fs24.mkdirSync(path25.join(androidDir, "gradle"), { recursive: true });
+  fs24.mkdirSync(generatedDir, { recursive: true });
+  fs24.mkdirSync(assetsDir, { recursive: true });
   const androidModules = modules.filter((m) => m.config.android);
   const abiList = abiFilters.map((a) => `"${a}"`).join(", ");
   const settingsContent = `pluginManagement {
@@ -6000,7 +6208,7 @@ include(":lib")
 ${androidModules.map((p) => {
     const gradleName = p.name.replace(/^@/, "").replace(/\//g, "_");
     const sourceDir = p.config.android?.sourceDir || "android";
-    const absPath = path24.join(p.packagePath, sourceDir).replace(/\\/g, "/");
+    const absPath = path25.join(p.packagePath, sourceDir).replace(/\\/g, "/");
     return `include(":${gradleName}")
 project(":${gradleName}").projectDir = file("${absPath}")`;
   }).join("\n")}
@@ -6049,10 +6257,10 @@ dependencies {
 ${libDeps}
 }
 `;
-  fs23.writeFileSync(path24.join(androidDir, "gradle", "libs.versions.toml"), LIBS_VERSIONS_TOML);
-  fs23.writeFileSync(path24.join(androidDir, "settings.gradle.kts"), settingsContent);
-  fs23.writeFileSync(
-    path24.join(androidDir, "build.gradle.kts"),
+  fs24.writeFileSync(path25.join(androidDir, "gradle", "libs.versions.toml"), LIBS_VERSIONS_TOML);
+  fs24.writeFileSync(path25.join(androidDir, "settings.gradle.kts"), settingsContent);
+  fs24.writeFileSync(
+    path25.join(androidDir, "build.gradle.kts"),
     `plugins {
     alias(libs.plugins.android.library) apply false
     alias(libs.plugins.kotlin.android) apply false
@@ -6060,26 +6268,26 @@ ${libDeps}
 }
 `
   );
-  fs23.writeFileSync(
-    path24.join(androidDir, "gradle.properties"),
+  fs24.writeFileSync(
+    path25.join(androidDir, "gradle.properties"),
     `org.gradle.jvmargs=-Xmx2048m
 android.useAndroidX=true
 kotlin.code.style=official
 `
   );
-  fs23.writeFileSync(path24.join(libDir, "build.gradle.kts"), libBuildContent);
-  fs23.writeFileSync(
-    path24.join(libSrcMain, "AndroidManifest.xml"),
+  fs24.writeFileSync(path25.join(libDir, "build.gradle.kts"), libBuildContent);
+  fs24.writeFileSync(
+    path25.join(libSrcMain, "AndroidManifest.xml"),
     '<?xml version="1.0" encoding="utf-8"?>\n<manifest />'
   );
-  fs23.copyFileSync(lynxBundlePath, path24.join(assetsDir, lynxBundleFile));
-  fs23.writeFileSync(path24.join(kotlinDir, "LynxEmbeddable.kt"), LYNX_EMBEDDABLE_KT);
-  fs23.writeFileSync(
-    path24.join(generatedDir, "GeneratedLynxExtensions.kt"),
+  fs24.copyFileSync(lynxBundlePath, path25.join(assetsDir, lynxBundleFile));
+  fs24.writeFileSync(path25.join(kotlinDir, "LynxEmbeddable.kt"), LYNX_EMBEDDABLE_KT);
+  fs24.writeFileSync(
+    path25.join(generatedDir, "GeneratedLynxExtensions.kt"),
     generateLynxExtensionsKotlin(modules, LIB_PACKAGE)
   );
-  fs23.writeFileSync(
-    path24.join(generatedDir, "GeneratedActivityLifecycle.kt"),
+  fs24.writeFileSync(
+    path25.join(generatedDir, "GeneratedActivityLifecycle.kt"),
     generateActivityLifecycleKotlin(modules, LIB_PACKAGE)
   );
 }
@@ -6088,20 +6296,20 @@ async function buildEmbeddable(opts = {}) {
   const { lynxProjectDir, lynxBundlePath, lynxBundleFile, projectRoot, config } = resolved;
   console.log("\u{1F4E6} Building Lynx project (release)...");
   execSync9("npm run build", { stdio: "inherit", cwd: lynxProjectDir });
-  if (!fs23.existsSync(lynxBundlePath)) {
+  if (!fs24.existsSync(lynxBundlePath)) {
     console.error(`\u274C Bundle not found at ${lynxBundlePath}`);
     process.exit(1);
   }
-  const outDir = path24.join(projectRoot, EMBEDDABLE_DIR);
-  fs23.mkdirSync(outDir, { recursive: true });
-  const distDir = path24.dirname(lynxBundlePath);
+  const outDir = path25.join(projectRoot, EMBEDDABLE_DIR);
+  fs24.mkdirSync(outDir, { recursive: true });
+  const distDir = path25.dirname(lynxBundlePath);
   copyDistAssets(distDir, outDir, lynxBundleFile);
   const modules = discoverModules(projectRoot);
   const androidModules = modules.filter((m) => m.config.android);
   const abiFilters = resolveAbiFilters(config);
-  const androidDir = path24.join(outDir, "android");
-  if (fs23.existsSync(androidDir)) fs23.rmSync(androidDir, { recursive: true });
-  fs23.mkdirSync(androidDir, { recursive: true });
+  const androidDir = path25.join(outDir, "android");
+  if (fs24.existsSync(androidDir)) fs24.rmSync(androidDir, { recursive: true });
+  fs24.mkdirSync(androidDir, { recursive: true });
   generateAndroidLibrary(
     outDir,
     androidDir,
@@ -6111,23 +6319,23 @@ async function buildEmbeddable(opts = {}) {
     modules,
     abiFilters
   );
-  const gradlewPath = path24.join(androidDir, "gradlew");
+  const gradlewPath = path25.join(androidDir, "gradlew");
   const devAppDir = findDevAppPackage(projectRoot);
   const existingGradleDirs = [
-    path24.join(projectRoot, "android"),
-    devAppDir ? path24.join(devAppDir, "android") : null
+    path25.join(projectRoot, "android"),
+    devAppDir ? path25.join(devAppDir, "android") : null
   ].filter(Boolean);
   let hasWrapper = false;
   for (const d of existingGradleDirs) {
-    if (fs23.existsSync(path24.join(d, "gradlew"))) {
+    if (fs24.existsSync(path25.join(d, "gradlew"))) {
       for (const name of ["gradlew", "gradlew.bat", "gradle"]) {
-        const src = path24.join(d, name);
-        if (fs23.existsSync(src)) {
-          const dest = path24.join(androidDir, name);
-          if (fs23.statSync(src).isDirectory()) {
-            fs23.cpSync(src, dest, { recursive: true });
+        const src = path25.join(d, name);
+        if (fs24.existsSync(src)) {
+          const dest = path25.join(androidDir, name);
+          if (fs24.statSync(src).isDirectory()) {
+            fs24.cpSync(src, dest, { recursive: true });
           } else {
-            fs23.copyFileSync(src, dest);
+            fs24.copyFileSync(src, dest);
           }
         }
       }
@@ -6146,10 +6354,10 @@ async function buildEmbeddable(opts = {}) {
     console.error("\u274C Android AAR build failed. Run manually: cd embeddable/android && ./gradlew :lib:assembleRelease");
     throw e;
   }
-  const aarSrc = path24.join(androidDir, "lib", "build", "outputs", "aar", "lib-release.aar");
-  const aarDest = path24.join(outDir, "tamer-embeddable.aar");
-  if (fs23.existsSync(aarSrc)) {
-    fs23.copyFileSync(aarSrc, aarDest);
+  const aarSrc = path25.join(androidDir, "lib", "build", "outputs", "aar", "lib-release.aar");
+  const aarDest = path25.join(outDir, "tamer-embeddable.aar");
+  if (fs24.existsSync(aarSrc)) {
+    fs24.copyFileSync(aarSrc, aarDest);
     console.log(`   - tamer-embeddable.aar`);
   }
   const snippetAndroid = `// Add to your app's build.gradle:
@@ -6160,7 +6368,7 @@ async function buildEmbeddable(opts = {}) {
 // LynxEmbeddable.init(applicationContext)
 // val lynxView = LynxEmbeddable.buildLynxView(containerViewGroup)
 `;
-  fs23.writeFileSync(path24.join(outDir, "snippet-android.kt"), snippetAndroid);
+  fs24.writeFileSync(path25.join(outDir, "snippet-android.kt"), snippetAndroid);
   generateIosPod(outDir, projectRoot, lynxBundlePath, lynxBundleFile, modules);
   const readme = `# Embeddable Lynx Bundle
@@ -6191,7 +6399,7 @@ Add the \`Podfile.snippet\` entries to your Podfile (inside your app target), th
 - [Embedding LynxView](https://lynxjs.org/guide/embed-lynx-to-native)
 `;
-  fs23.writeFileSync(path24.join(outDir, "README.md"), readme);
+  fs24.writeFileSync(path25.join(outDir, "README.md"), readme);
   console.log(`
 \u2705 Embeddable output at ${outDir}/`);
   console.log("   - main.lynx.bundle");
@@ -6203,20 +6411,20 @@ Add the \`Podfile.snippet\` entries to your Podfile (inside your app target), th
   console.log("   - README.md");
 }
 function generateIosPod(outDir, projectRoot, lynxBundlePath, lynxBundleFile, modules) {
-  const iosDir = path24.join(outDir, "ios");
-  const podDir = path24.join(iosDir, "TamerEmbeddable");
-  const resourcesDir = path24.join(podDir, "Resources");
-  fs23.mkdirSync(resourcesDir, { recursive: true });
-  fs23.copyFileSync(lynxBundlePath, path24.join(resourcesDir, lynxBundleFile));
+  const iosDir = path25.join(outDir, "ios");
+  const podDir = path25.join(iosDir, "TamerEmbeddable");
+  const resourcesDir = path25.join(podDir, "Resources");
+  fs24.mkdirSync(resourcesDir, { recursive: true });
+  fs24.copyFileSync(lynxBundlePath, path25.join(resourcesDir, lynxBundleFile));
   const iosModules = modules.filter((m) => m.config.ios);
   const podDeps = iosModules.map((p) => {
     const podspecPath = p.config.ios?.podspecPath || ".";
-    const podspecDir = path24.join(p.packagePath, podspecPath);
-    if (!fs23.existsSync(podspecDir)) return null;
-    const files = fs23.readdirSync(podspecDir);
+    const podspecDir = path25.join(p.packagePath, podspecPath);
+    if (!fs24.existsSync(podspecDir)) return null;
+    const files = fs24.readdirSync(podspecDir);
     const podspecFile = files.find((f) => f.endsWith(".podspec"));
     const podName = podspecFile ? podspecFile.replace(".podspec", "") : p.name.split("/").pop().replace(/-/g, "");
-    const absPath = path24.resolve(podspecDir);
+    const absPath = path25.resolve(podspecDir);
     return { podName, absPath };
   }).filter(Boolean);
   const podDepLines = podDeps.map((d) => `  s.dependency '${d.podName}'`).join("\n");
@@ -6256,9 +6464,9 @@ end
   });
   const swiftImports = iosModules.map((p) => {
     const podspecPath = p.config.ios?.podspecPath || ".";
-    const podspecDir = path24.join(p.packagePath, podspecPath);
-    if (!fs23.existsSync(podspecDir)) return null;
-    const files = fs23.readdirSync(podspecDir);
+    const podspecDir = path25.join(p.packagePath, podspecPath);
+    if (!fs24.existsSync(podspecDir)) return null;
+    const files = fs24.readdirSync(podspecDir);
     const podspecFile = files.find((f) => f.endsWith(".podspec"));
     return podspecFile ? podspecFile.replace(".podspec", "") : null;
   }).filter(Boolean);
@@ -6277,17 +6485,17 @@ ${regBlock}
     }
 }
 `;
-  fs23.writeFileSync(path24.join(iosDir, "TamerEmbeddable.podspec"), podspecContent);
-  fs23.writeFileSync(path24.join(podDir, "LynxEmbeddable.swift"), lynxEmbeddableSwift);
-  const absIosDir = path24.resolve(iosDir);
+  fs24.writeFileSync(path25.join(iosDir, "TamerEmbeddable.podspec"), podspecContent);
+  fs24.writeFileSync(path25.join(podDir, "LynxEmbeddable.swift"), lynxEmbeddableSwift);
+  const absIosDir = path25.resolve(iosDir);
   const podfileSnippet = `# Paste into your app target in Podfile:
 pod 'TamerEmbeddable', :path => '${absIosDir}'
 ${podDeps.map((d) => `pod '${d.podName}', :path => '${d.absPath}'`).join("\n")}
 `;
-  fs23.writeFileSync(path24.join(iosDir, "Podfile.snippet"), podfileSnippet);
-  fs23.writeFileSync(
-    path24.join(outDir, "snippet-ios.swift"),
+  fs24.writeFileSync(path25.join(iosDir, "Podfile.snippet"), podfileSnippet);
+  fs24.writeFileSync(
+    path25.join(outDir, "snippet-ios.swift"),
     `// Add LynxEmbeddable.initEnvironment() in your AppDelegate/SceneDelegate before presenting LynxView.
 // Then create LynxView with your bundle URL (main.lynx.bundle is in the pod resources).
 `
@@ -6295,8 +6503,8 @@ ${podDeps.map((d) => `pod '${d.podName}', :path => '${d.absPath}'`).join("\n")}
 }
 // src/common/add.ts
-import fs24 from "fs";
-import path25 from "path";
+import fs25 from "fs";
+import path26 from "path";
 import { execFile, execSync as execSync10 } from "child_process";
 import { promisify } from "util";
 import semver from "semver";
@@ -6311,21 +6519,15 @@ var CORE_PACKAGES = [
   "@tamer4lynx/tamer-icons"
 ];
 var DEV_STACK_PACKAGES = [
-  "@tamer4lynx/jiggle",
-  "@tamer4lynx/tamer-app-shell",
-  "@tamer4lynx/tamer-biometric",
   "@tamer4lynx/tamer-dev-app",
   "@tamer4lynx/tamer-dev-client",
-  "@tamer4lynx/tamer-display-browser",
+  "@tamer4lynx/tamer-app-shell",
   "@tamer4lynx/tamer-icons",
   "@tamer4lynx/tamer-insets",
-  "@tamer4lynx/tamer-linking",
   "@tamer4lynx/tamer-plugin",
   "@tamer4lynx/tamer-router",
   "@tamer4lynx/tamer-screen",
-  "@tamer4lynx/tamer-secure-store",
-  "@tamer4lynx/tamer-system-ui",
-  "@tamer4lynx/tamer-transports"
+  "@tamer4lynx/tamer-system-ui"
 ];
 var PACKAGE_ALIASES = {};
 async function getHighestPublishedVersion(fullName) {
@@ -6353,9 +6555,9 @@ async function normalizeTamerInstallSpec(pkg) {
   return `${pkg}@prerelease`;
 }
 function detectPackageManager2(cwd) {
-  const dir = path25.resolve(cwd);
-  if (fs24.existsSync(path25.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs24.existsSync(path25.join(dir, "bun.lockb"))) return "bun";
+  const dir = path26.resolve(cwd);
+  if (fs25.existsSync(path26.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs25.existsSync(path26.join(dir, "bun.lockb"))) return "bun";
   return "npm";
 }
 function runInstall(cwd, packages, pm) {
@@ -6407,13 +6609,13 @@ async function add(packages = []) {
 // src/common/signing.tsx
 import { useState as useState6, useEffect as useEffect4, useRef as useRef2 } from "react";
 import { render as render3, Text as Text10, Box as Box9 } from "ink";
-import fs27 from "fs";
-import path28 from "path";
+import fs28 from "fs";
+import path29 from "path";
 // src/common/androidKeystore.ts
 import { execFileSync } from "child_process";
-import fs25 from "fs";
-import path26 from "path";
+import fs26 from "fs";
+import path27 from "path";
 function normalizeJavaHome(raw) {
   if (!raw) return void 0;
   const t = raw.trim().replace(/^["']|["']$/g, "");
@@ -6426,7 +6628,7 @@ function discoverJavaHomeMacOs() {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim().split("\n")[0]?.trim();
-    if (out && fs25.existsSync(path26.join(out, "bin", "keytool"))) return out;
+    if (out && fs26.existsSync(path27.join(out, "bin", "keytool"))) return out;
   } catch {
   }
   return void 0;
@@ -6436,13 +6638,13 @@ function resolveKeytoolPath() {
   const win = process.platform === "win32";
   const keytoolName = win ? "keytool.exe" : "keytool";
   if (jh) {
-    const p = path26.join(jh, "bin", keytoolName);
-    if (fs25.existsSync(p)) return p;
+    const p = path27.join(jh, "bin", keytoolName);
+    if (fs26.existsSync(p)) return p;
   }
   const mac = discoverJavaHomeMacOs();
   if (mac) {
-    const p = path26.join(mac, "bin", keytoolName);
-    if (fs25.existsSync(p)) return p;
+    const p = path27.join(mac, "bin", keytoolName);
+    if (fs26.existsSync(p)) return p;
   }
   return "keytool";
 }
@@ -6457,16 +6659,16 @@ function keytoolAvailable() {
   };
   if (tryRun("keytool")) return true;
   const fromJavaHome = resolveKeytoolPath();
-  if (fromJavaHome !== "keytool" && fs25.existsSync(fromJavaHome)) {
+  if (fromJavaHome !== "keytool" && fs26.existsSync(fromJavaHome)) {
     return tryRun(fromJavaHome);
   }
   return false;
 }
 function generateReleaseKeystore(opts) {
   const keytool = resolveKeytoolPath();
-  const dir = path26.dirname(opts.keystoreAbsPath);
-  fs25.mkdirSync(dir, { recursive: true });
-  if (fs25.existsSync(opts.keystoreAbsPath)) {
+  const dir = path27.dirname(opts.keystoreAbsPath);
+  fs26.mkdirSync(dir, { recursive: true });
+  if (fs26.existsSync(opts.keystoreAbsPath)) {
     throw new Error(`Keystore already exists: ${opts.keystoreAbsPath}`);
   }
   if (!opts.storePassword || !opts.keyPassword) {
@@ -6504,13 +6706,13 @@ function generateReleaseKeystore(opts) {
 }
 // src/common/appendEnvFile.ts
-import fs26 from "fs";
-import path27 from "path";
+import fs27 from "fs";
+import path28 from "path";
 import { parse } from "dotenv";
 function keysDefinedInFile(filePath) {
-  if (!fs26.existsSync(filePath)) return /* @__PURE__ */ new Set();
+  if (!fs27.existsSync(filePath)) return /* @__PURE__ */ new Set();
   try {
-    return new Set(Object.keys(parse(fs26.readFileSync(filePath, "utf8"))));
+    return new Set(Object.keys(parse(fs27.readFileSync(filePath, "utf8"))));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -6525,11 +6727,11 @@ function formatEnvLine(key, value) {
 function appendEnvVarsIfMissing(projectRoot, vars) {
   const entries = Object.entries(vars).filter(([, v]) => v !== void 0 && v !== "");
   if (entries.length === 0) return null;
-  const envLocal = path27.join(projectRoot, ".env.local");
-  const envDefault = path27.join(projectRoot, ".env");
+  const envLocal = path28.join(projectRoot, ".env.local");
+  const envDefault = path28.join(projectRoot, ".env");
   let target;
-  if (fs26.existsSync(envLocal)) target = envLocal;
-  else if (fs26.existsSync(envDefault)) target = envDefault;
+  if (fs27.existsSync(envLocal)) target = envLocal;
+  else if (fs27.existsSync(envDefault)) target = envDefault;
   else target = envLocal;
   const existing = keysDefinedInFile(target);
   const lines = [];
@@ -6541,20 +6743,20 @@ function appendEnvVarsIfMissing(projectRoot, vars) {
   }
   if (lines.length === 0) {
     return {
-      file: path27.basename(target),
+      file: path28.basename(target),
       keys: [],
       skippedAll: entries.length > 0
     };
   }
   let prefix = "";
-  if (fs26.existsSync(target)) {
-    const cur = fs26.readFileSync(target, "utf8");
+  if (fs27.existsSync(target)) {
+    const cur = fs27.readFileSync(target, "utf8");
     prefix = cur.length === 0 ? "" : cur.endsWith("\n") ? cur : `${cur}
 `;
   }
   const block = lines.join("\n") + "\n";
-  fs26.writeFileSync(target, prefix + block, "utf8");
-  return { file: path27.basename(target), keys: appendedKeys };
+  fs27.writeFileSync(target, prefix + block, "utf8");
+  return { file: path28.basename(target), keys: appendedKeys };
 }
 // src/common/signing.tsx
@@ -6660,7 +6862,7 @@ function SigningWizard({ platform: initialPlatform }) {
       try {
         const resolved = resolveHostPaths();
         const rel = state.android.genKeystorePath.trim() || "android/release.keystore";
-        abs = path28.isAbsolute(rel) ? rel : path28.join(resolved.projectRoot, rel);
+        abs = path29.isAbsolute(rel) ? rel : path29.join(resolved.projectRoot, rel);
         const alias = state.android.keyAlias.trim() || "release";
         const pw = state.android.genPassword;
         const pkg = resolved.config.android?.packageName ?? "com.example.app";
@@ -6687,7 +6889,7 @@ function SigningWizard({ platform: initialPlatform }) {
         }));
       } catch (e) {
         const msg = e.message;
-        if (abs && fs27.existsSync(abs) && (msg.includes("already exists") || msg.includes("Keystore already exists"))) {
+        if (abs && fs28.existsSync(abs) && (msg.includes("already exists") || msg.includes("Keystore already exists"))) {
           if (cancelled || runId !== generateRunId.current) return;
           const rel = state.android.genKeystorePath.trim() || "android/release.keystore";
           const alias = state.android.keyAlias.trim() || "release";
@@ -6727,11 +6929,11 @@ function SigningWizard({ platform: initialPlatform }) {
   const saveConfig = async () => {
     try {
       const resolved = resolveHostPaths();
-      const configPath = path28.join(resolved.projectRoot, "tamer.config.json");
+      const configPath = path29.join(resolved.projectRoot, "tamer.config.json");
       let config = {};
       let androidEnvAppend = null;
-      if (fs27.existsSync(configPath)) {
-        config = JSON.parse(fs27.readFileSync(configPath, "utf8"));
+      if (fs28.existsSync(configPath)) {
+        config = JSON.parse(fs28.readFileSync(configPath, "utf8"));
       }
       if (state.platform === "android" || state.platform === "both") {
         config.android = config.android || {};
@@ -6758,10 +6960,10 @@ function SigningWizard({ platform: initialPlatform }) {
           ...state.ios.provisioningProfileSpecifier && { provisioningProfileSpecifier: state.ios.provisioningProfileSpecifier }
         };
       }
-      fs27.writeFileSync(configPath, JSON.stringify(config, null, 2));
-      const gitignorePath = path28.join(resolved.projectRoot, ".gitignore");
-      if (fs27.existsSync(gitignorePath)) {
-        let gitignore = fs27.readFileSync(gitignorePath, "utf8");
+      fs28.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      const gitignorePath = path29.join(resolved.projectRoot, ".gitignore");
+      if (fs28.existsSync(gitignorePath)) {
+        let gitignore = fs28.readFileSync(gitignorePath, "utf8");
         const additions = [
           ".env.local",
           "*.jks",
@@ -6774,7 +6976,7 @@ ${addition}
 `;
           }
         }
-        fs27.writeFileSync(gitignorePath, gitignore);
+        fs28.writeFileSync(gitignorePath, gitignore);
       }
       setState((s) => ({
         ...s,
@@ -7032,13 +7234,13 @@ async function signing(platform) {
 }
 // src/common/productionSigning.ts
-import fs28 from "fs";
-import path29 from "path";
+import fs29 from "fs";
+import path30 from "path";
 function isAndroidSigningConfigured(resolved) {
   const signing2 = resolved.config.android?.signing;
   const hasConfig = Boolean(signing2?.keystoreFile?.trim() && signing2?.keyAlias?.trim());
-  const signingProps = path29.join(resolved.androidDir, "signing.properties");
-  const hasProps = fs28.existsSync(signingProps);
+  const signingProps = path30.join(resolved.androidDir, "signing.properties");
+  const hasProps = fs29.existsSync(signingProps);
   return hasConfig || hasProps;
 }
 function isIosSigningConfigured(resolved) {
@@ -7068,14 +7270,7 @@ function assertProductionSigningReady(filter) {
 }
 // index.ts
-function readCliVersion() {
-  const root = path30.dirname(fileURLToPath(import.meta.url));
-  const here = path30.join(root, "package.json");
-  const parent = path30.join(root, "..", "package.json");
-  const pkgPath = fs29.existsSync(here) ? here : parent;
-  return JSON.parse(fs29.readFileSync(pkgPath, "utf8")).version;
-}
-var version = readCliVersion();
+var version = getCliVersion();
 function validateBuildMode(debug, release, production) {
   const modes = [debug, release, production].filter(Boolean).length;
   if (modes > 1) {
@@ -7114,7 +7309,10 @@ program.command("create <target>").description("Create a project or extension. T
   console.error(`Invalid create target: ${target}. Use ios | android | module | element | service | combo`);
   process.exit(1);
 });
-program.command("build [platform]").description("Build app. Platform: ios | android (default: both)").option("-e, --embeddable", "Output embeddable bundle + code for existing apps. Use with --release.").option("-d, --debug", "Debug build with dev client embedded (default)").option("-r, --release", "Release build without dev client (unsigned)").option("-p, --production", "Production build for app store (signed)").option("-i, --install", "Install after building").action(async (platform, opts) => {
+program.command("build [platform]").description("Build app. Platform: ios | android (default: both)").option("-e, --embeddable", "Output embeddable bundle + code for existing apps. Use with --release.").option("-d, --debug", "Debug build with dev client embedded (default)").option("-r, --release", "Release build without dev client (unsigned)").option("-p, --production", "Production build for app store (signed)").option(
+  "-i, --install",
+  "Install after build (iOS: simulator with -d; connected device with -p)"
+).action(async (platform, opts) => {
   validateBuildMode(opts.debug, opts.release, opts.production);
   const release = opts.release === true || opts.production === true;
   const production = opts.production === true;
@@ -7291,10 +7489,10 @@ program.command("ios <subcommand>").description("(Legacy) Use: t4l <command> ios
   process.exit(1);
 });
 program.command("autolink-toggle").alias("autolink").description("Toggle autolink on/off in tamer.config.json (controls postinstall linking)").action(async () => {
-  const configPath = path30.join(process.cwd(), "tamer.config.json");
+  const configPath = path31.join(process.cwd(), "tamer.config.json");
   let config = {};
-  if (fs29.existsSync(configPath)) {
-    config = JSON.parse(fs29.readFileSync(configPath, "utf8"));
+  if (fs30.existsSync(configPath)) {
+    config = JSON.parse(fs30.readFileSync(configPath, "utf8"));
   }
   if (config.autolink) {
     delete config.autolink;
@@ -7303,7 +7501,7 @@ program.command("autolink-toggle").alias("autolink").description("Toggle autolin
     config.autolink = true;
     console.log("Autolink enabled in tamer.config.json");
   }
-  fs29.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  fs30.writeFileSync(configPath, JSON.stringify(config, null, 2));
   console.log(`Updated ${configPath}`);
 });
 if (process.argv.length <= 2 || process.argv.length === 3 && process.argv[2] === "init") {