peachsim 0.1.940 → 0.1.1400

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.940 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! peach v0.1.1400 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;
@@ -33,13 +33,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var vite_plugin_one_exports = {};
 __export(vite_plugin_one_exports, {
   default: () => vite_plugin_one_default,
-  rnxPlugin: () => rnxPlugin,
-  sootsimPlugin: () => sootsimPlugin
+  peachPlugin: () => peachPlugin
 });
 module.exports = __toCommonJS(vite_plugin_one_exports);
 var import_fs2 = __toESM(require("fs"), 1);
 var import_node_crypto3 = require("node:crypto");
-var import_node_module2 = require("node:module");
+var import_node_url = require("node:url");
 var import_path2 = __toESM(require("path"), 1);
 var import_ws = require("ws");
 
@@ -554,6 +553,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   } catch {
     return false;
   }
+  if (url.pathname !== REPLACEMENT_MODULE_ROUTE) return false;
   if (options.requireLoopbackOrigin) {
     const origin = req.headers.origin;
     const remoteAddress = req.socket.remoteAddress?.replace(/^::ffff:/, "");
@@ -571,7 +571,6 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
       return true;
     }
   }
-  if (url.pathname !== REPLACEMENT_MODULE_ROUTE) return false;
   if (options.requestToken && url.searchParams.get("token") !== options.requestToken) {
     res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement module request token is invalid");
@@ -720,6 +719,8 @@ var SWIFT_HMR_PATH = "/__peach/swift-hmr";
 var MAX_SWIFT_COMPILE_SOURCE_BYTES = 2 * 1024 * 1024;
 var MAX_SWIFT_COMPILE_RESOURCE_BYTES = 2 * 1024 * 1024;
 var MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES = 8 * 1024 * 1024;
+var MAX_SWIFT_COMPILE_METAL_BYTES = 2 * 1024 * 1024;
+var MAX_SWIFT_COMPILE_METAL_TOTAL_BYTES = 8 * 1024 * 1024;
 var MAX_SWIFT_COMPILE_IMAGE_BYTES = 4 * 1024 * 1024;
 var MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024;
 
@@ -1072,8 +1073,8 @@ var loadSwiftHost = () => swiftHost ??= import("peachsim/vite-swift");
 var KOTLIN_ROUTE_PREFIX = "/__peach/kotlin";
 var kotlinHost;
 var loadKotlinHost = () => kotlinHost ??= import("peachsim/kotlin-host");
-function rnxPlugin(options = {}) {
-  const prefix = options.prefix || "/__soot";
+function peachPlugin(options = {}) {
+  const prefix = options.prefix || "/__peachsim";
   return {
     name: "sootsim-one",
     // use-latest-callback ships a CJS main (module.exports, no default) with
@@ -1094,12 +1095,9 @@ function rnxPlugin(options = {}) {
       let swiftModuleRoot;
       const moduleRootFor = () => {
         if (swiftModuleRoot === void 0) {
-          const peachsimPackage = (0, import_node_module2.createRequire)(
-            import_path2.default.join(server.config.root, "package.json")
-          ).resolve("peachsim/package.json");
           const moduleRoot = import_path2.default.resolve(
-            import_path2.default.dirname(peachsimPackage),
-            "../sootsim-swift"
+            import_path2.default.dirname((0, import_node_url.fileURLToPath)(__sootsim_import_meta_url)),
+            "../../sootsim-swift"
           );
           swiftModuleRoot = import_fs2.default.existsSync(import_path2.default.join(moduleRoot, "toolchain.json")) ? moduleRoot : null;
         }
@@ -1186,7 +1184,7 @@ function rnxPlugin(options = {}) {
         if (!pathname.startsWith(KOTLIN_ROUTE_PREFIX)) return next();
         loadKotlinHost().then(async (host) => {
           if (!kotlinModuleRoot) {
-            kotlinModuleRoot = host.peachKotlinModuleRoot(server.config.root);
+            kotlinModuleRoot = host.peachKotlinModuleRoot();
             server.watcher.add(import_path2.default.join(kotlinModuleRoot, "Sources"));
           }
           const served = await host.serveKotlinRequest(pathname, res, {
@@ -1410,10 +1408,8 @@ function rnxPlugin(options = {}) {
     }
   };
 }
-var sootsimPlugin = rnxPlugin;
-var vite_plugin_one_default = rnxPlugin;
+var vite_plugin_one_default = peachPlugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  rnxPlugin,
-  sootsimPlugin
+  peachPlugin
 });

package/dist-lib/worklet-executable.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.940 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! peach v0.1.1400 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;
@@ -30,51 +30,266 @@ var import_acorn = require("acorn");
 function isNode(value) {
   return value !== null && typeof value === "object" && typeof Reflect.get(value, "type") === "string";
 }
-function walk(node, visit) {
-  visit(node);
-  for (const value of Object.values(node)) {
-    if (isNode(value)) walk(value, visit);
-    else if (Array.isArray(value)) {
-      for (const child of value) if (isNode(child)) walk(child, visit);
-    }
-  }
+function childNodes(value) {
+  return Array.isArray(value) ? value.filter(isNode) : [];
+}
+function identifierName(node) {
+  if (!isNode(node) || node.type !== "Identifier") return void 0;
+  const name = Reflect.get(node, "name");
+  return typeof name === "string" ? name : void 0;
 }
 function propertyName(node) {
   if (!isNode(node)) return void 0;
   const name = Reflect.get(node, node.type === "Identifier" ? "name" : "value");
   return typeof name === "string" ? name : void 0;
 }
-function workletExecutableBodies(syntax) {
-  if (!isNode(syntax)) throw new Error("peach: expected worklet syntax");
-  const tree = syntax;
-  const initNames = /* @__PURE__ */ new Set();
-  const objects = /* @__PURE__ */ new Set();
-  walk(tree, (node) => {
-    if (node.type !== "AssignmentExpression") return;
-    const left = Reflect.get(node, "left");
-    if (!isNode(left) || left.type !== "MemberExpression" || propertyName(Reflect.get(left, "property")) !== "__initData")
+function keyName(owner, key) {
+  if (Reflect.get(owner, "computed") === true && isNode(key) && key.type === "Identifier")
+    return void 0;
+  return propertyName(key);
+}
+function patternNames(node) {
+  if (!isNode(node)) return [];
+  switch (node.type) {
+    case "Identifier": {
+      const name = identifierName(node);
+      return name === void 0 ? [] : [name];
+    }
+    case "AssignmentPattern":
+      return patternNames(Reflect.get(node, "left"));
+    case "RestElement":
+      return patternNames(Reflect.get(node, "argument"));
+    case "ArrayPattern":
+      return childNodes(Reflect.get(node, "elements")).flatMap(patternNames);
+    case "ObjectPattern":
+      return childNodes(Reflect.get(node, "properties")).flatMap(
+        (property) => patternNames(
+          property.type === "Property" || property.type === "ObjectProperty" ? Reflect.get(property, "value") : property
+        )
+      );
+    default:
+      return [];
+  }
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+var MAX_RESOLUTION_DEPTH = 32;
+function newScope(parent, hoist) {
+  return { parent, hoist, names: /* @__PURE__ */ new Map() };
+}
+function hoistScope(scope) {
+  let current = scope;
+  while (!current.hoist && current.parent) current = current.parent;
+  return current;
+}
+function declare(scope, name, binding) {
+  scope.names.set(name, scope.names.has(name) ? { kind: "opaque" } : binding);
+}
+function declareOpaque(scope, names) {
+  for (const name of names) declare(scope, name, { kind: "opaque" });
+}
+function lookup(scope, name) {
+  for (let current = scope; current; current = current.parent) {
+    const binding = current.names.get(name);
+    if (binding) return binding;
+  }
+  return void 0;
+}
+function declareParam(inner, fn, index, param) {
+  const name = identifierName(param);
+  if (name !== void 0) {
+    declare(inner, name, { kind: "param", fn, index });
+    return;
+  }
+  if (!isNode(param) || param.type !== "ObjectPattern") {
+    declareOpaque(inner, patternNames(param));
+    return;
+  }
+  for (const property of childNodes(Reflect.get(param, "properties"))) {
+    const key = keyName(property, Reflect.get(property, "key"));
+    const value = Reflect.get(property, "value");
+    const valueName = identifierName(value);
+    if (key !== void 0 && valueName !== void 0 && ["Property", "ObjectProperty"].includes(property.type))
+      declare(inner, valueName, { kind: "param", fn, index, key });
+    else
+      declareOpaque(
+        inner,
+        patternNames(property.type === "RestElement" ? property : value)
+      );
+  }
+}
+function enter(node, scope) {
+  switch (node.type) {
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression": {
+      const inner = newScope(scope, true);
+      const params = Reflect.get(node, "params");
+      if (Array.isArray(params)) {
+        params.forEach((param, index) => declareParam(inner, node, index, param));
+      }
+      const id = Reflect.get(node, "id");
+      if (node.type === "FunctionExpression") declareOpaque(inner, patternNames(id));
+      if (node.type === "FunctionDeclaration") {
+        declareOpaque(scope, patternNames(id));
+        declareOpaque(hoistScope(scope), patternNames(id));
+      }
+      return inner;
+    }
+    case "BlockStatement":
+    case "ForStatement":
+    case "ForInStatement":
+    case "ForOfStatement":
+    case "SwitchStatement":
+    case "StaticBlock":
+      return newScope(scope, false);
+    case "CatchClause": {
+      const inner = newScope(scope, false);
+      declareOpaque(inner, patternNames(Reflect.get(node, "param")));
+      return inner;
+    }
+    case "VariableDeclaration": {
+      const target = Reflect.get(node, "kind") === "var" ? hoistScope(scope) : scope;
+      for (const declarator of childNodes(Reflect.get(node, "declarations"))) {
+        const id = Reflect.get(declarator, "id");
+        const init = Reflect.get(declarator, "init");
+        const name = identifierName(id);
+        if (name !== void 0 && isNode(init))
+          declare(target, name, { kind: "value", init, scope });
+        else declareOpaque(target, patternNames(id));
+      }
+      return scope;
+    }
+    case "ImportDeclaration":
+      for (const specifier of childNodes(Reflect.get(node, "specifiers")))
+        declareOpaque(scope, patternNames(Reflect.get(specifier, "local")));
+      return scope;
+    case "ClassDeclaration":
+      declareOpaque(scope, patternNames(Reflect.get(node, "id")));
+      return scope;
+    default:
+      return scope;
+  }
+}
+function recordWrites(target, scope, collection) {
+  for (const name of patternNames(target)) collection.writes.push({ name, scope });
+}
+function record(node, scope, collection) {
+  switch (node.type) {
+    case "AssignmentExpression": {
+      const left = Reflect.get(node, "left");
+      const right = Reflect.get(node, "right");
+      if (isNode(left) && left.type === "MemberExpression" && keyName(left, Reflect.get(left, "property")) === "__initData" && isNode(right))
+        collection.inits.push({ value: right, scope });
+      recordWrites(left, scope, collection);
       return;
-    const right = Reflect.get(node, "right");
-    if (!isNode(right)) return;
-    if (right.type === "ObjectExpression") objects.add(right);
-    else if (right.type === "Identifier") {
-      const name = propertyName(right);
-      if (name) initNames.add(name);
     }
-  });
-  walk(tree, (node) => {
-    if (node.type !== "VariableDeclarator") return;
-    const name = propertyName(Reflect.get(node, "id"));
-    const init = Reflect.get(node, "init");
-    if (name && initNames.has(name) && isNode(init) && init.type === "ObjectExpression") {
-      objects.add(init);
+    case "UpdateExpression":
+      recordWrites(Reflect.get(node, "argument"), scope, collection);
+      return;
+    case "ForInStatement":
+    case "ForOfStatement":
+      recordWrites(Reflect.get(node, "left"), scope, collection);
+      return;
+    case "CallExpression": {
+      const callee = Reflect.get(node, "callee");
+      if (isNode(callee) && FUNCTION_TYPES.has(callee.type))
+        collection.immediate.set(callee, { call: node, scope });
+      return;
     }
-  });
+    default:
+      return;
+  }
+}
+function visit(node, scope, collection) {
+  record(node, scope, collection);
+  const inner = enter(node, scope);
+  for (const value of Object.values(node)) {
+    if (isNode(value)) visit(value, inner, collection);
+    else for (const child of childNodes(value)) visit(child, inner, collection);
+  }
+}
+function collectInitData(root) {
+  const collection = {
+    inits: [],
+    immediate: /* @__PURE__ */ new Map(),
+    writes: [],
+    reassigned: /* @__PURE__ */ new Set()
+  };
+  visit(root, newScope(void 0, true), collection);
+  for (const { name, scope } of collection.writes) {
+    const binding = lookup(scope, name);
+    if (binding) collection.reassigned.add(binding);
+  }
+  return collection;
+}
+function immediateArgument(fn, index, collection) {
+  const immediate = collection.immediate.get(fn);
+  const args = immediate && Reflect.get(immediate.call, "arguments");
+  if (!immediate || !Array.isArray(args)) return void 0;
+  const preceding = args.slice(0, index + 1);
+  if (preceding.some((arg) => isNode(arg) && arg.type === "SpreadElement"))
+    return void 0;
+  return { argument: args[index], scope: immediate.scope };
+}
+function propertyValue(object, name) {
+  let value;
+  for (const property of childNodes(Reflect.get(object, "properties"))) {
+    if (property.type === "SpreadElement") return void 0;
+    if (!["Property", "ObjectProperty"].includes(property.type)) continue;
+    if (keyName(property, Reflect.get(property, "key")) !== name) continue;
+    const next = Reflect.get(property, "value");
+    value = isNode(next) ? next : void 0;
+  }
+  return value;
+}
+function resolveProperty(owner, name, collection, depth) {
+  if (!owner) return void 0;
+  const value = propertyValue(owner.object, name);
+  return value && resolveObject(value, owner.scope, collection, depth + 1);
+}
+function resolveObject(expression, scope, collection, depth) {
+  if (depth > MAX_RESOLUTION_DEPTH) return void 0;
+  if (expression.type === "ObjectExpression") return { object: expression, scope };
+  if (expression.type === "Identifier") {
+    const name = identifierName(expression);
+    const binding = name === void 0 ? void 0 : lookup(scope, name);
+    if (!binding || collection.reassigned.has(binding)) return void 0;
+    if (binding.kind === "value")
+      return resolveObject(binding.init, binding.scope, collection, depth + 1);
+    if (binding.kind === "param") {
+      const passed = immediateArgument(binding.fn, binding.index, collection);
+      if (!passed || !isNode(passed.argument)) return void 0;
+      const argument = resolveObject(passed.argument, passed.scope, collection, depth + 1);
+      return binding.key === void 0 ? argument : resolveProperty(argument, binding.key, collection, depth);
+    }
+    return void 0;
+  }
+  if (expression.type === "MemberExpression") {
+    const name = keyName(expression, Reflect.get(expression, "property"));
+    const object = Reflect.get(expression, "object");
+    if (name === void 0 || !isNode(object)) return void 0;
+    const owner = resolveObject(object, scope, collection, depth + 1);
+    return resolveProperty(owner, name, collection, depth);
+  }
+  return void 0;
+}
+function workletExecutableBodies(syntax, includeCompiled = false) {
+  if (!isNode(syntax)) throw new Error("peach: expected worklet syntax");
+  const collection = collectInitData(syntax);
+  const objects = /* @__PURE__ */ new Set();
+  for (const { value, scope } of collection.inits) {
+    const resolved = resolveObject(value, scope, collection, 0);
+    if (resolved) objects.add(resolved.object);
+  }
   const bodies = [];
   for (const object of objects) {
     const properties = Reflect.get(object, "properties");
     if (!Array.isArray(properties)) continue;
-    if (properties.some(
+    if (!includeCompiled && properties.some(
       (property2) => isNode(property2) && propertyName(Reflect.get(property2, "key")) === "__peachExecutable"
     ))
       continue;