@use-voltra/ios-client 2.1.1 → 2.2.0

package/expo-plugin/src/ios-widget/xcode/buildPhases.ts

@@ -2,6 +2,7 @@ import { XcodeProject } from '@expo/config-plugins'
 import * as util from 'util'
 
 import type { IOSWidgetExtensionFiles } from '../../types'
+import { ensureWidgetFileReference, normalizeRef } from './fileReferences'
 
 const pbxFile = require('xcode/lib/pbxFile')
 
@@ -98,71 +99,77 @@ export function ensureWidgetBundleScriptPhase(xcodeProject: XcodeProject, target
   }
 }
 
-export interface AddBuildPhasesOptions {
+export interface EnsureBuildPhasesOptions {
   targetUuid: string
+  targetName: string
   groupName: string
   productFile: {
     uuid: string
+    fileRef?: string
     target?: string
     basename: string
     group: string
   }
   widgetFiles: IOSWidgetExtensionFiles
-}
-
-export interface EnsureBuildPhasesOptions extends AddBuildPhasesOptions {
   mainTargetUuid?: string
 }
 
 /**
- * Adds all required build phases for the widget extension target.
+ * Finds a `PBXCopyFilesBuildPhase` on the given target that embeds app extensions
+ * (`dstSubfolderSpec == 13`), regardless of its display name. Returns the phase object or null.
+ *
+ * A project that already contains another app extension (Share/Watch/expo-live-activity) will have
+ * such a phase — typically named "Embed App Extensions" — and the widget's product must be added to
+ * it rather than to a second, duplicate embed phase (issue #87).
  */
-export function addBuildPhases(xcodeProject: XcodeProject, options: AddBuildPhasesOptions): void {
-  const { targetUuid, groupName, productFile, widgetFiles } = options
-  const buildPath = `""`
-  const folderType = 'app_extension'
-
-  const { swiftFiles, intentFiles, assetDirectories, localizedStringResources } = widgetFiles
-  const resourcePaths = [...assetDirectories, ...localizedStringResources]
-
-  // Sources build phase
-  xcodeProject.addBuildPhase(
-    [...swiftFiles, ...intentFiles],
-    'PBXSourcesBuildPhase',
-    'Sources',
-    targetUuid,
-    folderType,
-    buildPath
-  )
-
-  // Copy files build phase
-  xcodeProject.addBuildPhase(
-    [],
-    'PBXCopyFilesBuildPhase',
-    groupName,
-    xcodeProject.getFirstTarget().uuid,
-    folderType,
-    buildPath
-  )
+function findExistingEmbedExtensionsPhase(xcodeProject: XcodeProject, targetUuid: string): any | null {
+  const nativeTargets = xcodeProject.pbxNativeTargetSection()
+  const target = nativeTargets[targetUuid]
+  if (!target?.buildPhases) {
+    return null
+  }
 
-  xcodeProject.buildPhaseObject('PBXCopyFilesBuildPhase', groupName, productFile.target).files.push({
-    value: productFile.uuid,
-    comment: util.format('%s in %s', productFile.basename, productFile.group),
-  })
-  xcodeProject.addToPbxBuildFileSection(productFile)
+  const copyFilesSection = xcodeProject.hash.project.objects['PBXCopyFilesBuildPhase'] || {}
+  for (const entry of target.buildPhases) {
+    const phase = copyFilesSection[normalizeRef(entry.value)]
+    if (phase && String(phase.dstSubfolderSpec) === '13') {
+      return phase
+    }
+  }
+  return null
+}
 
-  // Frameworks build phase
-  xcodeProject.addBuildPhase([], 'PBXFrameworksBuildPhase', 'Frameworks', targetUuid, folderType, buildPath)
+/**
+ * Finds a target's build phase of the given pbx section type by walking the target's own
+ * `buildPhases` list and checking membership in the type's object section; the first match wins.
+ *
+ * This is deliberately semantic: pbxproj comments are decorative and other tools strip them, and
+ * the xcode lib's `buildPhaseObject` both relies on comments and silently falls back to a
+ * project-wide search that can return another target's phase (e.g. the main app's "Sources").
+ * The embed phase is the one exception with extra semantics — see
+ * {@link findExistingEmbedExtensionsPhase} (`dstSubfolderSpec == 13`).
+ */
+function findTargetPhaseByType(xcodeProject: XcodeProject, targetUuid: string, phaseType: string): any | null {
+  const target = xcodeProject.pbxNativeTargetSection()[targetUuid]
+  if (!target?.buildPhases) {
+    return null
+  }
 
-  // Resources build phase
-  xcodeProject.addBuildPhase([...resourcePaths], 'PBXResourcesBuildPhase', 'Resources', targetUuid)
+  const phaseSection = xcodeProject.hash.project.objects[phaseType] || {}
+  for (const entry of target.buildPhases) {
+    const phase = phaseSection[normalizeRef(entry.value)]
+    if (phase) {
+      return phase
+    }
+  }
+  return null
 }
 
 /**
  * Ensures all required build phases and files exist for the widget extension target.
  */
 export function ensureBuildPhases(xcodeProject: XcodeProject, options: EnsureBuildPhasesOptions): void {
-  const { targetUuid, groupName, productFile, widgetFiles } = options
+  const { targetUuid, targetName, groupName, productFile, widgetFiles } = options
   const buildPath = `""`
   const folderType = 'app_extension'
   const mainTargetUuid = options.mainTargetUuid ?? xcodeProject.getFirstTarget().uuid
@@ -170,60 +177,55 @@ export function ensureBuildPhases(xcodeProject: XcodeProject, options: EnsureBui
   const { swiftFiles, intentFiles, assetDirectories, localizedStringResources } = widgetFiles
   const resourcePaths = [...assetDirectories, ...localizedStringResources]
 
-  dedupeBuildPhasesForTarget(xcodeProject, targetUuid, 'PBXSourcesBuildPhase', 'Sources')
-  dedupeBuildPhasesForTarget(xcodeProject, targetUuid, 'PBXFrameworksBuildPhase', 'Frameworks')
-  dedupeBuildPhasesByComment(xcodeProject, mainTargetUuid, 'PBXCopyFilesBuildPhase', groupName)
+  dedupeBuildPhasesForTarget(xcodeProject, targetUuid, 'PBXSourcesBuildPhase')
+  dedupeBuildPhasesForTarget(xcodeProject, targetUuid, 'PBXFrameworksBuildPhase')
+  dedupeEmbedPhasesForTarget(xcodeProject, mainTargetUuid)
 
   // Sources build phase
-  let sourcesPhase = xcodeProject.buildPhaseObject('PBXSourcesBuildPhase', 'Sources', targetUuid)
+  let sourcesPhase = findTargetPhaseByType(xcodeProject, targetUuid, 'PBXSourcesBuildPhase')
   if (!sourcesPhase) {
-    xcodeProject.addBuildPhase(
-      [...swiftFiles, ...intentFiles],
-      'PBXSourcesBuildPhase',
-      'Sources',
-      targetUuid,
-      folderType,
-      buildPath
-    )
-    sourcesPhase = xcodeProject.buildPhaseObject('PBXSourcesBuildPhase', 'Sources', targetUuid)
+    xcodeProject.addBuildPhase([], 'PBXSourcesBuildPhase', 'Sources', targetUuid, folderType, buildPath)
+    sourcesPhase = findTargetPhaseByType(xcodeProject, targetUuid, 'PBXSourcesBuildPhase')
   }
   if (sourcesPhase) {
-    ensureBuildPhaseFiles(xcodeProject, sourcesPhase, [...swiftFiles, ...intentFiles])
+    ensureBuildPhaseFiles(xcodeProject, sourcesPhase, [...swiftFiles, ...intentFiles], targetName)
   }
 
-  // Copy files build phase (embed extension into main app)
-  let copyFilesPhase = xcodeProject.buildPhaseObject('PBXCopyFilesBuildPhase', groupName, mainTargetUuid)
+  // Copy files build phase (embed extension into main app) — the embed phase is matched purely by
+  // its `dstSubfolderSpec == 13` semantics, both before and after creation
+  let copyFilesPhase = findExistingEmbedExtensionsPhase(xcodeProject, mainTargetUuid)
   if (!copyFilesPhase) {
     xcodeProject.addBuildPhase([], 'PBXCopyFilesBuildPhase', groupName, mainTargetUuid, folderType, buildPath)
-    copyFilesPhase = xcodeProject.buildPhaseObject('PBXCopyFilesBuildPhase', groupName, mainTargetUuid)
+    copyFilesPhase = findExistingEmbedExtensionsPhase(xcodeProject, mainTargetUuid)
   }
   if (copyFilesPhase) {
     ensureCopyFilesPhaseProduct(xcodeProject, copyFilesPhase, productFile)
   }
 
   // Frameworks build phase
-  const frameworksPhase = xcodeProject.buildPhaseObject('PBXFrameworksBuildPhase', 'Frameworks', targetUuid)
+  const frameworksPhase = findTargetPhaseByType(xcodeProject, targetUuid, 'PBXFrameworksBuildPhase')
   if (!frameworksPhase) {
     xcodeProject.addBuildPhase([], 'PBXFrameworksBuildPhase', 'Frameworks', targetUuid, folderType, buildPath)
   }
 
   // Resources build phase
-  let resourcesPhase = xcodeProject.buildPhaseObject('PBXResourcesBuildPhase', 'Resources', targetUuid)
+  let resourcesPhase = findTargetPhaseByType(xcodeProject, targetUuid, 'PBXResourcesBuildPhase')
   if (!resourcesPhase) {
-    xcodeProject.addBuildPhase([...resourcePaths], 'PBXResourcesBuildPhase', 'Resources', targetUuid)
-    resourcesPhase = xcodeProject.buildPhaseObject('PBXResourcesBuildPhase', 'Resources', targetUuid)
+    xcodeProject.addBuildPhase([], 'PBXResourcesBuildPhase', 'Resources', targetUuid)
+    resourcesPhase = findTargetPhaseByType(xcodeProject, targetUuid, 'PBXResourcesBuildPhase')
   }
   if (resourcesPhase) {
-    ensureBuildPhaseFiles(xcodeProject, resourcesPhase, [...resourcePaths])
+    ensureBuildPhaseFiles(xcodeProject, resourcesPhase, resourcePaths, targetName)
   }
 }
 
-function dedupeBuildPhasesForTarget(
-  xcodeProject: XcodeProject,
-  targetUuid: string,
-  phaseType: string,
-  preferredComment: string
-): void {
+/**
+ * Drops duplicate build phases of one pbx section type from a target, keeping the first phase in
+ * the target's `buildPhases` order. Membership in the type's object section is the only criterion —
+ * comments are decorative and other tools strip them. De-referenced phase objects are deleted so no
+ * orphans remain.
+ */
+function dedupeBuildPhasesForTarget(xcodeProject: XcodeProject, targetUuid: string, phaseType: string): void {
   const nativeTargets = xcodeProject.pbxNativeTargetSection()
   const target = nativeTargets[targetUuid]
   if (!target?.buildPhases) {
@@ -231,114 +233,97 @@ function dedupeBuildPhasesForTarget(
   }
 
   const phaseSection = xcodeProject.hash.project.objects[phaseType] || {}
-  const matching = target.buildPhases.filter((entry: any) => phaseSection[entry.value])
+  const matching = target.buildPhases.filter((entry: any) => phaseSection[normalizeRef(entry.value)])
   if (matching.length <= 1) {
     return
   }
 
-  const keep = matching.find((entry: any) => entry.comment === preferredComment) ?? matching[0]
-  keep.comment = preferredComment
-
+  const keep = matching[0]
+  const removed = matching.filter((entry: any) => entry.value !== keep.value)
   target.buildPhases = target.buildPhases.filter((entry: any) => {
-    if (!phaseSection[entry.value]) {
+    if (!phaseSection[normalizeRef(entry.value)]) {
       return true
     }
     return entry.value === keep.value
   })
+  deleteOrphanPhaseObjects(phaseSection, removed)
 }
 
-function dedupeBuildPhasesByComment(
-  xcodeProject: XcodeProject,
-  targetUuid: string,
-  phaseType: string,
-  comment: string
-): void {
+/**
+ * Drops duplicate embed-app-extensions copy-files phases (`dstSubfolderSpec == 13`) from a target,
+ * keeping the first one in the target's `buildPhases` order. Other copy-files phases (different
+ * `dstSubfolderSpec`) are left untouched. De-referenced phase objects are deleted so no orphans
+ * remain.
+ */
+function dedupeEmbedPhasesForTarget(xcodeProject: XcodeProject, targetUuid: string): void {
   const nativeTargets = xcodeProject.pbxNativeTargetSection()
   const target = nativeTargets[targetUuid]
   if (!target?.buildPhases) {
     return
   }
 
-  const phaseSection = xcodeProject.hash.project.objects[phaseType] || {}
-  const matching = target.buildPhases.filter((entry: any) => phaseSection[entry.value] && entry.comment === comment)
+  const phaseSection = xcodeProject.hash.project.objects['PBXCopyFilesBuildPhase'] || {}
+  const isEmbedEntry = (entry: any) => {
+    const phase = phaseSection[normalizeRef(entry.value)]
+    return phase && String(phase.dstSubfolderSpec) === '13'
+  }
+
+  const matching = target.buildPhases.filter(isEmbedEntry)
   if (matching.length <= 1) {
     return
   }
 
   const keep = matching[0]
+  const removed = matching.filter((entry: any) => entry.value !== keep.value)
   target.buildPhases = target.buildPhases.filter((entry: any) => {
-    if (!phaseSection[entry.value] || entry.comment !== comment) {
+    if (!isEmbedEntry(entry)) {
       return true
     }
     return entry.value === keep.value
   })
+  deleteOrphanPhaseObjects(phaseSection, removed)
 }
 
-function normalizePath(value: string | undefined): string {
-  if (!value) {
-    return ''
-  }
-  return value.replace(/^"|"$/g, '')
-}
-
-function findFileReferenceKey(xcodeProject: XcodeProject, filePath: string): string | null {
-  const fileReferenceSection = xcodeProject.pbxFileReferenceSection()
-  const normalizedPath = normalizePath(filePath)
-
-  for (const key of Object.keys(fileReferenceSection)) {
-    if (/_comment$/.test(key)) {
-      continue
-    }
-    const entry = fileReferenceSection[key]
-    const entryPath = normalizePath(entry?.path)
-    if (entryPath === normalizedPath) {
-      return key
-    }
-  }
-
-  return null
-}
-
-function findBuildFileKeyByFileRef(xcodeProject: XcodeProject, fileRef: string): string | null {
-  const buildFileSection = xcodeProject.pbxBuildFileSection()
-  for (const key of Object.keys(buildFileSection)) {
-    if (/_comment$/.test(key)) {
-      continue
-    }
-    const entry = buildFileSection[key]
-    if (entry?.fileRef === fileRef) {
-      return key
-    }
+/**
+ * Deletes de-referenced build-phase objects (and their `_comment` keys) from a phase section, so
+ * dropping duplicate phase refs from a target does not leave orphan objects that fail the
+ * `[Xcodeproj]` consistency check.
+ */
+function deleteOrphanPhaseObjects(phaseSection: Record<string, any>, removedEntries: any[]): void {
+  for (const entry of removedEntries) {
+    const key = normalizeRef(entry.value)
+    delete phaseSection[key]
+    delete phaseSection[`${key}_comment`]
   }
-  return null
 }
 
-function ensureFileReference(xcodeProject: XcodeProject, filePath: string) {
-  const existingFileRef = findFileReferenceKey(xcodeProject, filePath)
+/**
+ * Resolves (or creates) the PBXBuildFile for a widget file within a specific build phase.
+ *
+ * The lookup is scoped to the given phase's `files`: a PBXBuildFile is only reused when it is
+ * already part of THIS phase. This prevents adopting a build file that belongs to another target's
+ * phase — the same PBXFileReference (e.g. an asset catalog) may legitimately need its own build
+ * file per phase, and sharing one produces the "no parent for object" corruption (issue #87). When
+ * no match exists a new PBXBuildFile with a fresh UUID is created.
+ */
+function ensureBuildFile(xcodeProject: XcodeProject, filePath: string, buildPhase: any, targetName: string) {
+  const fileRef = ensureWidgetFileReference(xcodeProject, filePath, targetName)
   const file = new pbxFile(filePath)
 
-  if (existingFileRef) {
-    return { fileRef: existingFileRef, basename: file.basename, group: file.group }
-  }
-
-  file.fileRef = xcodeProject.generateUuid()
-  xcodeProject.addToPbxFileReferenceSection(file)
-  return { fileRef: file.fileRef, basename: file.basename, group: file.group }
-}
-
-function ensureBuildFile(xcodeProject: XcodeProject, filePath: string) {
-  const fileReference = ensureFileReference(xcodeProject, filePath)
-  const existingBuildFile = findBuildFileKeyByFileRef(xcodeProject, fileReference.fileRef)
-
-  if (existingBuildFile) {
-    return { uuid: existingBuildFile, ...fileReference }
+  if (buildPhase?.files) {
+    const buildFileSection = xcodeProject.pbxBuildFileSection()
+    const existingInPhase = buildPhase.files.find((entry: any) => {
+      const buildFile = buildFileSection[normalizeRef(entry.value)]
+      return buildFile?.fileRef === fileRef
+    })
+    if (existingInPhase) {
+      return { uuid: normalizeRef(existingInPhase.value), fileRef, basename: file.basename, group: file.group }
+    }
   }
 
-  const file = new pbxFile(filePath)
-  file.uuid = xcodeProject.generateUuid()
-  file.fileRef = fileReference.fileRef
-  xcodeProject.addToPbxBuildFileSection(file)
-  return { uuid: file.uuid, ...fileReference, group: file.group }
+  const uuid = xcodeProject.generateUuid()
+  xcodeProject.addToPbxBuildFileSection({ uuid, fileRef, basename: file.basename, group: file.group } as any)
+  return { uuid, fileRef, basename: file.basename, group: file.group }
 }
 
 function buildPhaseHasFile(xcodeProject: XcodeProject, buildPhase: any, fileRef: string): boolean {
@@ -348,23 +333,28 @@ function buildPhaseHasFile(xcodeProject: XcodeProject, buildPhase: any, fileRef:
   const buildFileSection = xcodeProject.pbxBuildFileSection()
 
   return buildPhase.files.some((entry: any) => {
-    const buildFile = buildFileSection[entry.value]
+    const buildFile = buildFileSection[normalizeRef(entry.value)]
     return buildFile?.fileRef === fileRef
   })
 }
 
-function ensureBuildPhaseFiles(xcodeProject: XcodeProject, buildPhase: any, filePaths: string[]): void {
+function ensureBuildPhaseFiles(
+  xcodeProject: XcodeProject,
+  buildPhase: any,
+  filePaths: string[],
+  targetName: string
+): void {
   if (!buildPhase.files) {
     buildPhase.files = []
   }
 
   for (const filePath of filePaths) {
-    const fileReference = ensureFileReference(xcodeProject, filePath)
-    if (buildPhaseHasFile(xcodeProject, buildPhase, fileReference.fileRef)) {
+    const fileRef = ensureWidgetFileReference(xcodeProject, filePath, targetName)
+    if (buildPhaseHasFile(xcodeProject, buildPhase, fileRef)) {
       continue
     }
 
-    const buildFile = ensureBuildFile(xcodeProject, filePath)
+    const buildFile = ensureBuildFile(xcodeProject, filePath, buildPhase, targetName)
     buildPhase.files.push({
       value: buildFile.uuid,
       comment: util.format('%s in %s', buildFile.basename, buildFile.group),
@@ -377,18 +367,27 @@ function ensureCopyFilesPhaseProduct(xcodeProject: XcodeProject, buildPhase: any
     buildPhase.files = []
   }
 
-  const alreadyExists = buildPhase.files.some((entry: any) => entry.value === productFile.uuid)
-  if (alreadyExists) {
+  const buildFileSection = xcodeProject.pbxBuildFileSection()
+  const alreadyInPhase = buildPhase.files.some((entry: any) => {
+    const buildFile = buildFileSection[normalizeRef(entry.value)]
+    return buildFile?.fileRef === productFile.fileRef
+  })
+  if (alreadyInPhase) {
     return
   }
 
-  const buildFileSection = xcodeProject.pbxBuildFileSection()
-  if (!buildFileSection[productFile.uuid]) {
+  // Reuse the product's build-file UUID only if it isn't already registered by another phase;
+  // otherwise mint a fresh UUID so the two phases never share one PBXBuildFile (issue #87).
+  let useUuid = productFile.uuid
+  if (buildFileSection[productFile.uuid]) {
+    useUuid = xcodeProject.generateUuid()
+    xcodeProject.addToPbxBuildFileSection({ ...productFile, uuid: useUuid })
+  } else {
     xcodeProject.addToPbxBuildFileSection(productFile)
   }
 
   buildPhase.files.push({
-    value: productFile.uuid,
+    value: useUuid,
     comment: util.format('%s in %s', productFile.basename, productFile.group),
   })
 }

package/expo-plugin/src/ios-widget/xcode/configurationList.ts

@@ -1,34 +1,52 @@
 import { XcodeProject } from '@expo/config-plugins'
 
 import { IOS } from '../../constants'
+import type { MainAppSigningSettings, MainAppTargetSettings } from './mainAppSettings'
 
-export interface AddConfigurationListOptions {
+export interface EnsureConfigurationListOptions {
   targetName: string
   bundleIdentifier: string
   deploymentTarget: string
-  codeSignStyle?: string
-  developmentTeam?: string
-  provisioningProfileSpecifier?: string
+  /**
+   * App marketing version (CFBundleShortVersionString). App Store Connect expects the appex
+   * version to match the app's, so this becomes the widget's MARKETING_VERSION.
+   */
+  version?: string
+  /** App build number; becomes the widget's CURRENT_PROJECT_VERSION. */
+  buildNumber?: string
+  /** Main app signing settings, applied per configuration name (Debug→Debug, Release→Release). */
+  mainAppSettings?: MainAppTargetSettings | null
 }
 
-function createCommonBuildSettings(options: AddConfigurationListOptions) {
-  const {
-    targetName,
-    bundleIdentifier,
-    deploymentTarget,
-    codeSignStyle,
-    developmentTeam,
-    provisioningProfileSpecifier,
-  } = options
-
-  const commonBuildSettings: Record<string, string> = {
+/**
+ * Resolves the main app signing settings for a widget configuration name: an exact name match
+ * wins, otherwise the first available configuration's settings are used as fallback.
+ */
+function signingForConfiguration(
+  mainAppSettings: MainAppTargetSettings | null | undefined,
+  configurationName: string
+): MainAppSigningSettings {
+  if (!mainAppSettings) {
+    return {}
+  }
+  return mainAppSettings.byConfigurationName[configurationName] ?? mainAppSettings.fallback
+}
+
+function createBuildSettings(options: EnsureConfigurationListOptions, configurationName: string) {
+  const { targetName, bundleIdentifier, deploymentTarget, version, buildNumber, mainAppSettings } = options
+  const { codeSignStyle, developmentTeam, provisioningProfileSpecifier } = signingForConfiguration(
+    mainAppSettings,
+    configurationName
+  )
+
+  const buildSettings: Record<string, string> = {
     PRODUCT_NAME: `"$(TARGET_NAME)"`,
     SWIFT_VERSION: IOS.SWIFT_VERSION,
     TARGETED_DEVICE_FAMILY: `"${IOS.DEVICE_FAMILY}"`,
     INFOPLIST_FILE: `${targetName}/Info.plist`,
     INFOPLIST_OUTPUT_FORMAT: `"xml"`,
-    CURRENT_PROJECT_VERSION: `"1"`,
-    MARKETING_VERSION: `"1.0"`,
+    CURRENT_PROJECT_VERSION: `"${buildNumber ?? '1'}"`,
+    MARKETING_VERSION: `"${version ?? '1.0'}"`,
     IPHONEOS_DEPLOYMENT_TARGET: `"${deploymentTarget}"`,
     PRODUCT_BUNDLE_IDENTIFIER: `"${bundleIdentifier}"`,
     SWIFT_OPTIMIZATION_LEVEL: `"-Onone"`,
@@ -37,41 +55,37 @@ function createCommonBuildSettings(options: AddConfigurationListOptions) {
     ASSETCATALOG_COMPILER_APPICON_NAME: '""',
   }
 
-  // Synchronize code signing settings from main app target
+  // Synchronize code signing settings from the main app target's matching configuration
   if (codeSignStyle) {
-    commonBuildSettings.CODE_SIGN_STYLE = `"${codeSignStyle}"`
+    buildSettings.CODE_SIGN_STYLE = `"${codeSignStyle}"`
   }
   if (developmentTeam) {
-    commonBuildSettings.DEVELOPMENT_TEAM = `"${developmentTeam}"`
+    buildSettings.DEVELOPMENT_TEAM = `"${developmentTeam}"`
   }
   if (provisioningProfileSpecifier) {
-    commonBuildSettings.PROVISIONING_PROFILE_SPECIFIER = `"${provisioningProfileSpecifier}"`
+    buildSettings.PROVISIONING_PROFILE_SPECIFIER = `"${provisioningProfileSpecifier}"`
   }
 
-  return commonBuildSettings
+  return buildSettings
 }
 
 /**
- * Adds the XCConfigurationList for the widget extension target.
+ * Adds a fresh XCConfigurationList for the widget extension target. Internal create-only fallback
+ * for {@link ensureXCConfigurationList}; not part of the public pipeline.
  */
-export function addXCConfigurationList(xcodeProject: XcodeProject, options: AddConfigurationListOptions) {
+function addXCConfigurationList(xcodeProject: XcodeProject, options: EnsureConfigurationListOptions) {
   const { targetName } = options
-  const commonBuildSettings = createCommonBuildSettings(options)
 
   const buildConfigurationsList = [
     {
       name: 'Debug',
       isa: 'XCBuildConfiguration',
-      buildSettings: {
-        ...commonBuildSettings,
-      },
+      buildSettings: createBuildSettings(options, 'Debug'),
     },
     {
       name: 'Release',
       isa: 'XCBuildConfiguration',
-      buildSettings: {
-        ...commonBuildSettings,
-      },
+      buildSettings: createBuildSettings(options, 'Release'),
     },
   ]
 
@@ -85,11 +99,13 @@ export function addXCConfigurationList(xcodeProject: XcodeProject, options: AddC
 }
 
 /**
- * Ensures an existing XCConfigurationList is updated, or adds a new one if missing.
+ * Ensures an existing XCConfigurationList is updated, or adds a new one if missing. Each widget
+ * configuration receives the build settings derived for its own name, so Debug and Release signing
+ * stay in sync with the main app's respective configurations.
  */
 export function ensureXCConfigurationList(
   xcodeProject: XcodeProject,
-  options: AddConfigurationListOptions,
+  options: EnsureConfigurationListOptions,
   existingConfigurationListId?: string | { value?: string }
 ) {
   const configurationListId =
@@ -103,7 +119,6 @@ export function ensureXCConfigurationList(
     return addXCConfigurationList(xcodeProject, options)
   }
 
-  const commonBuildSettings = createCommonBuildSettings(options)
   const buildConfigurations = configurationList.buildConfigurations
   const buildConfigurationSection = xcodeProject.pbxXCBuildConfigurationSection()
 
@@ -117,9 +132,11 @@ export function ensureXCConfigurationList(
       continue
     }
 
+    const configurationName =
+      typeof buildConfiguration.name === 'string' ? buildConfiguration.name.replace(/^"|"$/g, '') : ''
     buildConfiguration.buildSettings = {
       ...(buildConfiguration.buildSettings ?? {}),
-      ...commonBuildSettings,
+      ...createBuildSettings(options, configurationName),
     }
   }
 

package/expo-plugin/src/ios-widget/xcode/fileReferences.ts

@@ -0,0 +1,51 @@
+import { XcodeProject } from '@expo/config-plugins'
+
+const pbxFile = require('xcode/lib/pbxFile')
+
+/** Strips surrounding quotes from a pbx path/name value. */
+export function normalizePath(value: string | undefined): string {
+  if (!value) {
+    return ''
+  }
+  return value.replace(/^"|"$/g, '')
+}
+
+/** Strips a trailing `/* comment *\/` and whitespace, yielding the bare UUID of a pbx reference. */
+export function normalizeRef(value: unknown): string {
+  return String(value)
+    .replace(/\/\*.*?\*\//g, '')
+    .trim()
+}
+
+/**
+ * Resolves the PBXFileReference UUID for a widget file, scoped to the widget's own PBXGroup.
+ *
+ * pbxproj paths are group-relative, so a bare path like `Assets.xcassets` collides with any other
+ * extension's identically named file. Scoping the lookup to the children of the widget group
+ * (identified by `targetName`) keeps the widget's references distinct from those, which is what
+ * prevents the shared-fileRef corruption behind issues #87/#32. When the widget group does not
+ * exist yet, a fresh reference is created.
+ */
+export function ensureWidgetFileReference(xcodeProject: XcodeProject, filePath: string, targetName: string): string {
+  const file = new pbxFile(filePath)
+  const fileReferenceSection = xcodeProject.pbxFileReferenceSection()
+  const group = xcodeProject.pbxGroupByName(targetName)
+
+  if (group?.children) {
+    for (const child of group.children) {
+      const refKey = normalizeRef(child.value)
+      const entry = fileReferenceSection[refKey]
+      if (!entry) {
+        continue
+      }
+      const entryPath = normalizePath(entry.path)
+      if (entryPath === file.path || entryPath === normalizePath(filePath)) {
+        return refKey
+      }
+    }
+  }
+
+  file.fileRef = xcodeProject.generateUuid()
+  xcodeProject.addToPbxFileReferenceSection(file)
+  return file.fileRef
+}