peachsim 0.1.1620 → 0.1.1635

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1620 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1635 | (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;
@@ -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,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/process-group.ts
+var init_process_group = __esm({
+  "src/process-group.ts"() {
+    "use strict";
+  }
+});
+
 // src/vite-plugin-one.ts
 var vite_plugin_one_exports = {};
 __export(vite_plugin_one_exports, {
@@ -657,6 +667,7 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
 var import_lazy_stub_patterns = require("@peach/compat/lazy-stub-patterns");
+var import_native_package_names = require("@peach/compat/native-package-names");
 var import_stub_manifest = require("@peach/compat/stub-manifest");
 
 // ../peach-engine/src/stub-pattern-matcher.ts
@@ -677,7 +688,7 @@ function extractPackageFromPath(modulePath) {
 }
 
 // src/installed-package-versions.ts
-function readInstalledVersion(projectRoot, name) {
+function readInstalledPackage(projectRoot, name) {
   let dir = projectRoot;
   for (; ; ) {
     let manifest;
@@ -694,8 +705,7 @@ function readInstalledVersion(projectRoot, name) {
       dir = parent;
       continue;
     }
-    const version = typeof manifest === "object" && manifest !== null ? Reflect.get(manifest, "version") : void 0;
-    return typeof version === "string" && version.length > 0 ? version : null;
+    return typeof manifest === "object" && manifest !== null ? { root: import_path.default.join(dir, "node_modules", name), manifest } : null;
   }
 }
 function readInstalledPackageVersions(projectRoot, modulePaths) {
@@ -706,19 +716,59 @@ function readInstalledPackageVersions(projectRoot, modulePaths) {
   }
   const versions = {};
   for (const name of [...names].sort()) {
-    const version = readInstalledVersion(projectRoot, name);
-    if (version) versions[name] = version;
+    const installed = readInstalledPackage(projectRoot, name);
+    const version = installed && Reflect.get(installed.manifest, "version");
+    if (typeof version === "string" && version.length > 0) versions[name] = version;
   }
   return versions;
 }
 function readInstalledNativePackageVersions(projectRoot) {
+  const appRoot = import_fs.default.realpathSync(projectRoot);
+  const nativeNames = /* @__PURE__ */ new Set();
+  for (const specifier of [
+    "react-native",
+    ...import_native_package_names.NATIVE_RUNTIME_PACKAGE_NAMES,
+    ...import_lazy_stub_patterns.LAZY_STUB_PATTERNS,
+    ...Object.values(import_stub_manifest.COMPAT_STUBS).map((entry) => entry.specifier)
+  ]) {
+    const name = extractPackageFromPath(`node_modules/${specifier}`);
+    if (name) nativeNames.add(name);
+  }
+  const manifest = JSON.parse(
+    import_fs.default.readFileSync(import_path.default.join(appRoot, "package.json"), "utf8")
+  );
+  if (typeof manifest !== "object" || manifest === null) {
+    throw new Error("app package.json must contain an object");
+  }
+  const pending = [{ root: appRoot, manifest }];
+  const visited = /* @__PURE__ */ new Set();
+  const needed = /* @__PURE__ */ new Set();
+  for (let next = pending.pop(); next; next = pending.pop()) {
+    const root = import_fs.default.realpathSync(next.root);
+    if (visited.has(root)) continue;
+    visited.add(root);
+    const fields = ["dependencies", "optionalDependencies", "peerDependencies"];
+    if (root === appRoot) fields.push("devDependencies");
+    const peers = Reflect.get(next.manifest, "peerDependenciesMeta");
+    for (const field of fields) {
+      const dependencies = Reflect.get(next.manifest, field);
+      if (typeof dependencies !== "object" || dependencies === null) continue;
+      for (const name of Object.keys(dependencies)) {
+        if (field === "peerDependencies" && typeof peers === "object" && peers !== null) {
+          const peer = Reflect.get(peers, name);
+          if (typeof peer === "object" && peer !== null && Reflect.get(peer, "optional"))
+            continue;
+        }
+        const installed = readInstalledPackage(root, name);
+        if (!installed) continue;
+        if (nativeNames.has(name)) needed.add(name);
+        pending.push(installed);
+      }
+    }
+  }
   return readInstalledPackageVersions(
     projectRoot,
-    [
-      "react-native",
-      ...import_lazy_stub_patterns.LAZY_STUB_PATTERNS,
-      ...Object.values(import_stub_manifest.COMPAT_STUBS).map((entry) => entry.specifier)
-    ].map((specifier) => `node_modules/${specifier}`)
+    [...needed].map((specifier) => `node_modules/${specifier}`)
   );
 }
 
@@ -797,6 +847,8 @@ function readPackageFile(root, file, maxBytes) {
 // src/swift-submit.ts
 var SWIFT_PACKAGE_PATH = "/__peach/swift-package/";
 var SWIFT_HMR_PATH = "/__peach/swift-hmr";
+var DEFAULT_SWIFT_COMPILE_BUILD_MS = 10 * 6e4;
+var MAX_SWIFT_COMPILE_BUILD_MS = 60 * 6e4;
 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;
@@ -971,13 +1023,14 @@ function findBundleFooter(source, prefix) {
     if (newline < 0) return -1;
     const line = newline + 1;
     if (source.startsWith(prefix, line)) return newline;
-    if (line !== end && !source.startsWith("globalThis.", line) && !source.startsWith("//", line)) {
-      return -1;
-    }
+    if (!isFooterBlockLine(source, line, end)) return -1;
     end = newline;
   }
   return -1;
 }
+function isFooterBlockLine(source, line, end) {
+  return line === end || source.startsWith("globalThis.", line) || source.startsWith("//", line);
+}
 function readFooter(source, prefix, suffix, name) {
   const start = findBundleFooter(source, prefix);
   if (start < 0) return null;
@@ -1034,6 +1087,9 @@ var import_fs2 = __toESM(require("fs"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_url = require("url");
 
+// ../contrast-runtime-delivery/src/index.ts
+init_process_group();
+
 // ../contrast-runtime-delivery/src/version.ts
 function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);

package/dist-lib/worklet-executable.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1620 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1635 | (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;
@@ -119,6 +119,17 @@ function declareParam(inner, fn, index, param) {
     declare(inner, name, { kind: "param", fn, index });
     return;
   }
+  if (isNode(param) && param.type === "ArrayPattern") {
+    const elements = Reflect.get(param, "elements");
+    if (!Array.isArray(elements)) return;
+    elements.forEach((element, position) => {
+      const name2 = identifierName(element);
+      if (name2 !== void 0)
+        declare(inner, name2, { kind: "param", fn, index, key: String(position) });
+      else declareOpaque(inner, patternNames(element));
+    });
+    return;
+  }
   if (!isNode(param) || param.type !== "ObjectPattern") {
     declareOpaque(inner, patternNames(param));
     return;
@@ -267,6 +278,17 @@ function immediateArgument(fn, index, collection) {
   return { argument: args[index], scope: immediate.scope };
 }
 function propertyValue(object, name) {
+  if (object.type === "ArrayExpression") {
+    const index = Number(name);
+    const elements = Reflect.get(object, "elements");
+    if (!Number.isSafeInteger(index) || index < 0 || String(index) !== name)
+      return void 0;
+    if (!Array.isArray(elements)) return void 0;
+    if (elements.slice(0, index + 1).some((element) => isNode(element) && element.type === "SpreadElement"))
+      return void 0;
+    const value2 = elements[index];
+    return isNode(value2) ? value2 : void 0;
+  }
   let value;
   for (const property of childNodes(Reflect.get(object, "properties"))) {
     if (property.type === "SpreadElement") return void 0;
@@ -284,7 +306,8 @@ function resolveProperty(owner, name, collection, depth) {
 }
 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 === "ObjectExpression" || expression.type === "ArrayExpression")
+    return { object: expression, scope };
   if (expression.type === "SequenceExpression") {
     const last = childNodes(Reflect.get(expression, "expressions")).at(-1);
     return last && resolveObject(last, scope, collection, depth + 1);

package/dist-lib/worklet-executable.mjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1620 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1635 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 
 // src/worklet-executable.ts
 import { parse } from "acorn";
@@ -94,6 +94,17 @@ function declareParam(inner, fn, index, param) {
     declare(inner, name, { kind: "param", fn, index });
     return;
   }
+  if (isNode(param) && param.type === "ArrayPattern") {
+    const elements = Reflect.get(param, "elements");
+    if (!Array.isArray(elements)) return;
+    elements.forEach((element, position) => {
+      const name2 = identifierName(element);
+      if (name2 !== void 0)
+        declare(inner, name2, { kind: "param", fn, index, key: String(position) });
+      else declareOpaque(inner, patternNames(element));
+    });
+    return;
+  }
   if (!isNode(param) || param.type !== "ObjectPattern") {
     declareOpaque(inner, patternNames(param));
     return;
@@ -242,6 +253,17 @@ function immediateArgument(fn, index, collection) {
   return { argument: args[index], scope: immediate.scope };
 }
 function propertyValue(object, name) {
+  if (object.type === "ArrayExpression") {
+    const index = Number(name);
+    const elements = Reflect.get(object, "elements");
+    if (!Number.isSafeInteger(index) || index < 0 || String(index) !== name)
+      return void 0;
+    if (!Array.isArray(elements)) return void 0;
+    if (elements.slice(0, index + 1).some((element) => isNode(element) && element.type === "SpreadElement"))
+      return void 0;
+    const value2 = elements[index];
+    return isNode(value2) ? value2 : void 0;
+  }
   let value;
   for (const property of childNodes(Reflect.get(object, "properties"))) {
     if (property.type === "SpreadElement") return void 0;
@@ -259,7 +281,8 @@ function resolveProperty(owner, name, collection, depth) {
 }
 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 === "ObjectExpression" || expression.type === "ArrayExpression")
+    return { object: expression, scope };
   if (expression.type === "SequenceExpression") {
     const last = childNodes(Reflect.get(expression, "expressions")).at(-1);
     return last && resolveObject(last, scope, collection, depth + 1);

package/kotlin/AppSources/dev/peach/app/PeachDrawable.kt

@@ -4,18 +4,21 @@ import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.ImageBitmap
 import androidx.compose.ui.graphics.SolidColor
-import androidx.compose.ui.graphics.toComposeImageBitmap
+import androidx.compose.ui.graphics.asComposeImageBitmap
 import androidx.compose.ui.graphics.vector.ImageVector
 import kotlin.io.encoding.Base64
 import kotlin.io.encoding.ExperimentalEncodingApi
+import org.jetbrains.skia.Bitmap as SkiaBitmap
 import org.jetbrains.skia.BlendMode
+import org.jetbrains.skia.Canvas
+import org.jetbrains.skia.Codec
+import org.jetbrains.skia.Data
 import org.jetbrains.skia.FilterMipmap
 import org.jetbrains.skia.FilterMode
 import org.jetbrains.skia.Image
 import org.jetbrains.skia.MipmapMode
 import org.jetbrains.skia.Paint
 import org.jetbrains.skia.Rect
-import org.jetbrains.skia.Surface
 
 // one file a drawable resource resolves to under a density (ResTable_config's
 // value, 0 for an unqualified directory) and a platform version: a vector the
@@ -67,28 +70,32 @@ private fun isBetter(a: PeachDrawable, b: PeachDrawable, requested: Int): Boolea
 // bitmap drawn for a higher density than the display's is scaled down, its
 // size rounded, through a linear filtered draw with the source blend; one
 // drawn for a lower density, or nodpi, keeps its pixels, as from API 28 the
-// upscale is left to draw time, which BitmapPainter does not do
+// upscale is left to draw time, which BitmapPainter does not do. as
+// ImageDecoder does, the codec decodes into a bitmap and the scale draws into
+// another
 @OptIn(ExperimentalEncodingApi::class)
 internal fun peachDecodeBitmap(drawable: PeachDrawable.Bitmap, targetDensity: Int): ImageBitmap {
     if (drawable.ninePatch)
         throw UnsupportedOperationException("peach kotlin: the nine-patch drawable ${drawable.path} is not drawn yet")
-    val image = Image.makeFromEncoded(Base64.decode(drawable.data))
+    val decoded = Codec.makeFromData(Data.makeFromBytes(Base64.decode(drawable.data))).readPixels()
     val density = if (drawable.density == DENSITY_DEFAULT) DENSITY_MEDIUM else drawable.density
-    if (drawable.density == DENSITY_NONE || density <= targetDensity) return image.toComposeImageBitmap()
+    if (drawable.density == DENSITY_NONE || density <= targetDensity) return decoded.asComposeImageBitmap()
     val scale = targetDensity.toFloat() / density
-    val width = maxOf((image.width * scale + 0.5f).toInt(), 1)
-    val height = maxOf((image.height * scale + 0.5f).toInt(), 1)
-    val surface = Surface.makeRasterN32Premul(width, height)
-    surface.canvas.scale(width.toFloat() / image.width, height.toFloat() / image.height)
-    surface.canvas.drawImageRect(
-        image,
-        Rect.makeWH(image.width.toFloat(), image.height.toFloat()),
-        Rect.makeWH(image.width.toFloat(), image.height.toFloat()),
+    val width = maxOf((decoded.width * scale + 0.5f).toInt(), 1)
+    val height = maxOf((decoded.height * scale + 0.5f).toInt(), 1)
+    val scaled = SkiaBitmap().apply { allocN32Pixels(width, height) }
+    val canvas = Canvas(scaled)
+    canvas.scale(width.toFloat() / decoded.width, height.toFloat() / decoded.height)
+    canvas.drawImageRect(
+        Image.makeFromBitmap(decoded),
+        Rect.makeWH(decoded.width.toFloat(), decoded.height.toFloat()),
+        Rect.makeWH(decoded.width.toFloat(), decoded.height.toFloat()),
         FilterMipmap(FilterMode.LINEAR, MipmapMode.NONE),
         Paint().apply { blendMode = BlendMode.SRC },
         false,
     )
-    return surface.makeImageSnapshot().toComposeImageBitmap()
+    canvas.close()
+    return scaled.asComposeImageBitmap()
 }
 
 // ComplexColorCompat.willDraw: a transparent solid color draws nothing

package/kotlin/Sources/androidx/annotation/DrawableRes.kt

@@ -0,0 +1,14 @@
+package androidx.annotation
+
+// androidx.annotation's DrawableRes, which only its android artifact declares
+@MustBeDocumented
+@Retention(AnnotationRetention.BINARY)
+@Target(
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.PROPERTY_GETTER,
+    AnnotationTarget.PROPERTY_SETTER,
+    AnnotationTarget.VALUE_PARAMETER,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.LOCAL_VARIABLE,
+)
+annotation class DrawableRes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.1620",
+  "version": "0.1.1635",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -371,7 +371,7 @@
     "rollup": "4.62.2",
     "systemjs": "6.15.1",
     "tsconfck": "3.1.6",
-    "typescript": "7.1.0-dev.20261003.1",
+    "typescript": "7.1.0-beta",
     "vite": "8.3.3",
     "yaml": "^2.8.3"
   }

package/scripts/dev-server-scanner.ts

@@ -24,6 +24,8 @@ import {
   normalizeHostname,
 } from '../src/backend-origin.ts'
 import { applyPeachConfigToUrl } from '../src/config.ts'
+import { fetchDevManifest } from '../src/dev-bundle-resolution'
+import { parseExpoManifestBody } from '../src/expo-manifest-body'
 import {
   KOTLIN_DISCOVERY_PATH,
   KOTLIN_GUEST_PATH,
@@ -448,6 +450,36 @@ function httpGet(
   })
 }
 
+async function probeManifest(
+  hostname: string,
+  port: number,
+  timeout: number,
+): Promise<HttpResult | null> {
+  let deadline: ReturnType<typeof setTimeout> | undefined
+  try {
+    return await Promise.race([
+      fetchDevManifest(buildLoopbackProbeBaseUrl('http:', hostname, port)).then(
+        async (res) =>
+          res
+            ? {
+                statusCode: res.status,
+                body: await res.text(),
+                contentType: res.headers.get('content-type') || '',
+                hostname,
+              }
+            : null,
+      ),
+      new Promise<null>((resolve) => {
+        deadline = setTimeout(() => resolve(null), timeout)
+      }),
+    ])
+  } catch {
+    return null
+  } finally {
+    clearTimeout(deadline)
+  }
+}
+
 // ── discovery ───────────────────────────────────────────────────────────────
 
 export interface ListeningProcess {
@@ -938,7 +970,7 @@ function applyManifest(
 ): DiscoveredServer {
   if (!manifestRes) return result
   try {
-    const manifest = JSON.parse(manifestRes.body)
+    const manifest = parseExpoManifestBody(manifestRes.body)
     const client = manifest?.extra?.expoClient || manifest?.extra || {}
     if (client.name) result.projectName = client.name
     if (typeof client.primaryColor === 'string') result.primaryColor = client.primaryColor
@@ -1089,16 +1121,7 @@ async function fetchManifestEnrichment(
   buildIconProxyUrl?: (externalUrl: string) => string,
 ): Promise<void> {
   const hostname = normalizeHostname(new URL(result.bundleUrl).hostname)
-  const manifestRes = await httpGet(
-    hostname,
-    result.port,
-    '/',
-    'GET',
-    ENRICH_TIMEOUT_MS,
-    {
-      'expo-platform': 'ios',
-    },
-  )
+  const manifestRes = await probeManifest(hostname, result.port, ENRICH_TIMEOUT_MS)
   if (!manifestRes || manifestRes.statusCode !== 200) return
   // reuse applyManifest's exact field extraction against a throwaway result.
   const parsed = applyManifest(
@@ -1205,9 +1228,7 @@ export async function probePort(
       httpGet(probeHostname, port, '/status'),
       skipManifest
         ? Promise.resolve(null)
-        : httpGet(probeHostname, port, '/', 'GET', MANIFEST_TIMEOUT_MS, {
-            'expo-platform': 'ios',
-          }),
+        : probeManifest(probeHostname, port, MANIFEST_TIMEOUT_MS),
       skipExpo ? Promise.resolve(null) : httpGet(probeHostname, port, '/_expo/status'),
       httpGet(probeHostname, port, SWIFT_DISCOVERY_PATH),
       httpGet(probeHostname, port, KOTLIN_DISCOVERY_PATH),

package/skills/peach-perf/SKILL.md

@@ -310,9 +310,14 @@ attributes a missing frame to its hop:
 - `delivery lag` — vsync postMessage receipt latency above the run's
   best case; jitter here means the shell worker was descheduled or its
   queue was busy.
-- `paint interval` — the end-to-end cadence the user perceives.
-- `idle breaks` — gaps >250ms, excluded from all three: demand-gated
-  quiesce is legitimate, not starvation.
+- `present interval` — intervals between admitted compositor presentations,
+  including native frames, while progress remains pending after the preceding
+  presentation (`motionPending` in `compositorCadence.frameSeries`). Settled
+  admitted frames end a sequence; deferred frames retain the pending gap.
+  `paintIntervals` reports the sample count, so zero samples do not prove
+  smoothness. Shell work and JavaScript flushes can park while native frames
+  continue presenting.
+- `idle breaks` — host gaps >250ms, excluded from host interval statistics.
 
 the compositor `compositorHostFrameClock` keeps its historical name and reports
 display/timer ticks consumed by the compositor worker's resilient clock during
@@ -320,8 +325,9 @@ the acknowledged profile window. `published` is null because renderer-main no
 longer publishes compositor frames. sparse consumed ticks with low production
 time identifies worker scheduling starvation. many consumed ticks with sparse
 paints can be legitimate dirty-gating; correlate the frame series before
-treating it as a regression. shell cadence comes from its worker frame and paint
-series.
+treating it as a regression. Host and shell delivery statistics come from the
+shell worker; `cadence.paintInterval*` comes from compositor presentation times
+during motion.
 
 compare baseline vs contended captures of the same scripted window; also
 compare **painted-frame counts**, the crudest and most robust signal.

package/skills/peach-setup/SKILL.md

@@ -42,7 +42,8 @@ debugging or `/peach-test` for writing tests.
   daemon is down, the dev server port is wrong, or the runtime is missing.
   walk the recovery checklist before reinstalling.
 - **keep one sim for your whole session.** the first `peach open <port>`
-  launches Chrome for Testing with an isolated profile. later opens reuse the
+  launches the simulator window: the native desktop app on Apple silicon macOS
+  and Linux x64, otherwise Chrome for Testing with an isolated profile. later opens reuse the
   saved sim and navigate it in place. use `peach do reload` when the target
   has not changed:
 
@@ -74,27 +75,23 @@ debugging or `/peach-test` for writing tests.
   saved sim to reuse. verify the development server and Peach runtime, then
   retry once after fixing the cause.
 
-## choose the runtime
+## the simulator window
 
-on Apple silicon macOS and Linux x64, recommend trying the optional native
-runtime for faster simulation. it is beta, so the user may run into more issues
-than in the browser. keep the current default unless the user chooses native:
+on Apple silicon macOS and Linux x64, `peach open` shows the app in the native
+desktop app, which is faster than the browser. setup installs it, and on a Mac
+the first `peach open` installs it if it is missing. do not pass a driver flag
+for the user's own viewing.
 
-```sh
-peach desktop install
-peach open 8081 --driver desktop
-```
-
-use the app's actual development server port. the Linux desktop app needs a
-desktop session; its `.deb` installer uses `sudo apt-get install`.
-`peach desktop install --native` on Linux installs the standalone headless host
-instead of the desktop app. Intel Mac and Linux arm64 use the browser.
-`peach open 8081 --driver playwright --headed` explicitly opens a browser window.
-pass the selected driver when opening the app in the steps below; installing
-the desktop app alone does not change the saved window preference.
+the Linux desktop app needs a desktop session; its `.deb` installer uses
+`sudo apt-get install`. `peach desktop install --native` on Linux installs the
+standalone headless host instead of the desktop app. Intel Mac and Linux arm64
+use the browser. `peach open 8081 --driver playwright --headed` explicitly opens
+a browser window. a yellow "GPU disabled" item in the browser simulator's menu
+bar means it is drawing without a GPU and will be slow; move the user to the
+desktop app.
 
-the native runtime renders the simulator. the background service below keeps
-the bridge ready for either runtime and is a separate optional choice.
+the background service below keeps the bridge ready for either window and is a
+separate optional choice.
 
 ## first move
 

package/src/admitted-mac-build.ts

@@ -1,12 +1,38 @@
-// true only inside a mac builder slot that already passed resource admission.
-// any other CONTRAST_REMOTE_BUILD value, including "linux" and "0", is an
-// inherited marker and is not a reason to compile on this host.
+import { spawnSync } from 'node:child_process'
+
+export type WindowAdmission =
+  | { kind: 'heavy' | 'quiet'; cores: number | null; scopes: string[] }
+  | { kind: 'external'; name: string; cores: null }
+// do not cache authority: release returns capacity while this process stays live.
+export function windowAdmission(): WindowAdmission | null {
+  const result = spawnSync('tm', ['window', 'ancestor', '--json'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'inherit'],
+  })
+  if (result.error) throw result.error
+  if (result.status === 1) return null
+  if (result.status !== 0) throw new Error(`tm window ancestor exited ${result.status}`)
+  const entry = JSON.parse(result.stdout) as {
+    kind: string
+    name?: string
+    cores?: number
+    scopes?: string[]
+  }
+  if (entry.kind === 'external')
+    return { kind: 'external', name: entry.name ?? '', cores: null }
+  if (entry.kind !== 'heavy' && entry.kind !== 'quiet')
+    throw new Error(`tm window ancestor returned kind ${entry.kind}`)
+  return {
+    kind: entry.kind,
+    cores: entry.cores && entry.cores > 0 ? entry.cores : null,
+    scopes: entry.scopes ?? [],
+  }
+}
+
+// a held destination slot and verified native grant authorize local compilation.
 export function admittedMacBuilderSlot(
   env: { readonly [key: string]: string | undefined } = process.env,
 ): boolean {
-  return (
-    env.CONTRAST_REMOTE_BUILD === 'mac' &&
-    env.REMOTE_MAC_SLOT_HELD === '1' &&
-    env.CONTRAST_HEAVY_ADMITTED === '1'
-  )
+  if (process.platform !== 'darwin' || env.REMOTE_MAC_SLOT_HELD !== '1') return false
+  return windowAdmission() !== null
 }