peachsim 0.1.578 → 0.1.580

package/dist-lib/vite-kotlin.cjs

@@ -0,0 +1,356 @@
+/*! rnx v0.1.580 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vite-plugin-kotlin.ts
+var vite_plugin_kotlin_exports = {};
+__export(vite_plugin_kotlin_exports, {
+  KOTLIN_ARTIFACT_PREFIX: () => KOTLIN_ARTIFACT_PREFIX,
+  kotlinArtifact: () => kotlinArtifact,
+  kotlinSources: () => kotlinSources,
+  serveKotlinArtifact: () => serveKotlinArtifact
+});
+module.exports = __toCommonJS(vite_plugin_kotlin_exports);
+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_module = require("node:module");
+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 rnxHomeDir() {
+  const override = process.env[PEACH_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".peach");
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/vite-plugin-kotlin.ts
+var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var KOTLIN_ARTIFACT_PREFIX = "/__peach/kotlin-artifact/";
+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))
+    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");
+  return {
+    compiler: { ...download(parsed.compiler), version },
+    libraries: parsed.libraries.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 };
+    })
+  };
+}
+function kotlinHome() {
+  return import_node_path2.default.join(rnxHomeDir(), "kotlin");
+}
+async function fetchVerified(download, target) {
+  if (import_node_fs.default.existsSync(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 toolchainReady;
+function ensureToolchain(toolchain) {
+  toolchainReady ??= (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";
+    await run(java, ["-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 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 };
+  })().catch((error) => {
+    toolchainReady = void 0;
+    throw error;
+  });
+  return toolchainReady;
+}
+function appKotlinLanguage(root) {
+  const reactNative = import_node_path2.default.dirname(
+    (0, import_node_module.createRequire)(import_node_path2.default.join(root, "package.json")).resolve("react-native/package.json")
+  );
+  const versions = import_node_fs.default.readFileSync(
+    import_node_path2.default.join(reactNative, "gradle", "libs.versions.toml"),
+    "utf8"
+  );
+  const match = /^kotlin\s*=\s*"(\d+)\.(\d+)/m.exec(versions);
+  if (!match)
+    throw new Error(`${reactNative}/gradle/libs.versions.toml names no kotlin version`);
+  return `${match[1]}.${match[2]}`;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "ios",
+  "android",
+  "dist",
+  "types",
+  "build",
+  "tests",
+  "__tests__",
+  "scripts"
+]);
+function kotlinSources(root) {
+  const sources = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name)) continue;
+      const full = import_node_path2.default.join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile() && entry.name.endsWith(".kt")) sources.push(full);
+    }
+  };
+  walk(root);
+  return sources.sort();
+}
+function entrySource(ids) {
+  return [
+    "import kotlin.js.JsAny",
+    "import kotlin.js.Promise",
+    "import kotlinx.coroutines.CoroutineStart",
+    "import kotlinx.coroutines.Dispatchers",
+    "import kotlinx.coroutines.GlobalScope",
+    "import kotlinx.coroutines.promise",
+    "import dev.onejs.one.OneNativeSourceDispatch",
+    "import org.json.JSONObject",
+    "",
+    "private val instances = mutableMapOf<String, OneNativeSourceDispatch>()",
+    "",
+    "private fun dispatcher(packageName: String): OneNativeSourceDispatch? = instances[packageName] ?: when (packageName) {",
+    ...ids.map((id) => `    ${JSON.stringify(id)} -> OneNativeSource_${id}()`),
+    "    else -> null",
+    "}?.also { instances[packageName] = it }",
+    "",
+    "@OptIn(kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class, kotlinx.coroutines.DelicateCoroutinesApi::class)",
+    "@JsExport",
+    "fun peachNativeCall(module: String, method: String, argsJson: String, contractHash: String): Promise<JsAny?> =",
+    "    GlobalScope.promise(Dispatchers.Main, CoroutineStart.UNDISPATCHED) {",
+    "        val reply = JSONObject()",
+    "        try {",
+    `            val packageName = module.substringBefore('.', "")`,
+    "            val dispatch = dispatcher(packageName)",
+    "            if (packageName.isEmpty() || !module.contains('.')) {",
+    '                reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "invalid module $module")',
+    "            } else if (dispatch == null) {",
+    '                reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$module.$method: OneNativeSource_$packageName")',
+    "            } else if (dispatch.contractHash != contractHash) {",
+    '                reply.put("ok", false).put("code", "E_NATIVE_SOURCE_REBUILD").put("error", "native module $module changed; rebuild the app")',
+    "            } else {",
+    '                reply.put("ok", true).put("value", dispatch.call(module, method, argsJson))',
+    "            }",
+    "        } catch (error: Exception) {",
+    '            reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$module.$method: ${error.message}")',
+    "        }",
+    "        reply.toString().toJsString()",
+    "    }",
+    ""
+  ].join("\n");
+}
+var BUILD_FORMAT = 1;
+var builds = /* @__PURE__ */ new Map();
+function buildsDir() {
+  return import_node_path2.default.join(kotlinHome(), "builds");
+}
+async function kotlinArtifact(root, moduleRoot, origin) {
+  const { kotlinSourceId, nativeSourceContract, renderKotlinSourceGlue } = await import("vxrn/native-source-contract");
+  const toolchain = readToolchain(moduleRoot);
+  const language = appKotlinLanguage(root);
+  const sources = kotlinSources(root);
+  if (sources.length === 0) throw new Error(`${root} holds no Kotlin sources`);
+  const generated = {};
+  const ids = [];
+  for (const file of sources) {
+    const contract = nativeSourceContract(file, import_node_fs.default.readFileSync(file, "utf8"));
+    if (contract.modules.length === 0) continue;
+    const id = kotlinSourceId(root, file);
+    ids.push(id);
+    generated[`OneNativeSource_${id}.kt`] = renderKotlinSourceGlue(id, contract).source;
+  }
+  generated["PeachEntry.kt"] = entrySource(ids);
+  const shims = kotlinSources(import_node_path2.default.join(moduleRoot, "Sources"));
+  const digest = (0, import_node_crypto.createHash)("sha256");
+  digest.update(JSON.stringify({ format: BUILD_FORMAT, toolchain, language }));
+  for (const file of [...shims, ...sources])
+    digest.update(`${import_node_path2.default.relative(root, file)}\0${import_node_fs.default.readFileSync(file, "utf8")}\0`);
+  for (const [name, text] of Object.entries(generated))
+    digest.update(`${name}\0${text}\0`);
+  const hash = digest.digest("hex").slice(0, 24);
+  const artifact = { url: `${origin}${KOTLIN_ARTIFACT_PREFIX}${hash}/app.mjs`, hash };
+  const out = import_node_path2.default.join(buildsDir(), hash);
+  if (import_node_fs.default.existsSync(import_node_path2.default.join(out, "js", "app.wasm"))) return artifact;
+  const pending = builds.get(hash);
+  if (pending) return pending;
+  const build = (async () => {
+    const { kotlinc, libraries } = await ensureToolchain(toolchain);
+    import_node_fs.default.mkdirSync(buildsDir(), { recursive: true });
+    const work = import_node_fs.default.mkdtempSync(import_node_path2.default.join(buildsDir(), `${hash}-`));
+    const generatedDir = import_node_path2.default.join(work, "generated");
+    import_node_fs.default.mkdirSync(generatedDir);
+    for (const [name, text] of Object.entries(generated))
+      import_node_fs.default.writeFileSync(import_node_path2.default.join(generatedDir, name), text);
+    const common = ["-Xwasm-target=js", "-libraries", libraries.join(import_node_path2.default.delimiter)];
+    try {
+      await run(
+        kotlinc,
+        [
+          ...common,
+          "-language-version",
+          language,
+          "-api-version",
+          language,
+          "-nowarn",
+          "-nopack",
+          "-ir-output-dir",
+          import_node_path2.default.join(work, "klib"),
+          "-ir-output-name",
+          "app",
+          ...shims,
+          ...sources,
+          ...Object.keys(generated).map((name) => import_node_path2.default.join(generatedDir, name))
+        ],
+        { maxBuffer: 16 * 1024 * 1024 }
+      );
+      await run(
+        kotlinc,
+        [
+          ...common,
+          "-nowarn",
+          `-Xinclude=${import_node_path2.default.join(work, "klib")}`,
+          "-Xir-produce-js",
+          "-ir-output-dir",
+          import_node_path2.default.join(work, "js"),
+          "-ir-output-name",
+          "app"
+        ],
+        { maxBuffer: 16 * 1024 * 1024 }
+      );
+    } catch (error) {
+      import_node_fs.default.rmSync(work, { recursive: true, force: true });
+      const output = isRecord(error) ? `${String(error.stderr ?? "")}${String(error.stdout ?? "")}` : "";
+      throw new Error(
+        `kotlin compile failed:
+${output.trim() || (error instanceof Error ? error.message : String(error))}`
+      );
+    }
+    let patched = 0;
+    for (const file of import_node_fs.default.readdirSync(import_node_path2.default.join(work, "js"))) {
+      if (!file.endsWith(".mjs")) continue;
+      const target = import_node_path2.default.join(work, "js", file);
+      const text = import_node_fs.default.readFileSync(target, "utf8");
+      const next = text.replaceAll("process.release.name", "process.release?.name");
+      if (next !== text) {
+        patched++;
+        import_node_fs.default.writeFileSync(target, next);
+      }
+    }
+    if (patched === 0)
+      throw new Error(
+        "kotlin loader no longer reads process.release.name; recheck its node detection in Peach"
+      );
+    import_node_fs.default.renameSync(work, out);
+    return artifact;
+  })().finally(() => builds.delete(hash));
+  builds.set(hash, build);
+  return build;
+}
+var CONTENT_TYPES = {
+  ".mjs": "text/javascript",
+  ".wasm": "application/wasm"
+};
+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_path2.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_path2.default.join(buildsDir(), hash, "js", file);
+  if (!import_node_fs.default.existsSync(target)) {
+    res.statusCode = 404;
+    res.end(`kotlin artifact ${hash}/${file} was not built`);
+    return true;
+  }
+  res.setHeader("access-control-allow-origin", "*");
+  res.setHeader("content-type", type);
+  res.setHeader("cache-control", "public, max-age=31536000, immutable");
+  res.end(import_node_fs.default.readFileSync(target));
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KOTLIN_ARTIFACT_PREFIX,
+  kotlinArtifact,
+  kotlinSources,
+  serveKotlinArtifact
+});