@craft-native/android 0.0.92 → 0.0.94

package/dist/index.js

@@ -0,0 +1,702 @@
+// @bun
+// src/index.ts
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "path";
+var {$ } = globalThis.Bun;
+
+// src/promise-runtime.ts
+var ANDROID_PROMISE_RUNTIME = `
+if (window.__craftRejectPendingPromises) {
+    window.__craftRejectPendingPromises('Android bridge reinitialized');
+}
+if (window.__craftRejectPermissionRequests) {
+    window.__craftRejectPermissionRequests('Android bridge reinitialized');
+}
+window.__craftPromiseRuntimeClosed = false;
+window.__craftPendingPromises = Object.create(null);
+window.__craftPromise = function(channel, resolveName, rejectName, invoke, timeoutMs, timeoutError) {
+    if (window.__craftPromiseRuntimeClosed) {
+        return Promise.reject(new Error('Android bridge is closed'));
+    }
+    if (window.__craftPendingPromises[channel]) {
+        return Promise.reject(new Error('A '.concat(channel, ' request is already in progress')));
+    }
+
+    return new Promise(function(resolve, reject) {
+        var entry = {settled: false, timer: null, settle: null};
+        var resolveCallback;
+        var rejectCallback;
+
+        entry.settle = function(succeeded, value) {
+            if (entry.settled || window.__craftPendingPromises[channel] !== entry) return;
+            entry.settled = true;
+            if (entry.timer !== null) clearTimeout(entry.timer);
+            if (window[resolveName] === resolveCallback) window[resolveName] = null;
+            if (window[rejectName] === rejectCallback) window[rejectName] = null;
+            delete window.__craftPendingPromises[channel];
+            if (succeeded) resolve(value);
+            else reject(value);
+        };
+
+        resolveCallback = function(value) {
+            entry.settle(true, value);
+        };
+        rejectCallback = function(error) {
+            entry.settle(false, error);
+        };
+        window[resolveName] = resolveCallback;
+        window[rejectName] = rejectCallback;
+        window.__craftPendingPromises[channel] = entry;
+
+        if (timeoutMs > 0) {
+            entry.timer = setTimeout(function() {
+                entry.settle(false, timeoutError || new Error(channel.concat(' request timed out')));
+            }, timeoutMs);
+        }
+
+        try {
+            invoke();
+        }
+        catch (error) {
+            entry.settle(false, error);
+        }
+    });
+};
+
+window.__craftRejectPendingPromises = function(message) {
+    window.__craftPromiseRuntimeClosed = true;
+    Object.keys(window.__craftPendingPromises).forEach(function(channel) {
+        var entry = window.__craftPendingPromises[channel];
+        if (entry) entry.settle(false, new Error(message || 'Android bridge closed'));
+    });
+};
+`;
+function renderAndroidPromiseRuntime(indent = "") {
+  return ANDROID_PROMISE_RUNTIME.trim().split(`
+`).map((line) => `${indent}${line}`).join(`
+`);
+}
+
+// src/index.ts
+var TEMPLATES_DIR = join(dirname(import.meta.dir), "templates");
+var LOCAL_DEVELOPMENT_HOSTS = new Set(["localhost", "127.0.0.1", "10.0.2.2"]);
+var KOTLIN_KEYWORDS = new Set([
+  "as",
+  "break",
+  "class",
+  "continue",
+  "do",
+  "else",
+  "false",
+  "for",
+  "fun",
+  "if",
+  "in",
+  "interface",
+  "is",
+  "null",
+  "object",
+  "package",
+  "return",
+  "super",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typealias",
+  "typeof",
+  "val",
+  "var",
+  "when",
+  "while"
+]);
+var ANDROID_MIN_SDK = 26;
+var DEFAULT_CONFIG = {
+  version: "1.0.0",
+  versionCode: 1,
+  darkMode: true,
+  backgroundColor: "#0b1712",
+  enableSpeechRecognition: false,
+  enableHaptics: false,
+  enableShare: false,
+  enableCamera: false,
+  enableBiometric: false,
+  enablePushNotifications: false,
+  enableSecureStorage: false,
+  enableGeolocation: false,
+  enableBackgroundLocation: false,
+  enableHealthConnect: false,
+  enableKeepAwake: false,
+  enableDeepLinks: false,
+  urlSchemes: [],
+  trustedOrigins: [],
+  minSdk: ANDROID_MIN_SDK,
+  compileSdk: 36,
+  targetSdk: 35
+};
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function escapeKotlinString(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', "\\\"").replaceAll("$", "\\$").replaceAll("\r", "\\r").replaceAll(`
+`, "\\n");
+}
+function generatedPackageSegment(name) {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9_]/g, "");
+  if (!normalized)
+    return "app";
+  return /^[a-z_]/.test(normalized) ? normalized : `app${normalized}`;
+}
+function generatedGradleProjectName(name) {
+  const invalidCharacters = ["/", "\\", ":", "<", ">", '"', "?", "*", "|"];
+  const normalized = invalidCharacters.reduce((value, character) => value.replaceAll(character, "-"), name).trim();
+  return normalized || "craft-app";
+}
+function requireRegularFile(path, label) {
+  if (!existsSync(path))
+    throw new Error(`${label} not found: ${path}`);
+  if (!statSync(path).isFile())
+    throw new Error(`${label} must be a file: ${path}`);
+}
+function containsPath(parent, candidate) {
+  const relativePath = relative(parent, candidate);
+  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+}
+function validateGoogleServicesFile(path, packageName) {
+  requireRegularFile(path, "Google services file");
+  let document;
+  try {
+    document = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new Error(`Google services file must contain valid JSON: ${path}`, { cause: error });
+  }
+  const matchingClient = document.client?.some((client) => {
+    return client.client_info?.android_client_info?.package_name === packageName;
+  });
+  if (!matchingClient) {
+    throw new Error(`Google services file has no client for Android package ${packageName}: ${path}`);
+  }
+}
+function androidWebUrl(value, field) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`Invalid ${field}: ${value}`);
+  }
+  const localDevelopment = url.protocol === "http:" && LOCAL_DEVELOPMENT_HOSTS.has(url.hostname);
+  if (url.protocol !== "https:" && !localDevelopment || url.username || url.password) {
+    throw new Error(`${field} must use HTTPS or local HTTP without credentials: ${value}`);
+  }
+  return url;
+}
+function normalizeAndroidNetworkConfig(config) {
+  const schemes = config.urlSchemes?.map((value) => value.trim().toLowerCase()) ?? [];
+  if (schemes.some((value) => !/^[a-z][a-z0-9+.-]*$/.test(value))) {
+    throw new Error("Android deep-link schemes must be valid URI schemes");
+  }
+  config.urlSchemes = [...new Set(schemes)];
+  if (config.enableDeepLinks && config.urlSchemes.length === 0) {
+    throw new Error("Android deep links require at least one URL scheme");
+  }
+  const trustedOrigins = (config.trustedOrigins ?? []).map((value) => {
+    return androidWebUrl(value, "Android trusted origin").origin;
+  });
+  if (config.devServerURL) {
+    const devServer = androidWebUrl(config.devServerURL, "Android dev server URL");
+    config.devServerURL = devServer.toString();
+    trustedOrigins.push(devServer.origin);
+  }
+  config.trustedOrigins = [...new Set(trustedOrigins)];
+}
+function validateAndroidConfig(config) {
+  if (!config.appName.trim())
+    throw new Error("Android app name must not be empty");
+  const packageSegments = config.packageName.split(".");
+  if (packageSegments.length < 2 || packageSegments.some((segment) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment) || KOTLIN_KEYWORDS.has(segment))) {
+    throw new Error(`Invalid Android package name: ${config.packageName}`);
+  }
+  if (!/^#(?:[\dA-F]{3,4}|[\dA-F]{6}|[\dA-F]{8})$/i.test(config.backgroundColor ?? "")) {
+    throw new Error(`Invalid Android background color: ${config.backgroundColor}`);
+  }
+  for (const [name, value] of [
+    ["versionCode", config.versionCode],
+    ["minSdk", config.minSdk],
+    ["compileSdk", config.compileSdk],
+    ["targetSdk", config.targetSdk]
+  ]) {
+    if (!Number.isInteger(value) || Number(value) < 1) {
+      throw new Error(`Android ${name} must be a positive integer`);
+    }
+  }
+  if (Number(config.minSdk) < ANDROID_MIN_SDK) {
+    throw new Error(`Android minSdk must be at least ${ANDROID_MIN_SDK} (Android 8.0) for the Craft runtime`);
+  }
+  if (Number(config.minSdk) > Number(config.targetSdk)) {
+    throw new Error("Android minSdk must not exceed targetSdk");
+  }
+  if (Number(config.targetSdk) > Number(config.compileSdk)) {
+    throw new Error("Android targetSdk must not exceed compileSdk");
+  }
+}
+function writeAndroidConfig(output, config) {
+  writeFileSync(join(output, "craft.config.json"), JSON.stringify(config, null, 2));
+  const runtimeConfig = { ...config };
+  delete runtimeConfig.appIconPath;
+  delete runtimeConfig.googleServicesFile;
+  writeFileSync(join(output, "app/src/main/assets/craft.config.json"), JSON.stringify(runtimeConfig, null, 2));
+}
+function syncAndroidWebAssets(source, output) {
+  const sourcePath = resolve(source);
+  if (!existsSync(sourcePath))
+    throw new Error(`Web asset path not found: ${source}`);
+  const sourceStat = statSync(sourcePath);
+  if (!sourceStat.isDirectory() && !sourceStat.isFile()) {
+    throw new Error(`Web asset path must be a file or directory: ${source}`);
+  }
+  const assetsDir = resolve(output, "app/src/main/assets");
+  if (containsPath(sourcePath, assetsDir) || containsPath(assetsDir, sourcePath)) {
+    throw new Error(`Web asset source must not overlap generated asset directory: ${source}`);
+  }
+  if (sourceStat.isDirectory()) {
+    requireRegularFile(join(sourcePath, "index.html"), "Web asset directory entry point");
+  }
+  const configPath = join(assetsDir, "craft.config.json");
+  const config = existsSync(configPath) ? readFileSync(configPath) : undefined;
+  rmSync(assetsDir, { recursive: true, force: true });
+  mkdirSync(assetsDir, { recursive: true });
+  if (sourceStat.isDirectory())
+    cpSync(sourcePath, assetsDir, { recursive: true });
+  else
+    cpSync(sourcePath, join(assetsDir, "index.html"));
+  if (!existsSync(join(assetsDir, "index.html")))
+    throw new Error(`Web asset directory must contain index.html: ${source}`);
+  if (config)
+    writeFileSync(configPath, config);
+}
+function renderAndroidPermissions(config) {
+  const permissions = new Set(["android.permission.INTERNET", "android.permission.ACCESS_NETWORK_STATE"]);
+  if (config.enableSpeechRecognition)
+    permissions.add("android.permission.RECORD_AUDIO");
+  if (config.enableCamera)
+    permissions.add("android.permission.CAMERA");
+  if (config.enableHaptics)
+    permissions.add("android.permission.VIBRATE");
+  if (config.enableBiometric)
+    permissions.add("android.permission.USE_BIOMETRIC");
+  if (config.enableGeolocation || config.enableBackgroundLocation) {
+    permissions.add("android.permission.ACCESS_FINE_LOCATION");
+    permissions.add("android.permission.ACCESS_COARSE_LOCATION");
+  }
+  if (config.enableBackgroundLocation) {
+    permissions.add("android.permission.ACCESS_BACKGROUND_LOCATION");
+    permissions.add("android.permission.FOREGROUND_SERVICE");
+    permissions.add("android.permission.FOREGROUND_SERVICE_LOCATION");
+  }
+  if (config.enablePushNotifications)
+    permissions.add("android.permission.POST_NOTIFICATIONS");
+  if (config.enableKeepAwake)
+    permissions.add("android.permission.WAKE_LOCK");
+  if (config.enableHealthConnect) {
+    permissions.add("android.permission.health.READ_STEPS");
+    permissions.add("android.permission.health.READ_HEART_RATE");
+    permissions.add("android.permission.health.READ_ACTIVE_CALORIES_BURNED");
+    permissions.add("android.permission.health.READ_DISTANCE");
+    permissions.add("android.permission.health.READ_EXERCISE");
+    permissions.add("android.permission.health.WRITE_EXERCISE");
+    permissions.add("android.permission.health.WRITE_ACTIVE_CALORIES_BURNED");
+    permissions.add("android.permission.health.WRITE_DISTANCE");
+  }
+  return [...permissions].map((permission) => `    <uses-permission android:name="${permission}" />`).join(`
+`);
+}
+function renderAndroidDeepLinks(config) {
+  if (!config.enableDeepLinks)
+    return "";
+  const schemes = [...new Set(config.urlSchemes?.map((value) => value.trim()).filter((value) => /^[a-z][a-z0-9+.-]*$/i.test(value)) ?? [])];
+  return schemes.map((scheme) => `            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="${scheme}" />
+            </intent-filter>`).join(`
+`);
+}
+var RUNTIME_ABIS = ["arm64-v8a", "x86_64"];
+function resolveRuntimeDir(override) {
+  if (override === null)
+    return null;
+  const dir = override ?? process.env.CRAFT_ANDROID_RUNTIME;
+  if (!dir)
+    return null;
+  if (!existsSync(dir)) {
+    const source = override === undefined ? "CRAFT_ANDROID_RUNTIME points at" : "runtimeDir is";
+    throw new Error(`${source} ${dir}, which does not exist.`);
+  }
+  return dir;
+}
+function installRuntime(output, runtimeDir) {
+  const found = RUNTIME_ABIS.map((abi) => ({ abi, source: join(runtimeDir, abi, "libcraft.so") })).filter((entry) => existsSync(entry.source));
+  if (found.length === 0) {
+    throw new Error(`${runtimeDir} has no <abi>/libcraft.so for any of ${RUNTIME_ABIS.join(", ")}. ` + "Run `zig build build-android-all -Doptimize=ReleaseSafe` in packages/zig and point at its zig-out/android.");
+  }
+  if (found.length < RUNTIME_ABIS.length) {
+    const missing = RUNTIME_ABIS.filter((abi) => !found.some((entry) => entry.abi === abi));
+    console.warn(`   \u26A0 only ${found.map((entry) => entry.abi).join(", ")} was found; ${missing.join(", ")} is missing. ` + "The app will fall back to the Kotlin shim on those devices.");
+  }
+  const dest = join(output, "app/src/main/jniLibs");
+  rmSync(dest, { force: true, recursive: true });
+  for (const { abi, source } of found) {
+    const abiDir = join(dest, abi);
+    mkdirSync(abiDir, { recursive: true });
+    cpSync(source, join(abiDir, "libcraft.so"));
+  }
+  return true;
+}
+async function init(options) {
+  const { name, packageName, output } = options;
+  console.log(`
+\u26A1 Initializing Craft Android project: ${name}`);
+  console.log(`   Output: ${output}
+`);
+  const finalPackageName = packageName || `com.craft.${generatedPackageSegment(name)}`;
+  const packagePath = finalPackageName.replace(/\./g, "/");
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...options.config,
+    appName: name,
+    packageName: finalPackageName
+  };
+  if (config.enableBackgroundLocation)
+    config.enableGeolocation = true;
+  if (config.enableHealthConnect) {
+    config.compileSdk = Math.max(config.compileSdk ?? 36, 36);
+  }
+  normalizeAndroidNetworkConfig(config);
+  validateAndroidConfig(config);
+  if (config.enablePushNotifications && !config.googleServicesFile) {
+    throw new Error("Android push notifications require a googleServicesFile");
+  }
+  if (config.googleServicesFile)
+    validateGoogleServicesFile(config.googleServicesFile, finalPackageName);
+  if (config.appIconPath)
+    requireRegularFile(config.appIconPath, "App icon");
+  const appIconExtension = config.appIconPath ? extname(config.appIconPath).toLowerCase() : undefined;
+  if (config.appIconPath && ![".gif", ".jpg", ".png", ".webp"].includes(appIconExtension ?? "")) {
+    throw new Error(`Unsupported Android app icon format: ${appIconExtension || "(none)"}`);
+  }
+  const dirs = [
+    output,
+    join(output, "app/src/main/java", packagePath),
+    join(output, "app/src/main/res/layout"),
+    join(output, "app/src/main/res/values"),
+    join(output, "app/src/main/res/drawable"),
+    join(output, "app/src/main/assets"),
+    join(output, "gradle/wrapper")
+  ];
+  if (existsSync(output) && !statSync(output).isDirectory()) {
+    throw new Error(`Android project output must be a directory: ${output}`);
+  }
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  writeAndroidConfig(output, config);
+  const hasGoogleServices = Boolean(config.googleServicesFile);
+  if (config.googleServicesFile) {
+    cpSync(config.googleServicesFile, join(output, "app/google-services.json"));
+  }
+  const mainActivityTemplate = readFileSync(join(TEMPLATES_DIR, "MainActivity.kt.template"), "utf-8");
+  const mainActivity = mainActivityTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name);
+  writeFileSync(join(output, "app/src/main/java", packagePath, "MainActivity.kt"), mainActivity);
+  const craftBridgeTemplate = readFileSync(join(TEMPLATES_DIR, "CraftBridge.kt.template"), "utf-8");
+  const craftBridge = craftBridgeTemplate.replace(/\{\{PROMISE_RUNTIME\}\}/g, () => renderAndroidPromiseRuntime("            ")).replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{ENABLE_SPEECH\}\}/g, String(Boolean(config.enableSpeechRecognition))).replace(/\{\{ENABLE_HAPTICS\}\}/g, String(Boolean(config.enableHaptics))).replace(/\{\{ENABLE_SHARE\}\}/g, String(Boolean(config.enableShare))).replace(/\{\{ENABLE_CAMERA\}\}/g, String(Boolean(config.enableCamera))).replace(/\{\{ENABLE_BIOMETRIC\}\}/g, String(Boolean(config.enableBiometric))).replace(/\{\{ENABLE_PUSH\}\}/g, String(Boolean(config.enablePushNotifications))).replace(/\{\{ENABLE_SECURE_STORAGE\}\}/g, String(Boolean(config.enableSecureStorage))).replace(/\{\{ENABLE_GEOLOCATION\}\}/g, String(Boolean(config.enableGeolocation))).replace(/\{\{ENABLE_BACKGROUND_LOCATION\}\}/g, String(Boolean(config.enableBackgroundLocation))).replace(/\{\{ENABLE_KEEP_AWAKE\}\}/g, String(Boolean(config.enableKeepAwake))).replace(/\{\{ENABLE_DEEP_LINKS\}\}/g, String(Boolean(config.enableDeepLinks))).replace(/\{\{ENABLE_HEALTH_CONNECT\}\}/g, String(Boolean(config.enableHealthConnect))).replace(/\{\{FIREBASE_IMPORT\}\}/g, config.enablePushNotifications ? "import com.google.firebase.messaging.FirebaseMessaging" : "").replace(/\{\{REGISTER_PUSH_IMPLEMENTATION\}\}/g, config.enablePushNotifications ? `activity.runOnUiThread {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+                && ContextCompat.checkSelfPermission(activity, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+                ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.POST_NOTIFICATIONS), 4204)
+            }
+            try {
+                FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
+                    val token = if (task.isSuccessful) task.result else null
+                    val callback = if (token.isNullOrBlank()) "window._craftPushReject" else "window._craftPushResolve"
+                    val payload = JSONObject.quote(token ?: task.exception?.message ?: "Firebase Cloud Messaging is not configured")
+                    evaluatePromiseJavascript("$callback && $callback($payload)")
+                }
+            } catch (error: Exception) {
+                val payload = JSONObject.quote(error.message ?: "Firebase Cloud Messaging is not configured")
+                evaluatePromiseJavascript("window._craftPushReject && window._craftPushReject($payload)")
+            }
+        }` : `evaluatePromiseJavascript(
+            "window._craftPushReject && window._craftPushReject('Push notifications are disabled')"
+        )`);
+  writeFileSync(join(output, "app/src/main/java", packagePath, "CraftBridge.kt"), craftBridge);
+  const craftNative = readFileSync(join(TEMPLATES_DIR, "CraftNative.kt.template"), "utf-8");
+  const nativeDir = join(output, "app/src/main/java/com/craft/runtime");
+  mkdirSync(nativeDir, { recursive: true });
+  writeFileSync(join(nativeDir, "CraftNative.kt"), craftNative);
+  const serviceTemplate = readFileSync(join(TEMPLATES_DIR, "LocationRecordingService.kt.template"), "utf-8");
+  writeFileSync(join(nativeDir, "LocationRecordingService.kt"), serviceTemplate);
+  const healthTemplate = readFileSync(join(TEMPLATES_DIR, config.enableHealthConnect ? "CraftHealthConnect.kt.template" : "CraftHealthConnectStub.kt.template"), "utf-8");
+  writeFileSync(join(output, "app/src/main/java", packagePath, "CraftHealthConnect.kt"), healthTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName));
+  const manifestTemplate = readFileSync(join(TEMPLATES_DIR, "AndroidManifest.xml.template"), "utf-8");
+  const manifest = manifestTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{PERMISSIONS\}\}/g, renderAndroidPermissions(config)).replace(/\{\{USES_CLEARTEXT\}\}/g, config.devServerURL?.startsWith("http://") ? "true" : "false").replace(/\{\{DEEP_LINK_INTENT_FILTERS\}\}/g, renderAndroidDeepLinks(config)).replace(/\{\{BACKGROUND_SERVICE\}\}/g, config.enableBackgroundLocation ? '        <service android:name="com.craft.runtime.LocationRecordingService" android:exported="false" android:foregroundServiceType="location" android:stopWithTask="false" />' : "").replace(/\{\{HEALTH_CONNECT_QUERIES\}\}/g, config.enableHealthConnect ? `    <queries>
+        <package android:name="com.google.android.apps.healthdata" />
+    </queries>` : "").replace(/\{\{HEALTH_CONNECT_RATIONALE\}\}/g, config.enableHealthConnect ? `            <intent-filter>
+                <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW_PERMISSION_USAGE" />
+                <category android:name="android.intent.category.HEALTH_PERMISSIONS" />
+            </intent-filter>` : "");
+  writeFileSync(join(output, "app/src/main/AndroidManifest.xml"), manifest);
+  const projectGradleTemplate = readFileSync(join(TEMPLATES_DIR, "build.gradle.kts.project.template"), "utf-8");
+  writeFileSync(join(output, "build.gradle.kts"), projectGradleTemplate.replace(/\{\{GOOGLE_SERVICES_PLUGIN\}\}/g, hasGoogleServices ? '    id("com.google.gms.google-services") version "4.4.2" apply false' : ""));
+  const appGradleTemplate = readFileSync(join(TEMPLATES_DIR, "build.gradle.kts.app.template"), "utf-8");
+  const appGradle = appGradleTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName).replace(/\{\{VERSION_NAME\}\}/g, escapeKotlinString(config.version || "1.0.0")).replace(/\{\{VERSION_CODE\}\}/g, String(config.versionCode || 1)).replace(/\{\{MIN_SDK\}\}/g, String(config.minSdk ?? ANDROID_MIN_SDK)).replace(/\{\{COMPILE_SDK\}\}/g, String(config.compileSdk || 36)).replace(/\{\{TARGET_SDK\}\}/g, String(config.targetSdk || 35)).replace(/\{\{GOOGLE_SERVICES_PLUGIN\}\}/g, hasGoogleServices ? '    id("com.google.gms.google-services")' : "").replace(/\{\{FIREBASE_MESSAGING_DEPENDENCY\}\}/g, config.enablePushNotifications ? '    implementation("com.google.firebase:firebase-messaging:24.1.0")' : "").replace(/\{\{HEALTH_CONNECT_DEPENDENCIES\}\}/g, config.enableHealthConnect ? `    implementation("androidx.health.connect:connect-client:1.1.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1")` : "");
+  writeFileSync(join(output, "app/build.gradle.kts"), appGradle);
+  const proguardTemplate = readFileSync(join(TEMPLATES_DIR, "proguard-rules.pro.template"), "utf-8");
+  writeFileSync(join(output, "app/proguard-rules.pro"), proguardTemplate.replace(/\{\{PACKAGE_NAME\}\}/g, finalPackageName));
+  const settingsTemplate = readFileSync(join(TEMPLATES_DIR, "settings.gradle.kts.template"), "utf-8");
+  const settings = settingsTemplate.replace(/\{\{APP_NAME\}\}/g, escapeKotlinString(generatedGradleProjectName(name)));
+  writeFileSync(join(output, "settings.gradle.kts"), settings);
+  const gradleProperties = `org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true
+`;
+  writeFileSync(join(output, "gradle.properties"), gradleProperties);
+  writeFileSync(join(output, "local.properties"), `# SDK location will be set by Android Studio
+`);
+  const gradleWrapperProps = `distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+`;
+  writeFileSync(join(output, "gradle/wrapper/gradle-wrapper.properties"), gradleWrapperProps);
+  const stringsXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">${escapeXml(name)}</string>
+</resources>
+`;
+  writeFileSync(join(output, "app/src/main/res/values/strings.xml"), stringsXml);
+  const colorsXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="primary">#1a1a2e</color>
+    <color name="primary_dark">#16162b</color>
+    <color name="accent">#4ade80</color>
+    <color name="background">${config.backgroundColor}</color>
+</resources>
+`;
+  writeFileSync(join(output, "app/src/main/res/values/colors.xml"), colorsXml);
+  const appIconXml = `<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path android:fillColor="${config.backgroundColor}" android:pathData="M0,0h108v108h-108z" />
+    <path android:fillColor="#10B981" android:pathData="M18,78L42,42l12,18l12,-12l24,30z" />
+</vector>
+`;
+  if (config.appIconPath) {
+    cpSync(config.appIconPath, join(output, `app/src/main/res/drawable/craft_app_icon${appIconExtension}`));
+  } else {
+    writeFileSync(join(output, "app/src/main/res/drawable/craft_app_icon.xml"), appIconXml);
+  }
+  const themesXml = `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.CraftApp" parent="Theme.Material3.DayNight.NoActionBar">
+        <item name="android:statusBarColor">@color/primary_dark</item>
+        <item name="android:navigationBarColor">@color/primary</item>
+        <item name="android:windowBackground">@color/background</item>
+    </style>
+</resources>
+`;
+  writeFileSync(join(output, "app/src/main/res/values/themes.xml"), themesXml);
+  const activityMainXml = `<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <WebView
+        android:id="@+id/webview"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
+`;
+  writeFileSync(join(output, "app/src/main/res/layout/activity_main.xml"), activityMainXml);
+  const placeholderHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="viewport-fit=cover, width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+  <title>${escapeXml(name)}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: 'Roboto', sans-serif;
+      background: ${config.backgroundColor};
+      color: white;
+      min-height: 100vh;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+    }
+    .container { text-align: center; padding: 2rem; }
+    h1 { font-size: 2.5rem; margin-bottom: 1rem; }
+    p { opacity: 0.7; }
+    .ready { color: #4ade80; font-size: 0.9rem; margin-top: 2rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u26A1 ${escapeXml(name)}</h1>
+    <p>Built with Craft Android</p>
+    <p class="ready" id="status">Waiting for Craft bridge...</p>
+  </div>
+  <script>
+    window.addEventListener('craftReady', (e) => {
+      document.getElementById('status').textContent = \`\u2713 Craft bridge ready (platform: \${e.detail.platform})\`;
+      console.log('Craft capabilities:', e.detail.capabilities);
+    });
+  </script>
+</body>
+</html>`;
+  writeFileSync(join(output, "app/src/main/assets/index.html"), placeholderHtml);
+  const runtimeDir = resolveRuntimeDir(options.runtimeDir);
+  if (runtimeDir) {
+    installRuntime(output, runtimeDir);
+    console.log("   Installed the Zig runtime from", runtimeDir);
+  }
+  console.log("\u2705 Project initialized");
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  1. cd ${output}`);
+  console.log("  2. Add your web content to app/src/main/assets/index.html");
+  console.log("  3. Run: craft android build");
+  console.log("  4. Run: craft android open");
+  console.log("");
+}
+async function build(options) {
+  const { htmlPath, devServer, output, release, compile = true } = options;
+  console.log(`
+\uD83D\uDCE6 Building Craft Android project...`);
+  const configPath = join(output, "craft.config.json");
+  if (!existsSync(configPath)) {
+    throw new Error(`No craft.config.json found in ${output}. Run 'craft android init' first.`);
+  }
+  const config = JSON.parse(readFileSync(configPath, "utf-8"));
+  if (existsSync(join(output, "app/src/main/jniLibs"))) {
+    const runtimeDir = resolveRuntimeDir(options.runtimeDir);
+    if (runtimeDir) {
+      installRuntime(output, runtimeDir);
+      console.log("   Refreshed the Zig runtime from", runtimeDir);
+    } else {
+      console.log("   Keeping the Zig runtime installed at init (no runtime directory configured)");
+    }
+  }
+  if (devServer) {
+    const url = androidWebUrl(devServer, "Android dev server URL");
+    config.devServerURL = url.toString();
+    config.trustedOrigins = [...new Set([
+      ...(config.trustedOrigins ?? []).map((value) => androidWebUrl(value, "Android trusted origin").origin),
+      url.origin
+    ])];
+    writeAndroidConfig(output, config);
+    console.log(`   Dev server: ${devServer}`);
+  }
+  if (htmlPath) {
+    syncAndroidWebAssets(htmlPath, output);
+    config.hasBundledFallback = Boolean(devServer);
+    writeAndroidConfig(output, config);
+    console.log(`   Synced: ${htmlPath} \u2192 assets/`);
+  }
+  if (!compile)
+    return;
+  const gradlewPath = join(output, "gradlew");
+  if (!existsSync(gradlewPath)) {
+    console.log("   Generating Gradle wrapper...");
+    try {
+      await $`cd ${output} && gradle wrapper`.quiet();
+    } catch (error) {
+      throw new Error("Gradle is unavailable. Install Android Studio or Gradle before building Android.", { cause: error });
+    }
+  }
+  const buildType = release ? "assembleRelease" : "assembleDebug";
+  console.log(`   Building ${release ? "release" : "debug"} APK...`);
+  try {
+    await $`cd ${output} && ./gradlew ${buildType}`;
+    const apkPath = release ? "app/build/outputs/apk/release/app-release.apk" : "app/build/outputs/apk/debug/app-debug.apk";
+    console.log(`\u2705 APK built: ${apkPath}`);
+  } catch (error) {
+    console.error("Build failed. Open in Android Studio for details.");
+    throw error;
+  }
+  console.log("");
+}
+async function open(options) {
+  const { output } = options;
+  if (!existsSync(output)) {
+    throw new Error(`No Android project found in ${output}. Run 'craft android init' first.`);
+  }
+  console.log(`\uD83D\uDE80 Opening Android project in Android Studio...`);
+  try {
+    await $`open -a "Android Studio" ${output}`.quiet();
+  } catch {
+    try {
+      await $`studio ${output}`.quiet();
+    } catch {
+      console.log("\u26A0\uFE0F  Android Studio not found.");
+      console.log("   Please open the project manually in Android Studio:");
+      console.log(`   ${output}`);
+    }
+  }
+}
+async function run(options) {
+  const { device, output } = options;
+  await build({ output });
+  console.log("\uD83D\uDCF1 Installing and running on device...");
+  try {
+    const apkPath = join(output, "app/build/outputs/apk/debug/app-debug.apk");
+    if (device) {
+      await $`adb -s ${device} install -r ${apkPath}`;
+    } else {
+      await $`adb install -r ${apkPath}`;
+    }
+    const config = JSON.parse(readFileSync(join(output, "craft.config.json"), "utf-8"));
+    const launchCmd = `${config.packageName}/.MainActivity`;
+    if (device) {
+      await $`adb -s ${device} shell am start -n ${launchCmd}`;
+    } else {
+      await $`adb shell am start -n ${launchCmd}`;
+    }
+    console.log("\u2705 App launched");
+  } catch (error) {
+    console.error("Failed to install/run. Make sure:");
+    console.error("  1. ADB is installed and in PATH");
+    console.error("  2. A device/emulator is connected (run: adb devices)");
+    throw error;
+  }
+}
+export {
+  syncAndroidWebAssets,
+  run,
+  resolveRuntimeDir,
+  renderAndroidPermissions,
+  renderAndroidDeepLinks,
+  open,
+  installRuntime,
+  init,
+  build,
+  ANDROID_MIN_SDK
+};
+
+//# debugId=BDD4D60CC245FA0664756E2164756E21