@zerogpu/expo-android-sdk 0.0.2

package/README.md

@@ -0,0 +1,97 @@
+# @zerogpu/expo-android-sdk
+
+Expo / React Native module that turns an **Android** device into an on-device
+inference node on the [ZeroGPU](https://zerogpu.ai) network. It wraps the native
+`ai.zerogpu:android-sdk` AAR and exposes a tiny JS API.
+
+> **Android-only.** iOS builds link a no-op stub so cross-platform apps still
+> compile, but the device only acts as a node on Android. The native library ships
+> `arm64-v8a` (phones) and `x86_64` (emulators) only.
+
+## Install
+
+```bash
+npx expo install @zerogpu/expo-android-sdk
+```
+
+Add the config plugin to `app.json` / `app.config.js`:
+
+```json
+{
+  "expo": {
+    "plugins": ["@zerogpu/expo-android-sdk"]
+  }
+}
+```
+
+Then regenerate the native project:
+
+```bash
+npx expo prebuild
+```
+
+The plugin wires up the two app-level Android needs automatically:
+
+- a `pickFirst '**/libc++_shared.so'` packaging rule (the AAR bundles native libs
+  from ONNX Runtime **and** llama.cpp, both of which ship `libc++_shared.so`), and
+- raises `minSdkVersion` to **26** if your app is lower (never lowers it).
+
+Permissions (`INTERNET`, `ACCESS_NETWORK_STATE`) and `largeHeap` come from the AAR
+manifest and merge in automatically — nothing to add.
+
+> Requires an Expo app using `expo-modules-core` (managed or bare). This is not a
+> plain-React-Native library.
+
+## Usage
+
+```ts
+import { start, stop } from '@zerogpu/expo-android-sdk';
+
+// Start the node (typically once, e.g. in your root component / on app launch).
+await start('zgpu-sdk-xxxxxxxx'); // your operator key from https://zerogpu.ai
+
+// ...later, on teardown:
+await stop();
+```
+
+Keep the operator key out of source control (e.g. via `expo-constants` /
+environment config), just like any secret.
+
+`start()` is idempotent, and the native SDK manages the foreground/background socket
+itself — you do **not** need to wire it to `AppState`. On iOS both calls resolve as
+no-ops.
+
+### Options
+
+```ts
+await start('zgpu-sdk-…', {
+  baseUrl: 'https://devices.zerogpu.ai', // default
+  env: 'production',                     // default
+  enableTelemetry: true,                 // default
+});
+```
+
+## Verifying it works
+
+Run the app on an `arm64-v8a` phone or an `x86_64` emulator (Android 8.0+), then
+watch logcat:
+
+```bash
+adb logcat -s ZeroGpuSdk:* ZeroGpuWebSocket:*
+```
+
+You want to see `status":"idle"` and `WebSocket ready for tasks`. Send an inference
+request to `https://api.zerogpu.ai/v1/chat/completions` with your **API key** and
+match the response `id` to the `requestId` in logcat — see the SDK's
+[INTEGRATION.md](../app/INTEGRATION.md) for the full end-to-end check.
+
+## Versioning
+
+This package is published from the same release as the AAR and always carries the
+**same version** as `ai.zerogpu:android-sdk`. The AAR coordinate is derived from this
+package's own `package.json`, so an installed npm version always pulls the matching
+AAR.
+
+## License
+
+Apache-2.0

package/android/build.gradle

@@ -0,0 +1,51 @@
+import groovy.json.JsonSlurper
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+group = 'ai.zerogpu.expo'
+version = '0.0.2'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+buildscript {
+  // Lets the consuming app override versions we declare here.
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+}
+
+// Single source of truth for the wrapped AAR version: the package.json this module
+// ships in. In a consumer app this resolves inside node_modules/@zerogpu/expo-android-sdk,
+// so the npm package and the AAR it pulls always match — no drift possible.
+def zeroGpuSdkVersion = new JsonSlurper().parse(file("../package.json")).version
+
+android {
+  namespace "ai.zerogpu.expo"
+  defaultConfig {
+    // The native SDK requires API 26+. Never lower than the SDK's own minSdk.
+    minSdkVersion Math.max(safeExtGet("minSdkVersion", 26) as int, 26)
+    targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    versionCode 1
+    versionName version.toString()
+  }
+
+  compileSdk safeExtGet("compileSdkVersion", 34)
+
+  // The consuming app must add the app-level pickFirst for libc++_shared.so — the
+  // config plugin does that automatically at prebuild time.
+
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+    }
+  }
+}
+
+dependencies {
+  implementation "ai.zerogpu:android-sdk:${zeroGpuSdkVersion}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Intentionally empty. INTERNET / ACCESS_NETWORK_STATE and largeHeap are
+       declared by the ai.zerogpu:android-sdk AAR and merge into the host app. -->
+</manifest>

package/android/src/main/java/ai/zerogpu/expo/ZeroGpuAndroidSdkModule.kt

@@ -0,0 +1,55 @@
+package ai.zerogpu.expo
+
+import ai.zerogpu.android.sdk.ZeroGpuSdk
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * Expo module that bridges the native ZeroGPU Android SDK to JavaScript.
+ *
+ * The SDK drives its own foreground/background lifecycle via ProcessLifecycleOwner,
+ * so the bridge only constructs the instance and calls start()/stop(). Because
+ * ZeroGpuSdk is single-use (not restartable after stop()), we hold a nullable
+ * reference and always build a fresh instance on start().
+ */
+class ZeroGpuAndroidSdkModule : Module() {
+  // null == not started.
+  private var sdk: ZeroGpuSdk? = null
+
+  override fun definition() = ModuleDefinition {
+    // Must match requireNativeModule('ZeroGpuAndroidSdk') on the JS side.
+    Name("ZeroGpuAndroidSdk")
+
+    AsyncFunction("start") { operatorKey: String, options: Map<String, Any?>? ->
+      if (sdk != null) return@AsyncFunction // idempotent: already running
+
+      val appCtx = appContext.reactContext?.applicationContext
+        ?: throw Exceptions.ReactContextLost()
+
+      sdk = ZeroGpuSdk(
+        context = appCtx,
+        operatorKey = operatorKey,
+        baseUrl = (options?.get("baseUrl") as? String) ?: DEFAULT_BASE_URL,
+        env = (options?.get("env") as? String) ?: DEFAULT_ENV,
+        enableTelemetry = (options?.get("enableTelemetry") as? Boolean) ?: true,
+      ).also { it.start() }
+    }
+
+    AsyncFunction("stop") {
+      sdk?.stop()
+      sdk = null // drop the dead instance; a later start() builds a fresh one
+    }
+
+    // Safety net if the JS context is torn down without an explicit stop().
+    OnDestroy {
+      sdk?.stop()
+      sdk = null
+    }
+  }
+
+  private companion object {
+    const val DEFAULT_BASE_URL = "https://devices.zerogpu.ai"
+    const val DEFAULT_ENV = "production"
+  }
+}

package/app.plugin.js

@@ -0,0 +1,4 @@
+// Config-plugin entrypoint. Expo resolves `app.plugin.js` at the package root when
+// this package name appears in an app's `plugins` array. The real implementation is
+// compiled from plugin/src -> plugin/build by `npm run build:plugin`.
+module.exports = require('./plugin/build');

package/build/ZeroGpuAndroidSdkModule.d.ts

@@ -0,0 +1,13 @@
+import type { ZeroGpuOptions } from './types';
+/**
+ * Native-module contract. Backed by the Android implementation
+ * (`ai.zerogpu.expo.ZeroGpuAndroidSdkModule`) and a no-op iOS stub, so both
+ * methods resolve on every platform.
+ */
+export interface ZeroGpuAndroidSdkNativeModule {
+    start(operatorKey: string, options?: ZeroGpuOptions): Promise<void>;
+    stop(): Promise<void>;
+}
+declare const _default: ZeroGpuAndroidSdkNativeModule;
+export default _default;
+//# sourceMappingURL=ZeroGpuAndroidSdkModule.d.ts.map

package/build/ZeroGpuAndroidSdkModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZeroGpuAndroidSdkModule.d.ts","sourceRoot":"","sources":["../src/ZeroGpuAndroidSdkModule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;;AAGD,wBAAuF"}

package/build/ZeroGpuAndroidSdkModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+// The name must match `Name(...)` in the native module definitions.
+export default requireNativeModule('ZeroGpuAndroidSdk');
+//# sourceMappingURL=ZeroGpuAndroidSdkModule.js.map

package/build/ZeroGpuAndroidSdkModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZeroGpuAndroidSdkModule.js","sourceRoot":"","sources":["../src/ZeroGpuAndroidSdkModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAcxD,oEAAoE;AACpE,eAAe,mBAAmB,CAAgC,mBAAmB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from 'expo-modules-core';\n\nimport type { ZeroGpuOptions } from './types';\n\n/**\n * Native-module contract. Backed by the Android implementation\n * (`ai.zerogpu.expo.ZeroGpuAndroidSdkModule`) and a no-op iOS stub, so both\n * methods resolve on every platform.\n */\nexport interface ZeroGpuAndroidSdkNativeModule {\n  start(operatorKey: string, options?: ZeroGpuOptions): Promise<void>;\n  stop(): Promise<void>;\n}\n\n// The name must match `Name(...)` in the native module definitions.\nexport default requireNativeModule<ZeroGpuAndroidSdkNativeModule>('ZeroGpuAndroidSdk');\n"]}

package/build/index.d.ts

@@ -0,0 +1,20 @@
+import type { ZeroGpuOptions } from './types';
+export type { ZeroGpuOptions } from './types';
+/**
+ * Start the ZeroGPU node. The device registers with the ZeroGPU backend using the
+ * operator key, downloads its assigned model(s), and serves on-device inference
+ * while the app is foregrounded (the native SDK manages the socket lifecycle).
+ *
+ * Idempotent: calling `start` again while already running is a no-op. On iOS this
+ * resolves without doing anything — the SDK is Android-only.
+ *
+ * @param operatorKey Your operator key from the ZeroGPU dashboard (`zgpu-sdk-…`).
+ * @param options Optional base URL / environment / telemetry overrides.
+ */
+export declare function start(operatorKey: string, options?: ZeroGpuOptions): Promise<void>;
+/**
+ * Stop the ZeroGPU node: close the socket, release model adapters, and shut the
+ * SDK down. A subsequent {@link start} spins up a fresh instance. No-op on iOS.
+ */
+export declare function stop(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED;;;GAGG;AACH,wBAAgB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpC"}

package/build/index.js

@@ -0,0 +1,23 @@
+import ZeroGpuAndroidSdkModule from './ZeroGpuAndroidSdkModule';
+/**
+ * Start the ZeroGPU node. The device registers with the ZeroGPU backend using the
+ * operator key, downloads its assigned model(s), and serves on-device inference
+ * while the app is foregrounded (the native SDK manages the socket lifecycle).
+ *
+ * Idempotent: calling `start` again while already running is a no-op. On iOS this
+ * resolves without doing anything — the SDK is Android-only.
+ *
+ * @param operatorKey Your operator key from the ZeroGPU dashboard (`zgpu-sdk-…`).
+ * @param options Optional base URL / environment / telemetry overrides.
+ */
+export function start(operatorKey, options) {
+    return ZeroGpuAndroidSdkModule.start(operatorKey, options);
+}
+/**
+ * Stop the ZeroGPU node: close the socket, release model adapters, and shut the
+ * SDK down. A subsequent {@link start} spins up a fresh instance. No-op on iOS.
+ */
+export function stop() {
+    return ZeroGpuAndroidSdkModule.stop();
+}
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,uBAAuB,MAAM,2BAA2B,CAAC;AAKhE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,KAAK,CAAC,WAAmB,EAAE,OAAwB;IACjE,OAAO,uBAAuB,CAAC,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAC7D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,IAAI;IAClB,OAAO,uBAAuB,CAAC,IAAI,EAAE,CAAC;AACxC,CAAC","sourcesContent":["import ZeroGpuAndroidSdkModule from './ZeroGpuAndroidSdkModule';\nimport type { ZeroGpuOptions } from './types';\n\nexport type { ZeroGpuOptions } from './types';\n\n/**\n * Start the ZeroGPU node. The device registers with the ZeroGPU backend using the\n * operator key, downloads its assigned model(s), and serves on-device inference\n * while the app is foregrounded (the native SDK manages the socket lifecycle).\n *\n * Idempotent: calling `start` again while already running is a no-op. On iOS this\n * resolves without doing anything — the SDK is Android-only.\n *\n * @param operatorKey Your operator key from the ZeroGPU dashboard (`zgpu-sdk-…`).\n * @param options Optional base URL / environment / telemetry overrides.\n */\nexport function start(operatorKey: string, options?: ZeroGpuOptions): Promise<void> {\n  return ZeroGpuAndroidSdkModule.start(operatorKey, options);\n}\n\n/**\n * Stop the ZeroGPU node: close the socket, release model adapters, and shut the\n * SDK down. A subsequent {@link start} spins up a fresh instance. No-op on iOS.\n */\nexport function stop(): Promise<void> {\n  return ZeroGpuAndroidSdkModule.stop();\n}\n"]}

package/build/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Optional overrides for {@link start}. All fields default to production values
+ * inside the native SDK, so a typical caller only passes the operator key.
+ */
+export type ZeroGpuOptions = {
+    /** Device-registration base URL. Defaults to `https://devices.zerogpu.ai`. */
+    baseUrl?: string;
+    /** Environment name. Defaults to `production`. */
+    env?: string;
+    /** Whether the SDK reports anonymous telemetry. Defaults to `true`. */
+    enableTelemetry?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Optional overrides for {@link start}. All fields default to production values\n * inside the native SDK, so a typical caller only passes the operator key.\n */\nexport type ZeroGpuOptions = {\n  /** Device-registration base URL. Defaults to `https://devices.zerogpu.ai`. */\n  baseUrl?: string;\n  /** Environment name. Defaults to `production`. */\n  env?: string;\n  /** Whether the SDK reports anonymous telemetry. Defaults to `true`. */\n  enableTelemetry?: boolean;\n};\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["ZeroGpuAndroidSdkModule"]
+  },
+  "android": {
+    "modules": ["ai.zerogpu.expo.ZeroGpuAndroidSdkModule"]
+  }
+}

package/ios/ZeroGpuAndroidSdk.podspec

@@ -0,0 +1,21 @@
+Pod::Spec.new do |s|
+  s.name           = 'ZeroGpuAndroidSdk'
+  s.version        = '0.0.2'
+  s.summary        = 'iOS no-op stub for @zerogpu/expo-android-sdk (the SDK is Android-only).'
+  s.description    = 'Keeps cross-platform Expo apps building on iOS. start()/stop() resolve without doing anything; the device is only a ZeroGPU node on Android.'
+  s.author         = 'ZeroGPU'
+  s.homepage       = 'https://github.com/zerogpu/zerogpu-android-sdk'
+  s.platforms      = { :ios => '13.4', :tvos => '13.4' }
+  s.source         = { git: 'https://github.com/zerogpu/zerogpu-android-sdk.git' }
+  s.static_framework = true
+  s.license        = { :type => 'Apache-2.0' }
+
+  s.dependency 'ExpoModulesCore'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = '**/*.{h,m,mm,swift,hpp,cpp}'
+end

package/ios/ZeroGpuAndroidSdkModule.swift

@@ -0,0 +1,17 @@
+import ExpoModulesCore
+
+// The ZeroGPU SDK is Android-only. This iOS module exists solely so cross-platform
+// Expo apps compile and link; both functions resolve immediately as no-ops.
+public class ZeroGpuAndroidSdkModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ZeroGpuAndroidSdk")
+
+    AsyncFunction("start") { (_ operatorKey: String, _ options: [String: Any]?) in
+      // No-op on iOS.
+    }
+
+    AsyncFunction("stop") {
+      // No-op on iOS.
+    }
+  }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@zerogpu/expo-android-sdk",
+  "version": "0.0.2",
+  "description": "Expo/React Native module that runs a ZeroGPU on-device inference node on Android by wrapping the native ai.zerogpu:android-sdk AAR.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:plugin": "tsc -p plugin/tsconfig.json",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "npm run build && npm run build:plugin",
+    "prepublishOnly": "npm run build && npm run build:plugin",
+    "expo-module": "expo-module"
+  },
+  "keywords": [
+    "zerogpu",
+    "expo",
+    "react-native",
+    "android",
+    "on-device",
+    "inference",
+    "slm"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zerogpu/zerogpu-android-sdk.git",
+    "directory": "expo-android-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/zerogpu/zerogpu-android-sdk/issues"
+  },
+  "author": "ZeroGPU <hello@zerogpu.ai>",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/zerogpu/zerogpu-android-sdk/tree/develop/expo-android-sdk",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "build",
+    "plugin/build",
+    "android",
+    "ios",
+    "app.plugin.js",
+    "expo-module.config.json",
+    "!android/build",
+    "!android/.gradle"
+  ],
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@types/react": "~18.2.79",
+    "expo": "^51.0.0",
+    "expo-module-scripts": "^3.5.2",
+    "expo-modules-core": "^1.12.0",
+    "react": "18.2.0",
+    "react-native": "0.74.5",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@expo/config-plugins": "^8.0.0"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+declare const _default: ConfigPlugin<void>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const pkg = require('../../package.json');
+/** The minimum Android API level the native SDK requires. */
+const MIN_SDK_VERSION = 26;
+/** Marker so the packaging block is injected exactly once (survives `prebuild --clean`). */
+const PICK_FIRST_MARKER = '// @zerogpu/expo-android-sdk: pickFirst libc++_shared';
+/**
+ * The AAR bundles native `.so` files from both ONNX Runtime and llama.cpp, each
+ * shipping their own `libc++_shared.so`. Without `pickFirst`, the app-module merge
+ * fails on the duplicate. This block is app-module-level and does not propagate from
+ * the AAR, so the plugin must inject it into the consuming app's build.gradle.
+ */
+const withPickFirstLibcxx = (config) => (0, config_plugins_1.withAppBuildGradle)(config, (cfg) => {
+    if (cfg.modResults.language !== 'groovy') {
+        throw new Error('@zerogpu/expo-android-sdk config plugin only supports Groovy android/app/build.gradle.');
+    }
+    let contents = cfg.modResults.contents;
+    if (contents.includes(PICK_FIRST_MARKER)) {
+        return cfg; // already applied — idempotent
+    }
+    const block = [
+        '',
+        `    ${PICK_FIRST_MARKER}`,
+        '    packagingOptions {',
+        '        jniLibs {',
+        "            pickFirst '**/libc++_shared.so'",
+        '        }',
+        '    }',
+    ].join('\n');
+    // Insert immediately after the opening of the top-level `android {` block.
+    let inserted = false;
+    contents = contents.replace(/android\s*\{/, (match) => {
+        inserted = true;
+        return `${match}\n${block}`;
+    });
+    if (!inserted) {
+        throw new Error('@zerogpu/expo-android-sdk: could not find an `android { }` block in android/app/build.gradle.');
+    }
+    cfg.modResults.contents = contents;
+    return cfg;
+});
+/**
+ * Raise `android.minSdkVersion` to at least {@link MIN_SDK_VERSION}. Only ever raises,
+ * never lowers, so an app already on a higher minSdk (or `expo-build-properties`) is
+ * left alone. The Expo Android template reads this gradle property for its minSdk.
+ */
+const withMinSdk = (config) => (0, config_plugins_1.withGradleProperties)(config, (cfg) => {
+    const key = 'android.minSdkVersion';
+    const existing = cfg.modResults.find((item) => item.type === 'property' && item.key === key);
+    const current = existing ? parseInt(existing.value, 10) || 0 : 0;
+    const next = Math.max(current, MIN_SDK_VERSION);
+    if (existing) {
+        existing.value = String(next);
+    }
+    else {
+        cfg.modResults.push({ type: 'property', key, value: String(next) });
+    }
+    return cfg;
+});
+const withZeroGpu = (config) => {
+    config = withPickFirstLibcxx(config);
+    config = withMinSdk(config);
+    return config;
+};
+// Guarantees the plugin runs once even if listed multiple times.
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withZeroGpu, pkg.name, pkg.version);