peachsim 0.1.2186 → 0.1.2187

package/dist-lib/kotlin-host.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.2186 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.2187 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = '', __sootsim_import_meta_filename = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; __sootsim_import_meta_filename = __filename; } catch {}
 "use strict";
 var __create = Object.create;
@@ -7,6 +7,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -29,6 +32,312 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// <define:__SWIFT_COVERAGE_SOURCE_DIGESTS__>
+var init_define_SWIFT_COVERAGE_SOURCE_DIGESTS = __esm({
+  "<define:__SWIFT_COVERAGE_SOURCE_DIGESTS__>"() {
+  }
+});
+
+// src/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_is_record = __esm({
+  "src/is-record.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+  }
+});
+
+// src/home-paths.ts
+function ambientHomeDir() {
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".peach");
+}
+function rnxHomeDir() {
+  const override = process.env[PEACH_HOME_ENV];
+  return override && override.length > 0 ? import_node_path.default.resolve(override) : ambientHomeDir();
+}
+var import_node_os, import_node_path, PEACH_HOME_ENV, DAEMON_LOCKFILE_MAX_BYTES;
+var init_home_paths = __esm({
+  "src/home-paths.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_os = require("node:os");
+    import_node_path = __toESM(require("node:path"), 1);
+    PEACH_HOME_ENV = "PEACH_HOME";
+    DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+  }
+});
+
+// src/kotlin-toolchain.ts
+function readToolchain(moduleRoot) {
+  const parsed = JSON.parse(
+    import_node_fs.default.readFileSync(import_node_path2.default.join(moduleRoot, "toolchain.json"), "utf8")
+  );
+  const download = (value) => {
+    if (!isRecord(value) || typeof value.url !== "string" || typeof value.sha256 !== "string")
+      throw new Error(
+        "peachsim kotlin/toolchain.json names a download without url and sha256"
+      );
+    return { url: value.url, sha256: value.sha256 };
+  };
+  if (!isRecord(parsed) || !isRecord(parsed.compiler) || !Array.isArray(parsed.libraries) || !Array.isArray(parsed.composeLibraries) || !Array.isArray(parsed.composeJsLibraries) || !isRecord(parsed.composeRuntime) || typeof parsed.composeRuntime.name !== "string")
+    throw new Error("peachsim kotlin/toolchain.json has no compiler and libraries");
+  const version = parsed.compiler.version;
+  if (typeof version !== "string")
+    throw new Error("peachsim kotlin/toolchain.json has no compiler version");
+  const libraries = (values) => values.map((library) => {
+    if (!isRecord(library) || typeof library.name !== "string")
+      throw new Error("peachsim kotlin/toolchain.json names a library without a name");
+    return { ...download(library), name: library.name };
+  });
+  return {
+    compiler: { ...download(parsed.compiler), version },
+    libraries: libraries(parsed.libraries),
+    composeLibraries: libraries(parsed.composeLibraries),
+    composeRuntime: {
+      ...download(parsed.composeRuntime),
+      name: parsed.composeRuntime.name
+    },
+    composeJsLibraries: parsed.composeJsLibraries.map((library) => {
+      if (!isRecord(library) || typeof library.name !== "string" || typeof library.module !== "string" || typeof library.file !== "string" || typeof library.archiveEntry !== "string")
+        throw new Error("peachsim kotlin/toolchain.json has an incomplete JS library");
+      return {
+        ...download(library),
+        name: library.name,
+        module: library.module,
+        file: library.file,
+        archiveEntry: library.archiveEntry
+      };
+    })
+  };
+}
+function kotlinHome() {
+  return import_node_path2.default.join(rnxHomeDir(), "kotlin");
+}
+async function fetchVerified(download, target) {
+  if (import_node_fs.default.existsSync(target)) {
+    if ((0, import_node_crypto.createHash)("sha256").update(import_node_fs.default.readFileSync(target)).digest("hex") !== download.sha256)
+      throw new Error(
+        `cached Kotlin download differs from its pin: ${import_node_path2.default.basename(target)}`
+      );
+    return;
+  }
+  const response = await fetch(download.url);
+  if (!response.ok) throw new Error(`${download.url} answered ${response.status}`);
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const digest = (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+  if (digest !== download.sha256)
+    throw new Error(`${download.url} has sha256 ${digest}, expected ${download.sha256}`);
+  import_node_fs.default.mkdirSync(import_node_path2.default.dirname(target), { recursive: true });
+  const partial = `${target}.${process.pid}.partial`;
+  import_node_fs.default.writeFileSync(partial, bytes);
+  import_node_fs.default.renameSync(partial, target);
+}
+function ensureToolchain(toolchain) {
+  const key = JSON.stringify(toolchain);
+  const pending = toolchains.get(key);
+  if (pending) return pending;
+  const ready = (async () => {
+    const dir = import_node_path2.default.join(kotlinHome(), toolchain.compiler.version);
+    const kotlinc = import_node_path2.default.join(dir, "kotlinc", "bin", "kotlinc-wasm");
+    if (!import_node_fs.default.existsSync(kotlinc)) {
+      const zip = import_node_path2.default.join(dir, "kotlin-compiler.zip");
+      await fetchVerified(toolchain.compiler, zip);
+      await run("unzip", ["-q", "-o", zip, "-d", dir]);
+      import_node_fs.default.rmSync(zip);
+    }
+    const java = process.env.JAVA_HOME ? import_node_path2.default.join(process.env.JAVA_HOME, "bin", "java") : "java";
+    const { stderr } = await run(java, ["-XshowSettings:properties", "-version"]).catch(
+      () => {
+        throw new Error(
+          `Kotlin in Peach compiles with kotlinc, which needs a Java runtime (17 or newer, as android builds use); ${process.env.JAVA_HOME ? `JAVA_HOME ${process.env.JAVA_HOME} has none` : "set JAVA_HOME or put java on PATH"}`
+        );
+      }
+    );
+    const javaHome = /^\s*java\.home\s*=\s*(.+)$/m.exec(stderr)?.[1]?.trim();
+    if (!javaHome || !import_node_path2.default.isAbsolute(javaHome))
+      throw new Error("the configured Java runtime did not report an absolute java.home");
+    const libraries = [import_node_path2.default.join(dir, "kotlinc", "lib", "kotlin-stdlib-wasm-js.klib")];
+    for (const library of toolchain.libraries) {
+      const target = import_node_path2.default.join(dir, library.name);
+      await fetchVerified(library, target);
+      libraries.push(target);
+    }
+    return { kotlinc, libraries, javaHome };
+  })().catch((error) => {
+    toolchains.delete(key);
+    throw error;
+  });
+  toolchains.set(key, ready);
+  return ready;
+}
+var import_node_child_process, import_node_crypto, import_node_fs, import_node_path2, import_node_util, run, toolchains;
+var init_kotlin_toolchain = __esm({
+  "src/kotlin-toolchain.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_child_process = require("node:child_process");
+    import_node_crypto = require("node:crypto");
+    import_node_fs = __toESM(require("node:fs"), 1);
+    import_node_path2 = __toESM(require("node:path"), 1);
+    import_node_util = require("node:util");
+    init_home_paths();
+    init_is_record();
+    run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+    toolchains = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/forked-script-contract.ts
+var PEACH_FORKED_SCRIPT_ENV;
+var init_forked_script_contract = __esm({
+  "src/forked-script-contract.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    PEACH_FORKED_SCRIPT_ENV = "PEACH_RUNS_FORKED_SCRIPTS";
+  }
+});
+
+// src/android-gradle-sources.ts
+var android_gradle_sources_exports = {};
+__export(android_gradle_sources_exports, {
+  resolveAndroidGradleSources: () => resolveAndroidGradleSources
+});
+async function resolveAndroidGradleSources(request) {
+  let { root } = request;
+  const { projects: projectDirs, variant } = request;
+  if (projectDirs.length === 0) return [];
+  if (!import_node_path6.default.isAbsolute(root) || projectDirs.some((dir) => !import_node_path6.default.isAbsolute(dir)))
+    throw new Error("Android Gradle source selection requires absolute project paths");
+  if (!variant) throw new Error("Android Gradle source selection requires a variant");
+  root = import_node_fs5.default.realpathSync(root);
+  const projects = [...new Set(projectDirs.map((dir) => import_node_fs5.default.realpathSync(dir)))];
+  const parent = import_node_path6.default.join(kotlinHome(), "gradle-sources");
+  import_node_fs5.default.mkdirSync(parent, { recursive: true });
+  const work = import_node_fs5.default.mkdtempSync(import_node_path6.default.join(parent, ".query-"));
+  const task = `peachAndroidSources${(0, import_node_crypto5.randomBytes)(8).toString("hex")}`;
+  const script = import_node_path6.default.join(work, "sources.gradle");
+  const encoded = Buffer.from(
+    JSON.stringify({ root, projects, variant, output: work, task })
+  ).toString("base64");
+  import_node_fs5.default.writeFileSync(script, modelQuery.replace("__PEACH_REQUEST__", encoded));
+  try {
+    await run4(
+      "bash",
+      [
+        import_node_path6.default.join(root, "gradlew"),
+        "--init-script",
+        script,
+        `${task}All`,
+        "--no-daemon",
+        "--no-configuration-cache",
+        "--max-workers=1",
+        "--console=plain"
+      ],
+      {
+        cwd: root,
+        timeout: 3e5,
+        maxBuffer: 8 * 1024 * 1024,
+        env: { ...process.env, [PEACH_FORKED_SCRIPT_ENV]: "1" }
+      }
+    );
+    return projects.map((projectDir, index) => {
+      const value = JSON.parse(
+        import_node_fs5.default.readFileSync(import_node_path6.default.join(work, `${index}.json`), "utf8")
+      );
+      if (!isRecord(value) || value.projectDir !== projectDir || value.variant !== variant || typeof value.projectPath !== "string" || value.applicationId !== null && typeof value.applicationId !== "string")
+        throw new Error("Gradle printed an invalid Android project source model");
+      const sources = (field) => {
+        const list = value[field];
+        if (!Array.isArray(list) || !list.every((file) => typeof file === "string" && import_node_path6.default.isAbsolute(file)))
+          throw new Error(`Gradle printed invalid Android ${field} source paths`);
+        return list.map(String);
+      };
+      return {
+        projectDir,
+        projectPath: value.projectPath,
+        variant,
+        applicationId: value.applicationId,
+        kotlin: sources("kotlin"),
+        java: sources("java")
+      };
+    });
+  } finally {
+    import_node_fs5.default.rmSync(work, { recursive: true, force: true });
+  }
+}
+var import_node_child_process4, import_node_crypto5, import_node_fs5, import_node_path6, import_node_util4, run4, modelQuery;
+var init_android_gradle_sources = __esm({
+  "src/android-gradle-sources.ts"() {
+    "use strict";
+    init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+    import_node_child_process4 = require("node:child_process");
+    import_node_crypto5 = require("node:crypto");
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_path6 = __toESM(require("node:path"), 1);
+    import_node_util4 = require("node:util");
+    init_forked_script_contract();
+    init_is_record();
+    init_kotlin_toolchain();
+    run4 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
+    modelQuery = `
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+
+def request = new JsonSlurper().parseText(new String(Base64.decoder.decode('__PEACH_REQUEST__'), 'UTF-8'))
+gradle.projectsEvaluated {
+    if (gradle.rootProject.projectDir.canonicalPath != request.root) return
+    def selected = []
+    request.projects.eachWithIndex { directory, index ->
+        def matches = gradle.rootProject.allprojects.findAll { it.projectDir.canonicalPath == directory }
+        if (matches.size() != 1) throw new GradleException('Expected one Android project for ' + directory)
+        def project = matches[0]
+        if (project.pluginManager.hasPlugin('org.jetbrains.kotlin.multiplatform')) {
+            throw new GradleException('Kotlin multiplatform source selection is not supported: ' + project.path)
+        }
+        def library = project.pluginManager.hasPlugin('com.android.library')
+        if (!library && !project.pluginManager.hasPlugin('com.android.application')) {
+            throw new GradleException('Project has no Android application or library plugin: ' + project.path)
+        }
+        def android = project.extensions.getByName('android')
+        def variants = library ? android.libraryVariants : android.applicationVariants
+        def variant = variants.find { it.name == request.variant }
+        if (variant == null) throw new GradleException('Android variant ' + request.variant + ' is absent: ' + project.path)
+        def generators = []
+        def buildConfig = variant.generateBuildConfigProvider
+        if (buildConfig != null) generators.add(buildConfig)
+        if (project.pluginManager.hasPlugin('com.facebook.react')) {
+            generators.add(project.tasks.named('generateCodegenArtifactsFromSchema'))
+        }
+        def kotlin = project.tasks.findByName('compile' + variant.name.capitalize() + 'Kotlin')
+        def kotlinSources = kotlin == null ? project.files() : kotlin.sources
+        def javaSources = variant.javaCompileProvider.get().source
+        def query = project.tasks.register(request.task) {
+            dependsOn(generators)
+            dependsOn(kotlinSources.buildDependencies, javaSources.buildDependencies)
+            doLast {
+                def files = (kotlinSources.files + javaSources.files).unique()
+                def unknown = files.find { !it.name.endsWith('.kt') && !it.name.endsWith('.java') }
+                if (unknown != null) throw new GradleException('Unsupported Android source: ' + unknown)
+                new File(request.output, index.toString() + '.json').text = JsonOutput.toJson([
+                    projectDir:project.projectDir.canonicalPath,
+                    projectPath:project.path,
+                    variant:variant.name,
+                    applicationId:library ? null : variant.applicationId,
+                    kotlin:files.findAll { it.name.endsWith('.kt') }.collect { it.absolutePath }.sort(),
+                    java:files.findAll { it.name.endsWith('.java') }.collect { it.absolutePath }.sort()
+                ])
+            }
+        }
+        selected.add(query)
+    }
+    gradle.rootProject.tasks.register(request.task + 'All') { dependsOn(selected) }
+}
+`;
+  }
+});
+
 // src/kotlin-host.ts
 var kotlin_host_exports = {};
 __export(kotlin_host_exports, {
@@ -44,21 +353,19 @@ __export(kotlin_host_exports, {
   serveKotlinRequest: () => serveKotlinRequest
 });
 module.exports = __toCommonJS(kotlin_host_exports);
-var import_node_child_process3 = require("node:child_process");
-var import_node_crypto4 = require("node:crypto");
-var import_node_fs4 = __toESM(require("node:fs"), 1);
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_child_process5 = require("node:child_process");
+var import_node_crypto6 = require("node:crypto");
+var import_node_fs6 = __toESM(require("node:fs"), 1);
 var import_node_module = require("node:module");
-var import_node_path5 = __toESM(require("node:path"), 1);
-var import_node_util3 = require("node:util");
+var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_util5 = require("node:util");
 var import_acorn2 = require("acorn");
 
-// src/is-record.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // src/android-bridge-packages.ts
-function readMethod(value) {
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+init_is_record();
+function readBridgeMethod(value) {
   if (!isRecord(value) || typeof value.name !== "string" || typeof value.blocking !== "boolean" || value.returns !== null && typeof value.returns !== "string" || !Array.isArray(value.params))
     throw new Error("bridge-modules printed an invalid method");
   return {
@@ -96,13 +403,136 @@ function readBridgeFiles(output) {
       modules: row.modules.map((entry) => {
         if (!isRecord(entry) || typeof entry.name !== "string" || !Array.isArray(entry.methods))
           throw new Error("bridge-modules printed an invalid module");
-        return { name: entry.name, methods: entry.methods.map(readMethod) };
+        return { name: entry.name, methods: entry.methods.map(readBridgeMethod) };
       })
     };
   });
 }
 
+// src/kotlin-host.ts
+init_is_record();
+
+// src/java-module-abi.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_util2 = require("node:util");
+init_is_record();
+init_kotlin_toolchain();
+var run2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var JAVA_BINDINGS_INITIALIZER = "initializeJavaBindings";
+async function readJavaModuleSpecs(files, sdkRoot, toolchain) {
+  const digest = (0, import_node_crypto2.createHash)("sha256");
+  const parent = import_node_path3.default.join(kotlinHome(), "java-specs");
+  import_node_fs2.default.mkdirSync(parent, { recursive: true });
+  const work = import_node_fs2.default.mkdtempSync(import_node_path3.default.join(parent, ".read-"));
+  try {
+    const origins = /* @__PURE__ */ new Map();
+    for (const [index, file] of files.entries()) {
+      const bytes = import_node_fs2.default.readFileSync(file);
+      digest.update(file).update("\0").update(bytes).update("\0");
+      const target = import_node_path3.default.join(work, String(index), import_node_path3.default.basename(file));
+      import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(target));
+      import_node_fs2.default.writeFileSync(target, bytes);
+      origins.set(target, file);
+    }
+    const { stdout } = await run2(
+      import_node_path3.default.join(toolchain.javaHome, "bin", "java"),
+      [
+        "-cp",
+        [
+          import_node_path3.default.join(sdkRoot, "tools.jar"),
+          import_node_path3.default.resolve(import_node_path3.default.dirname(toolchain.kotlinc), "../lib/kotlin-compiler.jar"),
+          import_node_path3.default.resolve(import_node_path3.default.dirname(toolchain.kotlinc), "../lib/kotlin-stdlib.jar")
+        ].join(import_node_path3.default.delimiter),
+        "dev.peach.tools.javaabi.JavaModuleSpecsKt",
+        ...origins.keys()
+      ],
+      { maxBuffer: 16 * 1024 * 1024 }
+    );
+    const specs = stdout.split("\n").filter(Boolean).map((line) => {
+      const row = JSON.parse(line);
+      if (!isRecord(row) || typeof row.file !== "string" || typeof row.className !== "string" || row.name !== null && typeof row.name !== "string" || typeof row.source !== "string" || !Array.isArray(row.methods))
+        throw new Error("Java module reader printed an invalid spec");
+      const file = origins.get(row.file);
+      if (!file) throw new Error("Java module reader named an unknown input");
+      return {
+        file,
+        className: row.className,
+        name: row.name,
+        source: row.source,
+        methods: row.methods.map(readBridgeMethod)
+      };
+    });
+    return { sha256: digest.digest("hex"), specs };
+  } finally {
+    import_node_fs2.default.rmSync(work, { recursive: true, force: true });
+  }
+}
+async function compileJavaModuleAbi(input) {
+  const { specs, work, hash, toolchain, libraries, sdkRoot, sdkLibrary, language } = input;
+  const directory = import_node_path3.default.join(work, "java-abi");
+  import_node_fs2.default.mkdirSync(directory);
+  const sources = specs.specs.map((spec, index) => {
+    const target = import_node_path3.default.join(directory, `Spec${index}.kt`);
+    import_node_fs2.default.writeFileSync(target, spec.source);
+    return target;
+  });
+  const initializer = import_node_path3.default.join(directory, "Bindings.kt");
+  import_node_fs2.default.writeFileSync(
+    initializer,
+    [
+      "package dev.peach.jni",
+      `internal fun ${JAVA_BINDINGS_INITIALIZER}() { error("Java bindings require the compiler plugin") }`
+    ].join("\n")
+  );
+  const name = `peach-java-abi-${hash}`;
+  await run2(
+    toolchain.kotlinc,
+    [
+      "-J-Xmx2g",
+      "-Xwasm-target=js",
+      "-libraries",
+      libraries.join(import_node_path3.default.delimiter),
+      `-Xplugin=${import_node_path3.default.join(sdkRoot, "plugin.jar")}`,
+      `-Xfriend-modules=${sdkLibrary}`,
+      "-language-version",
+      language,
+      "-api-version",
+      language,
+      "-nowarn",
+      "-ir-output-dir",
+      directory,
+      "-ir-output-name",
+      name,
+      ...sources,
+      initializer
+    ],
+    { maxBuffer: 16 * 1024 * 1024 }
+  );
+  const library = import_node_path3.default.join(directory, "java-abi.klib");
+  await run2(
+    import_node_path3.default.join(toolchain.javaHome, "bin", "java"),
+    [
+      "-cp",
+      [
+        import_node_path3.default.join(sdkRoot, "tools.jar"),
+        import_node_path3.default.resolve(import_node_path3.default.dirname(toolchain.kotlinc), "../lib/kotlin-compiler.jar"),
+        import_node_path3.default.resolve(import_node_path3.default.dirname(toolchain.kotlinc), "../lib/kotlin-stdlib.jar")
+      ].join(import_node_path3.default.delimiter),
+      "dev.peach.tools.platform.JavaPlatformTypesKt",
+      import_node_path3.default.join(directory, `${name}.klib`),
+      library
+    ],
+    { maxBuffer: 16 * 1024 * 1024 }
+  );
+  return library;
+}
+
 // src/kotlin-instance-source.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var import_acorn = require("acorn");
 function bindingNames(pattern) {
   if (pattern.type === "Identifier") return [pattern.name];
@@ -209,139 +639,17 @@ return { peachDisposeInstance, ${exports2.map((item) => `${JSON.stringify(item.e
 }
 
 // src/kotlin-sdk.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_crypto2 = require("node:crypto");
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
-var import_node_util2 = require("node:util");
-
-// src/kotlin-toolchain.ts
-var import_node_child_process = require("node:child_process");
-var import_node_crypto = require("node:crypto");
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path2 = __toESM(require("node:path"), 1);
-var import_node_util = require("node:util");
-
-// src/home-paths.ts
-var import_node_os = require("node:os");
-var import_node_path = __toESM(require("node:path"), 1);
-var PEACH_HOME_ENV = "PEACH_HOME";
-function ambientHomeDir() {
-  return import_node_path.default.join((0, import_node_os.homedir)(), ".peach");
-}
-function rnxHomeDir() {
-  const override = process.env[PEACH_HOME_ENV];
-  return override && override.length > 0 ? import_node_path.default.resolve(override) : ambientHomeDir();
-}
-var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
-
-// src/kotlin-toolchain.ts
-var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
-function readToolchain(moduleRoot) {
-  const parsed = JSON.parse(
-    import_node_fs.default.readFileSync(import_node_path2.default.join(moduleRoot, "toolchain.json"), "utf8")
-  );
-  const download = (value) => {
-    if (!isRecord(value) || typeof value.url !== "string" || typeof value.sha256 !== "string")
-      throw new Error(
-        "peachsim kotlin/toolchain.json names a download without url and sha256"
-      );
-    return { url: value.url, sha256: value.sha256 };
-  };
-  if (!isRecord(parsed) || !isRecord(parsed.compiler) || !Array.isArray(parsed.libraries) || !Array.isArray(parsed.composeLibraries) || !Array.isArray(parsed.composeJsLibraries) || !isRecord(parsed.composeRuntime) || typeof parsed.composeRuntime.name !== "string")
-    throw new Error("peachsim kotlin/toolchain.json has no compiler and libraries");
-  const version = parsed.compiler.version;
-  if (typeof version !== "string")
-    throw new Error("peachsim kotlin/toolchain.json has no compiler version");
-  const libraries = (values) => values.map((library) => {
-    if (!isRecord(library) || typeof library.name !== "string")
-      throw new Error("peachsim kotlin/toolchain.json names a library without a name");
-    return { ...download(library), name: library.name };
-  });
-  return {
-    compiler: { ...download(parsed.compiler), version },
-    libraries: libraries(parsed.libraries),
-    composeLibraries: libraries(parsed.composeLibraries),
-    composeRuntime: {
-      ...download(parsed.composeRuntime),
-      name: parsed.composeRuntime.name
-    },
-    composeJsLibraries: parsed.composeJsLibraries.map((library) => {
-      if (!isRecord(library) || typeof library.name !== "string" || typeof library.module !== "string" || typeof library.file !== "string" || typeof library.archiveEntry !== "string")
-        throw new Error("peachsim kotlin/toolchain.json has an incomplete JS library");
-      return {
-        ...download(library),
-        name: library.name,
-        module: library.module,
-        file: library.file,
-        archiveEntry: library.archiveEntry
-      };
-    })
-  };
-}
-function kotlinHome() {
-  return import_node_path2.default.join(rnxHomeDir(), "kotlin");
-}
-async function fetchVerified(download, target) {
-  if (import_node_fs.default.existsSync(target)) {
-    if ((0, import_node_crypto.createHash)("sha256").update(import_node_fs.default.readFileSync(target)).digest("hex") !== download.sha256)
-      throw new Error(
-        `cached Kotlin download differs from its pin: ${import_node_path2.default.basename(target)}`
-      );
-    return;
-  }
-  const response = await fetch(download.url);
-  if (!response.ok) throw new Error(`${download.url} answered ${response.status}`);
-  const bytes = Buffer.from(await response.arrayBuffer());
-  const digest = (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
-  if (digest !== download.sha256)
-    throw new Error(`${download.url} has sha256 ${digest}, expected ${download.sha256}`);
-  import_node_fs.default.mkdirSync(import_node_path2.default.dirname(target), { recursive: true });
-  const partial = `${target}.${process.pid}.partial`;
-  import_node_fs.default.writeFileSync(partial, bytes);
-  import_node_fs.default.renameSync(partial, target);
-}
-var toolchains = /* @__PURE__ */ new Map();
-function ensureToolchain(toolchain) {
-  const key = JSON.stringify(toolchain);
-  const pending = toolchains.get(key);
-  if (pending) return pending;
-  const ready = (async () => {
-    const dir = import_node_path2.default.join(kotlinHome(), toolchain.compiler.version);
-    const kotlinc = import_node_path2.default.join(dir, "kotlinc", "bin", "kotlinc-wasm");
-    if (!import_node_fs.default.existsSync(kotlinc)) {
-      const zip = import_node_path2.default.join(dir, "kotlin-compiler.zip");
-      await fetchVerified(toolchain.compiler, zip);
-      await run("unzip", ["-q", "-o", zip, "-d", dir]);
-      import_node_fs.default.rmSync(zip);
-    }
-    const java = process.env.JAVA_HOME ? import_node_path2.default.join(process.env.JAVA_HOME, "bin", "java") : "java";
-    const { stderr } = await run(java, ["-XshowSettings:properties", "-version"]).catch(
-      () => {
-        throw new Error(
-          `Kotlin in Peach compiles with kotlinc, which needs a Java runtime (17 or newer, as android builds use); ${process.env.JAVA_HOME ? `JAVA_HOME ${process.env.JAVA_HOME} has none` : "set JAVA_HOME or put java on PATH"}`
-        );
-      }
-    );
-    const javaHome = /^\s*java\.home\s*=\s*(.+)$/m.exec(stderr)?.[1]?.trim();
-    if (!javaHome || !import_node_path2.default.isAbsolute(javaHome))
-      throw new Error("the configured Java runtime did not report an absolute java.home");
-    const libraries = [import_node_path2.default.join(dir, "kotlinc", "lib", "kotlin-stdlib-wasm-js.klib")];
-    for (const library of toolchain.libraries) {
-      const target = import_node_path2.default.join(dir, library.name);
-      await fetchVerified(library, target);
-      libraries.push(target);
-    }
-    return { kotlinc, libraries, javaHome };
-  })().catch((error) => {
-    toolchains.delete(key);
-    throw error;
-  });
-  toolchains.set(key, ready);
-  return ready;
-}
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_child_process3 = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_util3 = require("node:util");
+init_kotlin_toolchain();
 
 // src/kotlinSdkContract.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+init_is_record();
 var platform = ["Sources", "JniPlatformSources", "JniSources"];
 var KOTLIN_SDK_PROFILES = {
   core: { compose: false, directories: platform },
@@ -402,62 +710,67 @@ function readKotlinSdkManifest(source, compilerSha256) {
 }
 
 // src/kotlin-sdk.ts
-var run2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var run3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
 function verifyKotlinSdkDirectory(root, compilerSha256) {
   const expectedNames = ["manifest.json", ...KOTLIN_SDK_FILES];
-  const names = import_node_fs2.default.readdirSync(root);
+  const names = import_node_fs3.default.readdirSync(root);
   if (names.length !== expectedNames.length || names.some((name) => !expectedNames.includes(name)))
     throw new Error("Kotlin SDK directory contains unexpected inputs");
-  const manifestStat = import_node_fs2.default.lstatSync(import_node_path3.default.join(root, "manifest.json"));
+  const manifestStat = import_node_fs3.default.lstatSync(import_node_path4.default.join(root, "manifest.json"));
   if (!manifestStat.isFile() || manifestStat.nlink !== 1)
     throw new Error("Kotlin SDK manifest is not a regular file");
   const manifest = readKotlinSdkManifest(
-    import_node_fs2.default.readFileSync(import_node_path3.default.join(root, "manifest.json"), "utf8"),
+    import_node_fs3.default.readFileSync(import_node_path4.default.join(root, "manifest.json"), "utf8"),
     compilerSha256
   );
   for (const [name, expected] of Object.entries(manifest.files)) {
-    const target = import_node_path3.default.join(root, name);
-    const stat = import_node_fs2.default.lstatSync(target);
+    const target = import_node_path4.default.join(root, name);
+    const stat = import_node_fs3.default.lstatSync(target);
     if (!stat.isFile() || stat.nlink !== 1)
       throw new Error(`Kotlin SDK binary is not a regular file: ${name}`);
-    const bytes = import_node_fs2.default.readFileSync(target);
-    if (bytes.length !== expected.bytes || (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex") !== expected.sha256)
+    const bytes = import_node_fs3.default.readFileSync(target);
+    if (bytes.length !== expected.bytes || (0, import_node_crypto3.createHash)("sha256").update(bytes).digest("hex") !== expected.sha256)
       throw new Error(`Kotlin SDK binary differs from its manifest: ${name}`);
   }
   return manifest;
 }
 async function installKotlinSdkArchive(archive, compilerSha256) {
-  const sha256 = (0, import_node_crypto2.createHash)("sha256").update(archive).digest("hex");
-  const parent = import_node_path3.default.join(kotlinHome(), "sdk");
-  const root = import_node_path3.default.join(parent, sha256);
-  if (import_node_fs2.default.existsSync(root))
+  const sha256 = (0, import_node_crypto3.createHash)("sha256").update(archive).digest("hex");
+  const parent = import_node_path4.default.join(kotlinHome(), "sdk");
+  const root = import_node_path4.default.join(parent, sha256);
+  if (import_node_fs3.default.existsSync(root))
     return { root, sha256, manifest: verifyKotlinSdkDirectory(root, compilerSha256) };
-  import_node_fs2.default.mkdirSync(parent, { recursive: true });
-  const work = import_node_fs2.default.mkdtempSync(import_node_path3.default.join(parent, ".install-"));
+  import_node_fs3.default.mkdirSync(parent, { recursive: true });
+  const work = import_node_fs3.default.mkdtempSync(import_node_path4.default.join(parent, ".install-"));
   try {
-    const packed = import_node_path3.default.join(work, "sdk.tar.gz");
-    import_node_fs2.default.writeFileSync(packed, archive);
-    const { stdout } = await run2("tar", ["-tzf", packed]);
+    const packed = import_node_path4.default.join(work, "sdk.tar.gz");
+    import_node_fs3.default.writeFileSync(packed, archive);
+    const { stdout } = await run3("tar", ["-tzf", packed]);
     const names = stdout.trim().split("\n");
     const expected = ["manifest.json", ...KOTLIN_SDK_FILES];
     if (names.length !== expected.length || new Set(names).size !== names.length || names.some((name) => !expected.includes(name)))
       throw new Error("Kotlin SDK archive contains unexpected inputs");
-    await run2("tar", ["-xzf", packed, "-C", work, "--", ...expected]);
-    import_node_fs2.default.rmSync(packed);
+    await run3("tar", ["-xzf", packed, "-C", work, "--", ...expected]);
+    import_node_fs3.default.rmSync(packed);
     const manifest = verifyKotlinSdkDirectory(work, compilerSha256);
     try {
-      import_node_fs2.default.renameSync(work, root);
+      import_node_fs3.default.renameSync(work, root);
     } catch (error) {
-      if (!import_node_fs2.default.existsSync(root)) throw error;
+      if (!import_node_fs3.default.existsSync(root)) throw error;
       verifyKotlinSdkDirectory(root, compilerSha256);
     }
     return { root, sha256, manifest };
   } finally {
-    import_node_fs2.default.rmSync(work, { recursive: true, force: true });
+    import_node_fs3.default.rmSync(work, { recursive: true, force: true });
   }
 }
 
+// src/kotlin-host.ts
+init_kotlin_toolchain();
+
 // src/kotlin-view-models.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+init_is_record();
 var VIEW_MODEL = "androidx.lifecycle.ViewModel";
 var ANDROID_VIEW_MODEL = "androidx.lifecycle.AndroidViewModel";
 var APPLICATION = "android.app.Application";
@@ -533,45 +846,49 @@ function viewModelClasses(rows) {
 }
 
 // src/kotlin-module.ts
-var import_node_crypto3 = require("node:crypto");
-var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path4 = __toESM(require("node:path"), 1);
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
+var import_node_crypto4 = require("node:crypto");
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
 
 // cli/standalone.ts
+init_define_SWIFT_COVERAGE_SOURCE_DIGESTS();
 var IS_STANDALONE = typeof __SOOTSIM_STANDALONE__ !== "undefined" && __SOOTSIM_STANDALONE__;
 
 // src/kotlin-module.ts
+init_home_paths();
+init_is_record();
 var installedRoot;
 function peachKotlinModuleRoot() {
   if (!IS_STANDALONE)
-    return import_node_path4.default.resolve(import_node_path4.default.dirname((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)), "..", "kotlin");
+    return import_node_path5.default.resolve(import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)), "..", "kotlin");
   if (installedRoot) return installedRoot;
   const files = __PEACH_BUNDLED_KOTLIN__;
-  const digest = (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(files)).digest("hex");
-  const parent = import_node_path4.default.join(rnxHomeDir(), "kotlin", "modules");
-  const root = import_node_path4.default.join(parent, digest);
-  import_node_fs3.default.mkdirSync(parent, { recursive: true });
-  if (!import_node_fs3.default.existsSync(root)) {
-    const pending = import_node_fs3.default.mkdtempSync(import_node_path4.default.join(parent, ".install-"));
+  const digest = (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(files)).digest("hex");
+  const parent = import_node_path5.default.join(rnxHomeDir(), "kotlin", "modules");
+  const root = import_node_path5.default.join(parent, digest);
+  import_node_fs4.default.mkdirSync(parent, { recursive: true });
+  if (!import_node_fs4.default.existsSync(root)) {
+    const pending = import_node_fs4.default.mkdtempSync(import_node_path5.default.join(parent, ".install-"));
     try {
       for (const [name, contents] of Object.entries(files)) {
-        const file = import_node_path4.default.join(pending, name);
-        import_node_fs3.default.mkdirSync(import_node_path4.default.dirname(file), { recursive: true });
-        import_node_fs3.default.writeFileSync(file, Buffer.from(contents, "base64"));
+        const file = import_node_path5.default.join(pending, name);
+        import_node_fs4.default.mkdirSync(import_node_path5.default.dirname(file), { recursive: true });
+        import_node_fs4.default.writeFileSync(file, Buffer.from(contents, "base64"));
       }
       try {
-        import_node_fs3.default.renameSync(pending, root);
+        import_node_fs4.default.renameSync(pending, root);
       } catch (error) {
         if (!isRecord(error) || error.code !== "EEXIST" && error.code !== "ENOTEMPTY")
           throw error;
       }
     } finally {
-      import_node_fs3.default.rmSync(pending, { recursive: true, force: true });
+      import_node_fs4.default.rmSync(pending, { recursive: true, force: true });
     }
   }
   for (const [name, contents] of Object.entries(files)) {
-    if (!import_node_fs3.default.readFileSync(import_node_path4.default.join(root, name)).equals(Buffer.from(contents, "base64")))
+    if (!import_node_fs4.default.readFileSync(import_node_path5.default.join(root, name)).equals(Buffer.from(contents, "base64")))
       throw new Error(`packaged Kotlin module differs from this CLI: ${name}`);
   }
   installedRoot = root;
@@ -579,20 +896,20 @@ function peachKotlinModuleRoot() {
 }
 
 // src/kotlin-host.ts
-var run3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+var run5 = (0, import_node_util5.promisify)(import_node_child_process5.execFile);
 function loadKotlinSdk(moduleRoot, toolchain) {
   return installKotlinSdkArchive(
-    import_node_fs4.default.readFileSync(import_node_path5.default.join(moduleRoot, "sdk.tar.gz")),
+    import_node_fs6.default.readFileSync(import_node_path7.default.join(moduleRoot, "sdk.tar.gz")),
     toolchain.compiler.sha256
   );
 }
 var KOTLIN_ARTIFACT_PREFIX = "/__peach/kotlin-artifact/";
 function appKotlinLanguage(root) {
-  const reactNative = import_node_path5.default.dirname(
-    (0, import_node_module.createRequire)(import_node_path5.default.join(root, "package.json")).resolve("react-native/package.json")
+  const reactNative = import_node_path7.default.dirname(
+    (0, import_node_module.createRequire)(import_node_path7.default.join(root, "package.json")).resolve("react-native/package.json")
   );
-  const versions = import_node_fs4.default.readFileSync(
-    import_node_path5.default.join(reactNative, "gradle", "libs.versions.toml"),
+  const versions = import_node_fs6.default.readFileSync(
+    import_node_path7.default.join(reactNative, "gradle", "libs.versions.toml"),
     "utf8"
   );
   const match = /^kotlin\s*=\s*"(\d+)\.(\d+)/m.exec(versions);
@@ -614,9 +931,9 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 function kotlinSources(root, skip = SKIP_DIRS) {
   const sources = [];
   const walk = (dir) => {
-    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of import_node_fs6.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || skip.has(entry.name)) continue;
-      const full = import_node_path5.default.join(dir, entry.name);
+      const full = import_node_path7.default.join(dir, entry.name);
       if (entry.isDirectory()) walk(full);
       else if (entry.isFile() && entry.name.endsWith(".kt")) sources.push(full);
     }
@@ -644,11 +961,12 @@ function entrySource(ids) {
     "",
     "@OptIn(kotlin.js.ExperimentalJsExport::class)",
     "@JsExport",
-    "fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String) {",
+    "fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String, properties: String) {",
     "    Build.setDevice(model, release, apiLevel)",
     "    java.util.Locale.setDefault(java.util.Locale.forLanguageTag(locale))",
     "    java.util.TimeZone.setDevice(timeZone)",
     "    dev.peach.android.ProcessSettings.configure(settings)",
+    "    android.os.SystemProperties.configure(properties)",
     "}",
     "",
     "@OptIn(kotlin.js.ExperimentalJsExport::class, kotlinx.coroutines.DelicateCoroutinesApi::class)",
@@ -679,7 +997,7 @@ function entrySource(ids) {
 var BUILD_FORMAT = 19;
 var builds = /* @__PURE__ */ new Map();
 function buildsDir() {
-  return import_node_path5.default.join(kotlinHome(), "builds");
+  return import_node_path7.default.join(kotlinHome(), "builds");
 }
 async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   const { kotlinSourceId, nativeSourceContract, renderKotlinSourceGlue } = await import("vxrn/native-source-contract");
@@ -692,7 +1010,7 @@ async function kotlinArtifact(root, moduleRoot, origin, target = "app") {
   const viewIds = [];
   let usesCompose = false;
   for (const file of sources) {
-    const source = import_node_fs4.default.readFileSync(file, "utf8");
+    const source = import_node_fs6.default.readFileSync(file, "utf8");
     if (/\bandroidx\.compose\./.test(source)) usesCompose = true;
     const contract = nativeSourceContract(file, source);
     if (contract.modules.length === 0 && contract.views.length === 0) continue;
@@ -782,24 +1100,24 @@ function readExpoTypes(output) {
 }
 var toolScans = /* @__PURE__ */ new Map();
 async function scanSources(tool, parse3, toolchain, moduleRoot, files) {
-  const digest = (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(toolchain.compiler));
+  const digest = (0, import_node_crypto6.createHash)("sha256").update(JSON.stringify(toolchain.compiler));
   const sdk = await loadKotlinSdk(moduleRoot, toolchain);
-  digest.update(import_node_fs4.default.readFileSync(import_node_path5.default.join(moduleRoot, "sdk.tar.gz")));
+  digest.update(import_node_fs6.default.readFileSync(import_node_path7.default.join(moduleRoot, "sdk.tar.gz")));
   digest.update(tool);
-  for (const file of files) digest.update(`${file}\0${import_node_fs4.default.readFileSync(file, "utf8")}\0`);
+  for (const file of files) digest.update(`${file}\0${import_node_fs6.default.readFileSync(file, "utf8")}\0`);
   const key = digest.digest("hex");
   let scan = toolScans.get(key);
   if (!scan) {
     scan = (async () => {
       const { kotlinc } = await ensureToolchain(toolchain);
-      const { stdout } = await run3(
-        import_node_path5.default.join(import_node_path5.default.dirname(kotlinc), "kotlin"),
+      const { stdout } = await run5(
+        import_node_path7.default.join(import_node_path7.default.dirname(kotlinc), "kotlin"),
         [
           "-cp",
           [
-            import_node_path5.default.resolve(import_node_path5.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
-            import_node_path5.default.join(sdk.root, "tools.jar")
-          ].join(import_node_path5.default.delimiter),
+            import_node_path7.default.resolve(import_node_path7.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+            import_node_path7.default.join(sdk.root, "tools.jar")
+          ].join(import_node_path7.default.delimiter),
           tool,
           ...files
         ],
@@ -817,7 +1135,7 @@ async function scanSources(tool, parse3, toolchain, moduleRoot, files) {
 async function scanExpoTypes(toolchain, moduleRoot, sources) {
   const candidates = sources.filter(
     (file) => /\bRecord\b|\benum\s+class\b|\bExpoComposeView\b|\bExpoView\b|\bComposeProps\b|:\s*(?:[A-Za-z0-9_.]+\.)?(?:View|FrameLayout|LinearLayout|ViewGroup)\b/.test(
-      import_node_fs4.default.readFileSync(file, "utf8")
+      import_node_fs6.default.readFileSync(file, "utf8")
     )
   );
   if (candidates.length === 0) return [];
@@ -1006,7 +1324,7 @@ function expoTypeSources(files) {
       )
     ];
     if (edits.length > 0 || views.length > 0) {
-      let text = import_node_fs4.default.readFileSync(file.file, "utf8").replaceAll("\r\n", "\n");
+      let text = import_node_fs6.default.readFileSync(file.file, "utf8").replaceAll("\r\n", "\n");
       for (const { range, owner, field } of edits.sort((a, b) => b.range[0] - a.range[0]))
         text = `${text.slice(0, range[0])}dev.peach.expo.PeachExpoTypes.initial(${owner}::class, ${literal(field.key)}, ${field.required}) { ${text.slice(range[0], range[1])} }${text.slice(range[1])}`;
       if (views.length > 0) {
@@ -1022,7 +1340,7 @@ function expoTypeSources(files) {
           `${file.package ? `${file.package}.` : ""}peachExpoViews${index}()`
         );
       }
-      const name = `PeachExpoSource_${index}_${import_node_path5.default.basename(file.file)}`;
+      const name = `PeachExpoSource_${index}_${import_node_path7.default.basename(file.file)}`;
       generated[name] = text;
       origins[name] = file.file;
     }
@@ -1041,11 +1359,30 @@ function expoTypeSources(files) {
   return { generated, origins, registrations };
 }
 async function expoKotlinArtifact(root, moduleRoot, origin, modules) {
+  if (modules.gradleSources) {
+    const { resolveAndroidGradleSources: resolveAndroidGradleSources2 } = await Promise.resolve().then(() => (init_android_gradle_sources(), android_gradle_sources_exports));
+    const projects = await resolveAndroidGradleSources2(modules.gradleSources);
+    modules = {
+      ...modules,
+      sources: [
+        .../* @__PURE__ */ new Set([
+          ...modules.sources,
+          ...projects.flatMap((project) => project.kotlin)
+        ])
+      ],
+      javaSpecs: [
+        .../* @__PURE__ */ new Set([
+          ...modules.javaSpecs ?? [],
+          ...projects.flatMap((project) => project.java)
+        ])
+      ]
+    };
+  }
   const toolchain = readToolchain(moduleRoot);
   const language = appKotlinLanguage(root);
   const scanned = await scanExpoTypes(toolchain, moduleRoot, modules.sources);
   const usesCompose = scanned.some((file) => file.views.length > 0) || modules.sources.some(
-    (file) => /\bandroidx\.compose\./.test(import_node_fs4.default.readFileSync(file, "utf8"))
+    (file) => /\bandroidx\.compose\./.test(import_node_fs6.default.readFileSync(file, "utf8"))
   );
   const types = expoTypeSources(scanned);
   const rewritten = new Set(Object.values(types.origins));
@@ -1064,11 +1401,12 @@ async function expoKotlinArtifact(root, moduleRoot, origin, modules) {
     "    ))",
     "}",
     "",
-    "@JsExport fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String) {",
+    "@JsExport fun peachSetAndroidDeviceInfo(model: String, release: String, apiLevel: Int, locale: String, timeZone: String, settings: String, properties: String) {",
     "    android.os.Build.setDevice(model, release, apiLevel)",
     "    java.util.Locale.setDefault(java.util.Locale.forLanguageTag(locale))",
     "    java.util.TimeZone.setDevice(timeZone)",
     "    dev.peach.android.ProcessSettings.configure(settings)",
+    "    android.os.SystemProperties.configure(properties)",
     "    PeachExpoRuntime.configureProcessLocale(locale)",
     "}",
     "",
@@ -1090,6 +1428,7 @@ async function expoKotlinArtifact(root, moduleRoot, origin, modules) {
       toolchain,
       language,
       sources: modules.sources.filter((file) => !rewritten.has(file)),
+      javaSpecs: modules.javaSpecs,
       generated: {
         ...types.generated,
         "PeachExpoEntry.kt": entry,
@@ -1270,7 +1609,7 @@ function appResourceSources(app) {
       entries: app.drawables.map((drawable) => ({
         name: drawable.name,
         init: `listOf(
-${drawable.files.map((file) => drawableInit(file, import_node_path5.default.relative(app.moduleDir, file.file))).join(",\n")}
+${drawable.files.map((file) => drawableInit(file, import_node_path7.default.relative(app.moduleDir, file.file))).join(",\n")}
 )`
       }))
     },
@@ -1339,7 +1678,7 @@ function drawableInit(drawable, file) {
   if (drawable.kind === "xml") return `PeachDrawable.Xml(${where})`;
   if (drawable.kind === "bitmap")
     return `PeachDrawable.Bitmap(${where}, ${drawable.ninePatch}, ${literal(
-      import_node_fs4.default.readFileSync(drawable.file).toString("base64")
+      import_node_fs6.default.readFileSync(drawable.file).toString("base64")
     )})`;
   const vector = drawable.vector;
   const float = (value) => `${value}f`;
@@ -1399,11 +1738,13 @@ async function compileKotlin(input, origin) {
     sdkProfile,
     usesCompose,
     usesSerialization = false,
-    viewModels
+    viewModels,
+    javaSpecs = []
   } = input;
   const sdk = await loadKotlinSdk(moduleRoot, toolchain);
-  const plugin = import_node_path5.default.join(sdk.root, "plugin.jar");
-  const sdkLibrary = import_node_path5.default.join(sdk.root, `${sdkProfile}.klib`);
+  const plugin = import_node_path7.default.join(sdk.root, "plugin.jar");
+  const sdkLibrary = import_node_path7.default.join(sdk.root, `${sdkProfile}.klib`);
+  const java = javaSpecs.length ? await readJavaModuleSpecs(javaSpecs, sdk.root, await ensureToolchain(toolchain)) : null;
   const generated = {
     ...sourceGenerated,
     "PeachBindingsInitialization.kt": [
@@ -1415,6 +1756,7 @@ async function compileKotlin(input, origin) {
       "@JsExport fun peachInitializeModuleBindings() {",
       "    if (!initialized) {",
       "        requireIncomingBindings()",
+      ...java ? [`        ${JAVA_BINDINGS_INITIALIZER}()`] : [],
       "        initializeApplicationIncomingBindings()",
       ...sourceGenerated["PeachViews.kt"] ? ["        initializeApplicationViews()"] : [],
       "        initialized = true",
@@ -1424,9 +1766,9 @@ async function compileKotlin(input, origin) {
   };
   const inputs = sources.map((file) => ({
     file,
-    bytes: import_node_fs4.default.readFileSync(file)
+    bytes: import_node_fs6.default.readFileSync(file)
   }));
-  const digest = (0, import_node_crypto4.createHash)("sha256");
+  const digest = (0, import_node_crypto6.createHash)("sha256");
   digest.update(
     JSON.stringify({
       format: BUILD_FORMAT,
@@ -1434,11 +1776,12 @@ async function compileKotlin(input, origin) {
       language,
       sdk: sdk.sha256,
       sdkProfile,
-      usesSerialization
+      usesSerialization,
+      java: java?.sha256
     })
   );
   for (const { file, bytes } of inputs)
-    digest.update(import_node_path5.default.relative(root, file)).update("\0").update(bytes).update("\0");
+    digest.update(import_node_path7.default.relative(root, file)).update("\0").update(bytes).update("\0");
   if (viewModels) digest.update(viewModels.toolClass);
   for (const [name, text] of Object.entries(generated))
     digest.update(`${name}\0${text}\0`);
@@ -1447,37 +1790,39 @@ async function compileKotlin(input, origin) {
     url: `${origin}${KOTLIN_ARTIFACT_PREFIX}${hash}/app.mjs`,
     hash
   };
-  const out = import_node_path5.default.join(buildsDir(), hash);
-  if (import_node_fs4.default.existsSync(import_node_path5.default.join(out, "js", "app.wasm"))) return artifact;
+  const out = import_node_path7.default.join(buildsDir(), hash);
+  if (import_node_fs6.default.existsSync(import_node_path7.default.join(out, "js", "app.wasm"))) return artifact;
   const pending = builds.get(hash);
   if (pending) return pending;
   const build = (async () => {
     const ready = await ensureToolchain(toolchain);
     const { kotlinc } = ready;
     const libraries = [...ready.libraries, sdkLibrary];
-    const composeRuntime = import_node_path5.default.join(
+    const composeRuntime = import_node_path7.default.join(
       kotlinHome(),
       toolchain.compiler.version,
       toolchain.composeRuntime.name
     );
     if (usesCompose) {
       for (const library of toolchain.composeLibraries) {
-        const target = import_node_path5.default.join(kotlinHome(), toolchain.compiler.version, library.name);
+        const target = import_node_path7.default.join(kotlinHome(), toolchain.compiler.version, library.name);
         await fetchVerified(library, target);
         libraries.push(target);
       }
       await fetchVerified(toolchain.composeRuntime, composeRuntime);
     }
-    import_node_fs4.default.mkdirSync(buildsDir(), { recursive: true });
-    const work = import_node_fs4.default.mkdtempSync(import_node_path5.default.join(buildsDir(), `${hash}-`));
-    const generatedDir = import_node_path5.default.join(work, "generated");
-    import_node_fs4.default.mkdirSync(generatedDir);
+    import_node_fs6.default.mkdirSync(buildsDir(), { recursive: true });
+    const work = import_node_fs6.default.mkdtempSync(import_node_path7.default.join(buildsDir(), `${hash}-`));
+    const javaLibrary = java ? import_node_path7.default.join(work, "java-abi", "java-abi.klib") : null;
+    if (javaLibrary) libraries.push(javaLibrary);
+    const generatedDir = import_node_path7.default.join(work, "generated");
+    import_node_fs6.default.mkdirSync(generatedDir);
     for (const [name, text] of Object.entries(generated))
-      import_node_fs4.default.writeFileSync(import_node_path5.default.join(generatedDir, name), text);
+      import_node_fs6.default.writeFileSync(import_node_path7.default.join(generatedDir, name), text);
     const compiledSources = inputs.map(({ file, bytes }, index) => {
-      const target = import_node_path5.default.join(work, "sources", String(index), import_node_path5.default.basename(file));
-      import_node_fs4.default.mkdirSync(import_node_path5.default.dirname(target), { recursive: true });
-      import_node_fs4.default.writeFileSync(target, bytes);
+      const target = import_node_path7.default.join(work, "sources", String(index), import_node_path7.default.basename(file));
+      import_node_fs6.default.mkdirSync(import_node_path7.default.dirname(target), { recursive: true });
+      import_node_fs6.default.writeFileSync(target, bytes);
       return { file, target };
     });
     const common = [
@@ -1486,19 +1831,19 @@ async function compileKotlin(input, origin) {
       "-Xallow-kotlin-package",
       "-Xwasm-target=js",
       "-libraries",
-      libraries.join(import_node_path5.default.delimiter)
+      libraries.join(import_node_path7.default.delimiter)
     ];
-    const compileKlib = (outputDir) => run3(
+    const compileKlib = (outputDir) => run5(
       kotlinc,
       [
         ...common,
         `-Xplugin=${plugin}`,
-        `-Xfriend-modules=${sdkLibrary}`,
+        `-Xfriend-modules=${[sdkLibrary, ...javaLibrary ? [javaLibrary] : []].join(import_node_path7.default.delimiter)}`,
         ...usesCompose ? [
-          `-Xplugin=${import_node_path5.default.resolve(import_node_path5.default.dirname(kotlinc), "../lib/compose-compiler-plugin.jar")}`
+          `-Xplugin=${import_node_path7.default.resolve(import_node_path7.default.dirname(kotlinc), "../lib/compose-compiler-plugin.jar")}`
         ] : [],
         ...usesSerialization ? [
-          `-Xplugin=${import_node_path5.default.resolve(import_node_path5.default.dirname(kotlinc), "../lib/kotlinx-serialization-compiler-plugin.jar")}`
+          `-Xplugin=${import_node_path7.default.resolve(import_node_path7.default.dirname(kotlinc), "../lib/kotlinx-serialization-compiler-plugin.jar")}`
         ] : [],
         "-language-version",
         language,
@@ -1511,59 +1856,70 @@ async function compileKotlin(input, origin) {
         "-ir-output-name",
         "app",
         ...compiledSources.map(({ target }) => target),
-        ...Object.keys(generated).map((name) => import_node_path5.default.join(generatedDir, name))
+        ...Object.keys(generated).map((name) => import_node_path7.default.join(generatedDir, name))
       ],
       { maxBuffer: 16 * 1024 * 1024 }
     );
     try {
+      if (java)
+        await compileJavaModuleAbi({
+          specs: java,
+          work,
+          hash,
+          toolchain: ready,
+          libraries: libraries.filter((library) => library !== javaLibrary),
+          sdkRoot: sdk.root,
+          sdkLibrary,
+          language
+        });
       if (viewModels && inputs.some(
         ({ file, bytes }) => sources.includes(file) && bytes.includes("ViewModel")
       )) {
-        await compileKlib(import_node_path5.default.join(work, "abi"));
-        const { stdout } = await run3(
-          import_node_path5.default.join(import_node_path5.default.dirname(kotlinc), "kotlin"),
+        await compileKlib(import_node_path7.default.join(work, "abi"));
+        const { stdout } = await run5(
+          import_node_path7.default.join(import_node_path7.default.dirname(kotlinc), "kotlin"),
           [
             "-cp",
             [
-              import_node_path5.default.resolve(import_node_path5.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
-              import_node_path5.default.join(sdk.root, "tools.jar")
-            ].join(import_node_path5.default.delimiter),
+              import_node_path7.default.resolve(import_node_path7.default.dirname(kotlinc), "../lib/kotlin-compiler.jar"),
+              import_node_path7.default.join(sdk.root, "tools.jar")
+            ].join(import_node_path7.default.delimiter),
             viewModels.toolClass,
-            import_node_path5.default.join(work, "abi")
+            import_node_path7.default.join(work, "abi")
           ],
           { maxBuffer: 64 * 1024 * 1024 }
         );
-        import_node_fs4.default.writeFileSync(
-          import_node_path5.default.join(generatedDir, viewModels.file),
+        import_node_fs6.default.writeFileSync(
+          import_node_path7.default.join(generatedDir, viewModels.file),
           viewModels.render(viewModelClasses(readAbiClasses(stdout)))
         );
       }
-      await compileKlib(import_node_path5.default.join(work, "klib"));
-      await run3(
+      await compileKlib(import_node_path7.default.join(work, "klib"));
+      await run5(
         kotlinc,
         [
           ...common,
           "-nowarn",
-          `-Xinclude=${import_node_path5.default.join(work, "klib")}`,
+          `-Xinclude=${import_node_path7.default.join(work, "klib")}`,
           "-Xir-produce-js",
           "-ir-output-dir",
-          import_node_path5.default.join(work, "js"),
+          import_node_path7.default.join(work, "js"),
           "-ir-output-name",
           "app"
         ],
         { maxBuffer: 16 * 1024 * 1024 }
       );
       if (usesCompose) {
-        await run3("unzip", [
+        await run5("unzip", [
           "-q",
           "-j",
           composeRuntime,
           "skiko.mjs",
           "-d",
-          import_node_path5.default.join(work, "js")
+          import_node_path7.default.join(work, "js")
         ]);
-        const skikoPath = import_node_path5.default.join(work, "js", "skiko.mjs");
-        const upstream = (0, import_acorn2.parse)(import_node_fs4.default.readFileSync(skikoPath, "utf8"), {
+        const skikoPath = import_node_path7.default.join(work, "js", "skiko.mjs");
+        const upstream = (0, import_acorn2.parse)(import_node_fs6.default.readFileSync(skikoPath, "utf8"), {
           ecmaVersion: "latest",
           sourceType: "module"
         });
@@ -1586,7 +1942,7 @@ async function compileKotlin(input, origin) {
           "GL",
           ...bindings
         ];
-        import_node_fs4.default.writeFileSync(
+        import_node_fs6.default.writeFileSync(
           skikoPath,
           [
             "const runtime = globalThis.__peachKotlinSkiko;",
@@ -1600,10 +1956,10 @@ async function compileKotlin(input, origin) {
       if (usesCompose) {
         for (const library of toolchain.composeJsLibraries) {
           let imported = false;
-          for (const file of import_node_fs4.default.readdirSync(import_node_path5.default.join(work, "js"))) {
+          for (const file of import_node_fs6.default.readdirSync(import_node_path7.default.join(work, "js"))) {
             if (!file.endsWith(".mjs")) continue;
-            const target = import_node_path5.default.join(work, "js", file);
-            const source = import_node_fs4.default.readFileSync(target, "utf8");
+            const target = import_node_path7.default.join(work, "js", file);
+            const source = import_node_fs6.default.readFileSync(target, "utf8");
             let next = source;
             for (const quote of ["'", '"'])
               next = next.replaceAll(
@@ -1611,29 +1967,34 @@ async function compileKotlin(input, origin) {
                 `from ${quote}./${library.file}${quote}`
               );
             if (next === source) continue;
-            import_node_fs4.default.writeFileSync(target, next);
+            import_node_fs6.default.writeFileSync(target, next);
             imported = true;
           }
           if (!imported) continue;
-          const archive = import_node_path5.default.join(
+          const archive = import_node_path7.default.join(
             kotlinHome(),
             toolchain.compiler.version,
             library.name
           );
           await fetchVerified(library, archive);
-          const { stdout } = await run3("tar", ["-xOf", archive, library.archiveEntry], {
+          const { stdout } = await run5("tar", ["-xOf", archive, library.archiveEntry], {
             maxBuffer: 16 * 1024 * 1024
           });
-          import_node_fs4.default.writeFileSync(import_node_path5.default.join(work, "js", library.file), stdout);
+          import_node_fs6.default.writeFileSync(import_node_path7.default.join(work, "js", library.file), stdout);
         }
       }
     } catch (error) {
-      import_node_fs4.default.rmSync(work, { recursive: true, force: true });
+      import_node_fs6.default.rmSync(work, { recursive: true, force: true });
       let output = isRecord(error) ? `${String(error.stderr ?? "")}${String(error.stdout ?? "")}` : "";
       for (const [name, source] of Object.entries(origins))
-        output = output.replaceAll(import_node_path5.default.join(generatedDir, name), source);
+        output = output.replaceAll(import_node_path7.default.join(generatedDir, name), source);
       for (const { file, target } of compiledSources)
-        output = output.replaceAll(target, file).replaceAll(import_node_path5.default.relative(process.cwd(), target), file);
+        output = output.replaceAll(target, file).replaceAll(import_node_path7.default.relative(process.cwd(), target), file);
+      for (const [index, spec] of (java?.specs ?? []).entries())
+        output = output.replaceAll(
+          import_node_path7.default.join(work, "java-abi", `Spec${index}.kt`),
+          spec.file
+        );
       throw new Error(
         `kotlin compile failed:
 ${output.trim() || (error instanceof Error ? error.message : String(error))}`
@@ -1642,9 +2003,9 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
     const seams = [
       ["process.release.name", "process.release?.name"]
     ];
-    const js = import_node_fs4.default.readdirSync(import_node_path5.default.join(work, "js")).filter((file) => file.endsWith(".mjs"));
+    const js = import_node_fs6.default.readdirSync(import_node_path7.default.join(work, "js")).filter((file) => file.endsWith(".mjs"));
     if (js.some(
-      (file) => import_node_fs4.default.readFileSync(import_node_path5.default.join(work, "js", file), "utf8").includes("'kotlinx.coroutines.")
+      (file) => import_node_fs6.default.readFileSync(import_node_path7.default.join(work, "js", file), "utf8").includes("'kotlinx.coroutines.")
     ))
       seams.push([
         "(typeof(window) !== 'undefined' && window != null && typeof(window.addEventListener) === 'function') ? window : null",
@@ -1653,12 +2014,12 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
     for (const [from, to] of seams) {
       let patched = 0;
       for (const file of js) {
-        const target = import_node_path5.default.join(work, "js", file);
-        const text = import_node_fs4.default.readFileSync(target, "utf8");
+        const target = import_node_path7.default.join(work, "js", file);
+        const text = import_node_fs6.default.readFileSync(target, "utf8");
         const next = text.replaceAll(from, to);
         if (next !== text) {
           patched++;
-          import_node_fs4.default.writeFileSync(target, next);
+          import_node_fs6.default.writeFileSync(target, next);
         }
       }
       if (patched === 0)
@@ -1666,11 +2027,11 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
           `kotlin output no longer contains ${from}; recheck how it detects its host in Peach`
         );
     }
-    const entry = import_node_path5.default.join(work, "js/app.mjs");
-    const entrySource2 = import_node_fs4.default.readFileSync(entry, "utf8");
-    const importsPath = import_node_path5.default.join(work, "js/app.import-object.mjs");
+    const entry = import_node_path7.default.join(work, "js/app.mjs");
+    const entrySource2 = import_node_fs6.default.readFileSync(entry, "utf8");
+    const importsPath = import_node_path7.default.join(work, "js/app.import-object.mjs");
     const importsFactory = kotlinInstanceSource(
-      import_node_fs4.default.readFileSync(importsPath, "utf8"),
+      import_node_fs6.default.readFileSync(importsPath, "utf8"),
       "createKotlinImportObject"
     );
     const runtimeFactory = kotlinInstanceSource(
@@ -1678,9 +2039,9 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
       "createKotlinInstance",
       /* @__PURE__ */ new Map([["./app.import-object.mjs", "createKotlinImportObject"]])
     );
-    import_node_fs4.default.writeFileSync(importsPath, importsFactory.source);
-    import_node_fs4.default.writeFileSync(import_node_path5.default.join(work, "js/app-runtime.mjs"), runtimeFactory.source);
-    import_node_fs4.default.writeFileSync(
+    import_node_fs6.default.writeFileSync(importsPath, importsFactory.source);
+    import_node_fs6.default.writeFileSync(import_node_path7.default.join(work, "js/app-runtime.mjs"), runtimeFactory.source);
+    import_node_fs6.default.writeFileSync(
       entry,
       [
         "import { createKotlinInstance } from './app-runtime.mjs';",
@@ -1693,10 +2054,10 @@ ${output.trim() || (error instanceof Error ? error.message : String(error))}`
       ].join("\n")
     );
     try {
-      import_node_fs4.default.renameSync(work, out);
+      import_node_fs6.default.renameSync(work, out);
     } catch (error) {
-      if (!import_node_fs4.default.existsSync(import_node_path5.default.join(out, "js", "app.wasm"))) throw error;
-      import_node_fs4.default.rmSync(work, { recursive: true, force: true });
+      if (!import_node_fs6.default.existsSync(import_node_path7.default.join(out, "js", "app.wasm"))) throw error;
+      import_node_fs6.default.rmSync(work, { recursive: true, force: true });
     }
     return artifact;
   })().finally(() => builds.delete(hash));
@@ -1708,24 +2069,24 @@ var CONTENT_TYPES = {
   ".wasm": "application/wasm"
 };
 function kotlinArtifactFiles(hash) {
-  const dir = import_node_path5.default.join(buildsDir(), hash, "js");
-  return import_node_fs4.default.readdirSync(dir).sort().map((name) => {
-    const contentType = CONTENT_TYPES[import_node_path5.default.extname(name)];
+  const dir = import_node_path7.default.join(buildsDir(), hash, "js");
+  return import_node_fs6.default.readdirSync(dir).sort().map((name) => {
+    const contentType = CONTENT_TYPES[import_node_path7.default.extname(name)];
     if (!contentType) throw new Error(`unexpected kotlin artifact file ${name}`);
-    return { name, bytes: import_node_fs4.default.readFileSync(import_node_path5.default.join(dir, name)), contentType };
+    return { name, bytes: import_node_fs6.default.readFileSync(import_node_path7.default.join(dir, name)), contentType };
   });
 }
 function serveKotlinArtifact(pathname, res) {
   if (!pathname.startsWith(KOTLIN_ARTIFACT_PREFIX)) return false;
   const [hash, file, ...rest] = pathname.slice(KOTLIN_ARTIFACT_PREFIX.length).split("/");
-  const type = file ? CONTENT_TYPES[import_node_path5.default.extname(file)] : void 0;
+  const type = file ? CONTENT_TYPES[import_node_path7.default.extname(file)] : void 0;
   if (!hash || !/^[0-9a-f]+$/.test(hash) || !file || rest.length > 0 || !type || file.includes("..")) {
     res.statusCode = 404;
     res.end("not a kotlin artifact");
     return true;
   }
-  const target = import_node_path5.default.join(buildsDir(), hash, "js", file);
-  if (!import_node_fs4.default.existsSync(target)) {
+  const target = import_node_path7.default.join(buildsDir(), hash, "js", file);
+  if (!import_node_fs6.default.existsSync(target)) {
     res.statusCode = 404;
     res.end(`kotlin artifact ${hash}/${file} was not built`);
     return true;
@@ -1733,7 +2094,7 @@ function serveKotlinArtifact(pathname, res) {
   res.setHeader("access-control-allow-origin", "*");
   res.setHeader("content-type", type);
   res.setHeader("cache-control", "public, max-age=31536000, immutable");
-  res.end(import_node_fs4.default.readFileSync(target));
+  res.end(import_node_fs6.default.readFileSync(target));
   return true;
 }
 var KOTLIN_PACKAGE_PATH = "/__peach/kotlin-package";