peachsim 0.1.1620 → 0.1.1635

package/src/android-app-identity.ts

@@ -0,0 +1,146 @@
+// read only an app's completed manifest merger output. raw source manifests
+// cannot name the selected variant, linked AARs, or the effects of merge rules.
+import { compileAndroidStringValue } from './android-string-value'
+import { parseXml } from './android-xml'
+import type { AndroidManifestPermission, NativeAppIdentity } from './native-app-identity'
+
+export function nativeAppIdentityFromAndroidManifest(
+  source: string,
+  file: string,
+  files: Readonly<Record<string, string>> = {},
+): NativeAppIdentity | null {
+  const document = parseXml(source, file)
+  if (document.children.length !== 1) return null
+  const manifest = document.children[0]!
+  if (manifest.name !== 'manifest') return null
+  const androidPrefix = Object.entries(manifest.attributes)
+    .find(
+      ([name, value]) =>
+        name.startsWith('xmlns:') &&
+        value === 'http://schemas.android.com/apk/res/android',
+    )?.[0]
+    .slice('xmlns:'.length)
+  if (!androidPrefix) return null
+  const attribute = `${androidPrefix}:`
+  const bundleIdentifier = manifest.attributes.package
+  const appVersion = manifest.attributes[`${attribute}versionName`]
+  const buildVersion = manifest.attributes[`${attribute}versionCode`]
+  const application = manifest.children.find((child) => child.name === 'application')
+  if (
+    !application ||
+    !bundleIdentifier ||
+    !appVersion ||
+    !buildVersion ||
+    !/^[1-9][0-9]*$/.test(buildVersion) ||
+    [bundleIdentifier, appVersion].some((value) => /\$\{|^[@?]/.test(value))
+  )
+    return null
+
+  // an unconsumed merger marker or placeholder is not a completed app output.
+  const toolsPrefixes = Object.entries(manifest.attributes)
+    .filter(
+      ([name, value]) =>
+        name.startsWith('xmlns:') && value === 'http://schemas.android.com/tools',
+    )
+    .map(([name]) => `${name.slice('xmlns:'.length)}:`)
+  const androidManifestPermissions: AndroidManifestPermission[] = []
+  for (const element of manifest.children) {
+    if (
+      !['uses-permission', 'uses-permission-sdk-23', 'uses-permission-sdk-m'].includes(
+        element.name,
+      )
+    )
+      continue
+    if (
+      Object.keys(element.attributes).some((key) =>
+        toolsPrefixes.some((prefix) => key.startsWith(prefix)),
+      )
+    )
+      return null
+    const name = element.attributes[`${attribute}name`]
+    const max = element.attributes[`${attribute}maxSdkVersion`]
+    // feature-dependent declarations need the installed device's feature set.
+    // resource references and unresolved placeholders cannot certify a permission.
+    if (
+      !name ||
+      /\$\{|^[@?]/.test(name) ||
+      element.attributes[`${attribute}requiredFeature`] !== undefined ||
+      element.attributes[`${attribute}requiredNotFeature`] !== undefined ||
+      (max !== undefined && !/^\d+$/.test(max))
+    )
+      return null
+    androidManifestPermissions.push({
+      name,
+      minSdkVersion: element.name === 'uses-permission' ? 1 : 23,
+      ...(max === undefined ? {} : { maxSdkVersion: Number(max) }),
+    })
+  }
+  let label = application.attributes[`${attribute}label`]
+  let applicationName: string | null = null
+  if (label && !/\$\{|^[@?]/.test(label)) applicationName = label
+  else if (label?.startsWith('@string/')) {
+    const resourceDirectory = androidMergedResourceValuesDirectory(file)
+    const resourceFile = resourceDirectory
+      ? `${resourceDirectory}/values/values.xml`
+      : null
+    const resources = resourceFile ? files[resourceFile] : undefined
+    if (resources !== undefined && resourceFile) {
+      const document = parseXml(resources, resourceFile)
+      const root = document.children[0]
+      if (document.children.length === 1 && root?.name === 'resources') {
+        const qualified = Object.entries(files)
+          .filter(
+            ([name]) =>
+              name.startsWith(`${resourceDirectory}/values-`) && name.endsWith('.xml'),
+          )
+          .flatMap(([name, source]) => parseXml(source, name).children)
+          .flatMap((root) => root.children)
+        const visited = new Set<string>()
+        while (label?.startsWith('@string/') && !visited.has(label)) {
+          visited.add(label)
+          const name = label.slice('@string/'.length)
+          // no device resource configuration travels with this build metadata.
+          // a qualified override makes a default label insufficient evidence.
+          if (qualified.some((element) => element.attributes.name === name)) break
+          const matches = root.children.filter(
+            (element) =>
+              (element.name === 'string' ||
+                (element.name === 'item' && element.attributes.type === 'string')) &&
+              element.attributes.name === name,
+          )
+          const value = matches.length === 1 ? matches[0] : undefined
+          // styled or unresolved values cannot certify a plain application label.
+          if (!value || value.children.length) break
+          label = value.text.trim()
+          if (/^[@?]/.test(label)) continue
+          applicationName = compileAndroidStringValue(value.text, resourceFile) || null
+          break
+        }
+      }
+    }
+  }
+  return {
+    applicationName,
+    appVersion,
+    buildVersion,
+    bundleIdentifier,
+    platform: 'android',
+    androidManifestPermissions,
+  }
+}
+
+// AGP's resource merger writes the selected variant's uncompiled values here.
+// raw src/main resources cannot certify flavor, build type or library overrides.
+export function androidMergedResourceValuesDirectory(
+  manifestFile: string,
+): string | null {
+  const match =
+    /^(.*\/build\/intermediates\/)merged_manifests\/([^/]+)\/[^/]+\/AndroidManifest\.xml$/.exec(
+      manifestFile,
+    )
+  if (!match) return null
+  const [, intermediates, variant] = match
+  if (!variant) return null
+  const taskVariant = variant[0]!.toUpperCase() + variant.slice(1)
+  return `${intermediates}incremental/${variant}/merge${taskVariant}Resources/merged.dir`
+}

package/src/android-autolinking.ts

@@ -0,0 +1,75 @@
+// use the app's Expo resolver so transitive dependencies, exclusions and
+// plugin-only Android packages follow the same autolinking as Gradle.
+import { execFile } from 'node:child_process'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import { RNX_FORKED_SCRIPT_ENV } from '../cli/internal-child'
+import { readAndroidAutolinkedPackages } from './androidAutolinkingContract'
+import { isRecord } from './is-record'
+
+const run = promisify(execFile)
+
+const resolving = new Map<string, Promise<readonly Record<string, unknown>[]>>()
+
+// only an overlapping resolution pass is shared. later builds must observe
+// changed dependencies, module configuration and autolinking exclusions.
+export async function resolveExpoAndroidAutolinking(
+  appRoot: string,
+): Promise<readonly Record<string, unknown>[]> {
+  const root = fs.realpathSync(appRoot)
+  const existing = resolving.get(root)
+  if (existing) return existing
+  const pending = resolveAndroidModules(root)
+  resolving.set(root, pending)
+  try {
+    return await pending
+  } finally {
+    if (resolving.get(root) === pending) resolving.delete(root)
+  }
+}
+
+async function resolveAndroidModules(
+  appRoot: string,
+): Promise<readonly Record<string, unknown>[]> {
+  let autolinker: string
+  try {
+    autolinker = createRequire(path.join(appRoot, 'package.json')).resolve(
+      'expo-modules-autolinking/package.json',
+    )
+  } catch (error) {
+    if (isRecord(error) && error.code === 'MODULE_NOT_FOUND') return []
+    throw error
+  }
+  const { stdout } = await run(
+    process.execPath,
+    [
+      path.join(path.dirname(autolinker), 'bin/expo-modules-autolinking.js'),
+      'resolve',
+      '--platform',
+      'android',
+      '--project-root',
+      appRoot,
+      '--json',
+    ],
+    {
+      timeout: 30_000,
+      maxBuffer: 8 * 1024 * 1024,
+      env: { ...process.env, [RNX_FORKED_SCRIPT_ENV]: '1' },
+    },
+  )
+  const resolved: unknown = JSON.parse(stdout)
+  if (!isRecord(resolved) || !Array.isArray(resolved.modules))
+    throw new Error('invalid Expo Android autolinking result')
+  if (!resolved.modules.every(isRecord))
+    throw new Error('invalid Expo Android autolinking entry')
+  return resolved.modules
+}
+
+export async function collectAndroidAutolinkedPackages(
+  appRoot: string,
+): Promise<string[]> {
+  const modules = await resolveExpoAndroidAutolinking(appRoot)
+  return readAndroidAutolinkedPackages(modules.map((entry) => entry.packageName))
+}

package/src/android-string-value.ts

@@ -0,0 +1,36 @@
+// aapt2's StringBuilder over the decoded text: outside double quotes a run of
+// whitespace is one space and the ends are trimmed, an unescaped apostrophe is
+// an error; a double quote toggles quoting and is dropped; a backslash escapes
+// the next character (\n, \t and \uXXXX, any other character as itself). a
+// value beginning with @ or ? must be resolved before compiling its text
+export function compileAndroidStringValue(text: string, where: string): string {
+  if (/^\s*[@?]/.test(text))
+    throw new Error(`${where} is a resource reference, not resolved by peach kotlin yet`)
+  const out: { char: string; soft: boolean }[] = []
+  let quoted = false
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index] ?? ''
+    if (char === '\\') {
+      const next = text[index + 1]
+      if (next === undefined) break
+      index++
+      if (next === 'n') out.push({ char: '\n', soft: false })
+      else if (next === 't') out.push({ char: '\t', soft: false })
+      else if (next === 'u') {
+        const hex = text.slice(index + 1, index + 5)
+        if (!/^[0-9a-fA-F]{4}$/.test(hex))
+          throw new Error(`${where} has an invalid unicode escape \\u${hex}`)
+        out.push({ char: String.fromCharCode(Number.parseInt(hex, 16)), soft: false })
+        index += 4
+      } else out.push({ char: next, soft: false })
+    } else if (char === '"') quoted = !quoted
+    else if (char === "'" && !quoted)
+      throw new Error(`${where} has an unescaped apostrophe`)
+    else if (!quoted && /\s/.test(char)) {
+      if (out.at(-1)?.soft !== true) out.push({ char: ' ', soft: true })
+    } else out.push({ char, soft: false })
+  }
+  while (out[0]?.soft) out.shift()
+  while (out.at(-1)?.soft) out.pop()
+  return out.map((part) => part.char).join('')
+}

package/src/android-strings.ts

@@ -6,6 +6,7 @@
 // rejected by name, never read as the default or as text.
 import fs from 'node:fs'
 import path from 'node:path'
+import { compileAndroidStringValue } from './android-string-value'
 import { decodeXmlText } from './android-xml'
 
 // one resource's value per locale: '' for values, then a language or a
@@ -123,41 +124,9 @@ const sorted = <Value>(
     .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
     .map(([name, values]) => ({ name, values }))
 
-// aapt2's StringBuilder over the decoded text: outside double quotes a run of
-// whitespace is one space and the ends are trimmed, an unescaped apostrophe is
-// an error; a double quote toggles quoting and is dropped; a backslash escapes
-// the next character (\n, \t and \uXXXX, any other character as itself). a
-// value beginning with @ or ? is a reference aapt2 resolves, which Peach does
-// not yet
 function compileString(raw: string, where: string): string {
-  const text = decodeXmlText(raw.replace(/<[^>]*>/g, ''), where)
-  if (/^\s*[@?]/.test(text))
-    throw new Error(`${where} is a resource reference, not resolved by peach kotlin yet`)
-  const out: { char: string; soft: boolean }[] = []
-  let quoted = false
-  for (let index = 0; index < text.length; index++) {
-    const char = text[index] ?? ''
-    if (char === '\\') {
-      const next = text[index + 1]
-      if (next === undefined) break
-      index++
-      if (next === 'n') out.push({ char: '\n', soft: false })
-      else if (next === 't') out.push({ char: '\t', soft: false })
-      else if (next === 'u') {
-        const hex = text.slice(index + 1, index + 5)
-        if (!/^[0-9a-fA-F]{4}$/.test(hex))
-          throw new Error(`${where} has an invalid unicode escape \\u${hex}`)
-        out.push({ char: String.fromCharCode(Number.parseInt(hex, 16)), soft: false })
-        index += 4
-      } else out.push({ char: next, soft: false })
-    } else if (char === '"') quoted = !quoted
-    else if (char === "'" && !quoted)
-      throw new Error(`${where} has an unescaped apostrophe`)
-    else if (!quoted && /\s/.test(char)) {
-      if (out.at(-1)?.soft !== true) out.push({ char: ' ', soft: true })
-    } else out.push({ char, soft: false })
-  }
-  while (out[0]?.soft) out.shift()
-  while (out.at(-1)?.soft) out.pop()
-  return out.map((part) => part.char).join('')
+  return compileAndroidStringValue(
+    decodeXmlText(raw.replace(/<[^>]*>/g, ''), where),
+    where,
+  )
 }

package/src/androidAutolinkingContract.ts

@@ -0,0 +1,40 @@
+import {
+  detachBundleGlobalFooter,
+  insertBundleGlobalFooter,
+  readBundleGlobalFooter,
+} from './bundleGlobalFooter'
+
+const FOOTER = '__peachAndroidAutolinkedPackages'
+
+export function readAndroidAutolinkedPackages(value: unknown): string[] {
+  if (
+    !Array.isArray(value) ||
+    !value.every((name) => typeof name === 'string' && name.length > 0)
+  )
+    throw new Error('invalid Android autolinked packages')
+  return [...new Set(value)].sort((left, right) => left.localeCompare(right))
+}
+
+export function readAndroidAutolinkingFooter(source: string): string[] | null {
+  const value = readBundleGlobalFooter(source, FOOTER)
+  return value === null ? null : readAndroidAutolinkedPackages(value)
+}
+
+export function insertAndroidAutolinkingFooter(
+  source: string,
+  packages: readonly string[],
+): string {
+  return insertBundleGlobalFooter(source, FOOTER, readAndroidAutolinkedPackages(packages))
+}
+
+export function detachAndroidAutolinkingFooter(source: string): {
+  source: string
+  packages: string[] | null
+} {
+  const detached = detachBundleGlobalFooter(source, FOOTER)
+  return {
+    source: detached.source,
+    packages:
+      detached.value === null ? null : readAndroidAutolinkedPackages(detached.value),
+  }
+}

package/src/bridge-constants.ts

@@ -6,6 +6,17 @@ import { PEACH_SIMULATOR_PATH } from './simulator-route'
 export const DEFAULT_SOOTSIM_BRIDGE_PORT = 7668
 export const DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`
 
+export function assertPeachPortEnvironment(env: Record<string, unknown>): void {
+  for (const [removed, replacement] of [
+    ['SOOTSIM_SHELL_PORT', 'PEACH_SHELL_PORT'],
+    ['SOOTSIM_BRIDGE_PORT', 'PEACH_BRIDGE_PORT'],
+  ] satisfies [string, string][]) {
+    if (env[removed] !== undefined) {
+      throw new Error(`${removed} has been removed; unset it and use ${replacement}`)
+    }
+  }
+}
+
 function parsePort(value: unknown): number | null {
   if (typeof value === 'number') {
     return Number.isInteger(value) && value > 0 ? value : null

package/src/bridge-contract.ts

@@ -385,39 +385,29 @@ export const SEMANTIC_READY_POLL_MS = 150
 
 export const HEADLESS_TENANT_FETCH_HUNG_MARKER = 'headless tenant fetch hung'
 
-export function readyProbeHasContent(
-  probe: Pick<SemanticReadyProbe, 'nodes' | 'targets'> &
-    Partial<
-      Pick<
-        SemanticReadyProbe,
-        'liveFrameActive' | 'browserSurfaceCount' | 'paintedAppContent'
-      >
-    >,
-): boolean {
-  return (
-    probe.paintedAppContent === true ||
-    (probe.browserSurfaceCount ?? 0) > 0 ||
-    probe.liveFrameActive ||
-    probe.targets > 0 ||
-    probe.nodes >= SEMANTIC_READY_CONTENT_NODE_FLOOR
-  )
+type ReadyContentProbe = Pick<SemanticReadyProbe, 'nodes' | 'targets'> &
+  Partial<
+    Pick<
+      SemanticReadyProbe,
+      'liveFrameActive' | 'browserSurfaceCount' | 'paintedAppContent' | 'flag'
+    >
+  >
+
+// the first content condition a probe satisfies. a probe without the ready
+// flag counts only targeted content, never the node floor. empty when the
+// probe has none.
+export function readyProbeContentBasis(probe: ReadyContentProbe): string {
+  if (probe.paintedAppContent === true) return 'paintedAppContent'
+  if ((probe.browserSurfaceCount ?? 0) > 0) return 'browserSurface'
+  if (probe.liveFrameActive) return 'liveFrame'
+  if (probe.targets > 0) return 'targets'
+  if (probe.flag === true && probe.nodes >= SEMANTIC_READY_CONTENT_NODE_FLOOR)
+    return 'nodeFloor'
+  return ''
 }
 
-export function readyProbeHasTargetContent(
-  probe: Pick<SemanticReadyProbe, 'targets'> &
-    Partial<
-      Pick<
-        SemanticReadyProbe,
-        'liveFrameActive' | 'browserSurfaceCount' | 'paintedAppContent'
-      >
-    >,
-): boolean {
-  return (
-    probe.paintedAppContent === true ||
-    (probe.browserSurfaceCount ?? 0) > 0 ||
-    probe.liveFrameActive ||
-    probe.targets > 0
-  )
+export function readyProbeHasContent(probe: ReadyContentProbe): boolean {
+  return readyProbeContentBasis({ ...probe, flag: true }) !== ''
 }
 
 // one probe shows a ready app: it has said so with content behind it, or it
@@ -426,9 +416,7 @@ export function readyProbeHasTargetContent(
 // already let the app settle judges a single probe with this alone.
 export function readyProbeIsReady(probe: SemanticReadyProbe): boolean {
   return (
-    (probe.flag === true
-      ? readyProbeHasContent(probe)
-      : readyProbeHasTargetContent(probe)) &&
+    readyProbeContentBasis(probe) !== '' &&
     probe.externalReady !== false &&
     !probe.externalError &&
     !probe.loadingText

package/src/bundleGlobalFooter.ts

@@ -14,18 +14,37 @@ export function findBundleFooter(source: string, prefix: string): number {
     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: string, line: number, end: number): boolean {
+  return (
+    line === end ||
+    source.startsWith('globalThis.', line) ||
+    source.startsWith('//', line)
+  )
+}
+
+// the whole trailing block the readers above walk, split from the code before
+// it. a rewrite of the code (minification) must leave the block as written:
+// a minifier reprints each footer's JSON as an object literal and moves legal
+// comments after it, so no reader would find the footer again.
+export function splitBundleFooterBlock(source: string): {
+  code: string
+  footers: string
+} {
+  let end = source.length
+  while (end > 0) {
+    const newline = source.lastIndexOf('\n', end - 1)
+    if (newline < 0 || !isFooterBlockLine(source, newline + 1, end)) break
+    end = newline
+  }
+  return { code: source.slice(0, end), footers: source.slice(end) }
+}
+
 function readFooter(
   source: string,
   prefix: string,

package/src/codex-client.ts

@@ -9,6 +9,7 @@
 
 import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
 import readline from 'node:readline'
+import { terminateProcessGroup } from './process-group'
 
 export interface CodexClientOptions {
   /** resolved path to the codex binary (via `which codex` or user override). */
@@ -211,10 +212,10 @@ export function spawnCodexClient(options: CodexClientOptions): CodexClient {
       try {
         child.stdin.end()
       } catch {}
-      const t = setTimeout(() => {
+      const t = setTimeout(async () => {
         if (!closed) {
           try {
-            child.kill('SIGTERM')
+            await terminateProcessGroup(child, 'SIGTERM')
           } catch {}
         }
       }, timeoutMs)

package/src/config.ts

@@ -76,6 +76,8 @@ export interface PeachConfig<Settings extends Record<string, any> = Record<strin
   runtimeVersion?: string
   // native host identity. omission preserves the Fabric default.
   nativeRenderer?: NativeRenderer
+  // developer-owned browser token, restricted to the runtime's origin.
+  mapKit?: { token: string }
   modules?: Record<string, ModuleResolution>
   // native stubs keyed by the package they answer. the cli lowers these, with
   // installed stub packages, into the wire slots below before anything runs.
@@ -95,6 +97,9 @@ export interface PeachConfig<Settings extends Record<string, any> = Record<strin
     remap?: Record<string, string>
   }
   settings?: Partial<Settings>
+  // the properties a native host hands the root component at launch, the
+  // initialProperties of RCTRootView / runApplication's initialProps.
+  initialProps?: Record<string, unknown>
   initialState?: {
     authenticated?: boolean
     locale?: string
@@ -131,6 +136,11 @@ export function isPeachConfig<Settings extends Record<string, any> = Record<stri
     (value.nativeRenderer === undefined ||
       value.nativeRenderer === 'paper' ||
       value.nativeRenderer === 'fabric') &&
+    (value.mapKit === undefined ||
+      (isRecord(value.mapKit) &&
+        typeof value.mapKit.token === 'string' &&
+        value.mapKit.token.length > 0 &&
+        value.mapKit.token === value.mapKit.token.trim())) &&
     (value.runtimeVersion === undefined ||
       (typeof value.runtimeVersion === 'string' &&
         value.runtimeVersion === value.runtimeVersion.trim() &&
@@ -144,6 +154,7 @@ export function isPeachConfig<Settings extends Record<string, any> = Record<stri
       'env',
       'network',
       'settings',
+      'initialProps',
       'initialState',
     ].every((key) => value[key] === undefined || isRecord(value[key])) &&
     (value.packages === undefined ||
@@ -232,6 +243,7 @@ export function hasPeachConfig<
   if (!config) return false
   return (
     config.nativeRenderer !== undefined ||
+    config.mapKit !== undefined ||
     (typeof config.runtimeVersion === 'string' && config.runtimeVersion.length > 0) ||
     hasOwnKeys(config.modules as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.turboModules as Record<string, unknown> | undefined) ||
@@ -240,6 +252,7 @@ export function hasPeachConfig<
     hasOwnKeys(config.env as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.network?.remap as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.settings as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.initialProps) ||
     hasOwnKeys(config.initialState as Record<string, unknown> | undefined)
   )
 }
@@ -257,6 +270,7 @@ export function mergePeachConfig<
   return {
     runtimeVersion: override.runtimeVersion ?? base.runtimeVersion,
     nativeRenderer: override.nativeRenderer ?? base.nativeRenderer,
+    mapKit: override.mapKit ?? base.mapKit,
     modules: { ...(base.modules || {}), ...(override.modules || {}) },
     turboModules: { ...(base.turboModules || {}), ...(override.turboModules || {}) },
     nativeModules: {
@@ -272,6 +286,7 @@ export function mergePeachConfig<
       ...(base.settings || {}),
       ...(override.settings || {}),
     } as Partial<Settings>,
+    initialProps: { ...(base.initialProps || {}), ...(override.initialProps || {}) },
     initialState: { ...(base.initialState || {}), ...(override.initialState || {}) },
   }
 }

package/src/desktop-host-delivery.ts

@@ -229,9 +229,13 @@ export function headlessHostCommand(): string[] | null {
     if (!fs.existsSync(launcher) || !hostEntrySupportsAutomaticPort(host)) return null
     return [launcher, '--experimental-vm-modules', host]
   }
-  const version = placedHostVersion()
+  const pin = desktopHostDelivery().resolvePin()
+  if (pin && !/^\d+\.\d+$/.test(pin))
+    throw new Error(`invalid native host version '${pin}' (expected <build>.<attempt>)`)
+  const version = pin || placedHostVersion()
   if (!version) return null
   const dir = desktopHostDir(version)
+  if (!fs.existsSync(path.join(dir, desktopHostExecutable()))) return null
   // a placed host that predates the automatic-port bind upgrades like a missing one
   if (!hostEntrySupportsAutomaticPort(path.join(dir, 'node/host.mjs'))) return null
   return [