Does Windows 11 support exact-version activation for full-trust desktop MSIX?

Tom Apperson 0 Reputation points
2026-11-06T15:35:09.7366667+00:00

On Windows 11 x64, a normal non-elevated desktop caller independently authorizes PackageFullName A and a manifest Application ID for a registered full-trust desktop MSIX staged in Windows-managed storage, with package integrity enforcement intended. The packaged AUMID is version-independent. Registration may change after verification and before activation.

We reviewed PackageManager.FindPackageForUser, Package.GetAppListEntriesAsync, AppListEntry.LaunchAsync, IApplicationActivationManager::ActivateApplication, GetPackageFullName, GetCurrentPackageFullName, GetPackagePathByFullName, package lifetime/strong references, and package dependency APIs.

  1. Can a supported API bind activation to exact PackageFullName A and Application ID so that A's declared executable is the first private image mapped? If yes, which API, identifiers, Windows versions, and mapping guarantee apply?
  2. If not, is there a supported lock, lease, reference, transaction, or equivalent that keeps registration/version selection stable from verification through selection and first-image mapping? If yes, what are its lifetime rules?
  3. If neither exists and B replaces A before AUMID activation, is the result guaranteed to be A, B, failure, or unspecified? Please state explicitly if no supported guarantee covers this interval.

Post-launch identity checks are understood. Please cite controlling Microsoft documentation or provide an attributable determination from the Windows/MSIX activation team.

Windows development | Windows API - Win32
0 comments No comments

2 answers

Sort by: Newest
  1. Harry Nguyen (WICLOUD CORPORATION) 780 Reputation points Microsoft External Staff Moderator
    2026-11-09T04:29:15.5566667+00:00

    Hi @Tom Apperson , 

    I went through the published documentation for the APIs you mentioned, and none of them covers the full window from verification to first-image mapping. Below are the answers to each of your questions. 

    1. Can a supported API bind activation to exact PackageFullName A and Application ID? 

    No such API is documented. IApplicationActivationManager::ActivateApplication accepts only an AUMID, arguments, and activation options. It has no PackageFullName parameter. AppListEntry.LaunchAsync takes no parameters and launches the app as if the user selected its app list entry. An AUMID is built from the package family name and the Application ID, and it is documented as independent of package version and architecture. It therefore can't identify package A specifically. None of these pages documents which image is mapped first. 

    2. Is there a supported lock, lease, or reference that keeps version selection stable? 

    No documented mechanism provides this guarantee. FindPackageForUser returns information about package A, but its documentation describes no lock on registration. The dynamic dependency API is the closest documented reference mechanism, but it doesn't fit this scenario: 

    Its criteria are package family, minimum version, and architecture. The page states that a specific package can't be specified and that the highest matching version is selected. 

    On Windows 11, a main package can be targeted only if it opts in with uap15:DependencyTarget. 

    AddPackageDependency adds the resolved package to the calling process's package graph so that process can use its content and activate its types. Older versions are serviced side by side while the reference is held. Nothing documents this reference controlling a separate AUMID activation. 

    Because no such mechanism is documented, there are no lifetime rules to cite for it. 

    3. If B replaces A before AUMID activation, is the result A, B, failure, or unspecified? 

    The reviewed documentation doesn't specify this. The activation APIs never receive A's identity, and no document defines an atomic interval from verification through activation selection and first-image mapping. The outcome should be treated as unspecified by the published contracts. Don't rely on any particular result. 

    4. Explicit statement 

    Based on the documentation reviewed, no published Microsoft documentation establishes a supported guarantee that only the executable from exact package A will be the first private image mapped after verification. 

    Public documentation can't provide an authoritative determination from the Windows/MSIX activation team. If your design depends on one, please contact https://developer.microsoft.com/en-us/windows/support to request a formal determination. 

    Hope this clarifies the documented boundaries. If you found this helpful, you can refer to this guidance to confirm it and help others with similar questions. 

    Thank you. 

    Was this answer helpful?


  2. AI answer

    2026-11-06T15:36:08.6466667+00:00

    No supported Windows 11 API documented here binds activation of a packaged full-trust desktop application to both an exact PackageFullName and manifest Application ID through first-image mapping.

    1. Exact-version activation

    The supported activation APIs take an AUMID, not a package full name:

    • IApplicationActivationManager::ActivateApplication accepts appUserModelId, arguments, and activation options. It returns the process ID that fulfills the launch contract, but exposes no package-version or PackageFullName parameter.^1^
    • AppListEntry.LaunchAsync launches the application as though the user selected its app-list entry. It likewise has no exact-package parameter.^2^

    For packaged applications, the AUMID is derived from package family name + Package Relative Application ID. Package identity and application identity are distinct.^3^ Crucially, Microsoft documents the AUMID as independent of package version and architecture.^4^

    Consequently:

    • FindPackageForUser("", A) can retrieve the package identified by exact full name A.^5^
    • GetAppListEntriesAsync can provide A’s application entries.
    • Calling LaunchAsync on such an entry does not have a documented contract that carries A’s full name into activation or pins resolution to A.
    • Passing the resulting AUMID to ActivateApplication cannot express A’s version because the identifier is version-independent.

    None of these APIs documents a guarantee that A’s declared executable will be the first private image mapped.

    2. Lifetime and dependency mechanisms

    A package strong reference prevents the referenced package from being destaged. Registration, provisioning, static/dynamic dependencies, and a process using package content are examples of strong references.^6^ That is a payload-lifetime guarantee, not a documented lock on the current user’s registration or on AUMID-to-version activation selection.

    Dynamic dependencies do not supply the requested transaction either:

    • The dependency is created from criteria including package family, minimum version, and architecture; it cannot identify a specific MSIX package.
    • If multiple packages satisfy the criteria, the highest version is selected.
    • A runtime reference keeps the resolved package in active use until the last reference is removed or the referencing process exits.^7^
    • AddPackageDependency adds the resolved package to the calling process’s package graph. Its documented guarantees concern using content and activating types from that dependency, plus side-by-side servicing; they do not bind a separate AUMID activation to the returned PackageFullName.^8^

    Windows 11’s native dynamic-dependency implementation can target a main package only when that target opts in with uap15:DependencyTarget. Even then, its documented role remains package-graph/content dependency management—not exact-version launch of an application declared by that main package.^7^

    Holding a Package, AppListEntry, COM, or WinRT object alive is also not documented as holding a registration lock. Object lifetime must not be treated as package-registration lifetime without an explicit API contract.

    3. Replacement race: A versus B

    If verification identifies full name A, registration changes, and B replaces A before version-independent AUMID activation:

    • A is not guaranteed, because activation does not receive A’s full name.
    • B is not guaranteed by the cited activation contracts.
    • Failure is not guaranteed either.
    • No cited public contract specifies which of A, B, or failure must result, or defines an atomic interval spanning verification, activation selection, and first-image mapping.

    Therefore, for security design purposes, the outcome across that interval must be treated as unspecified by the supported public API contract. A post-launch identity/image check can detect an unacceptable result, but it does not make the initial mapping atomic.

    If the requirement is that only previously authorized bytes from exact package A may begin executing, the available documentation does not establish a supported packaged-app activation primitive that satisfies it. An authoritative stronger guarantee would require a written determination from the Windows/MSIX activation team or a newly documented API contract; it cannot be inferred from package enumeration, staged-file retention, or dynamic dependencies.


    References

    1. IApplicationActivationManager::ActivateApplication method (shobjidl_core.h)
    2. AppListEntry.LaunchAsync Method-Definition
    3. An overview of Package Identity in Windows apps
    4. AppListEntry.AppUserModelId Property-Definition
    5. PackageManager.FindPackageForUser(String, String) Method-Definition
    6. Package registration and lifetime
    7. Use the dynamic dependency API to reference MSIX packages at run time
    8. AddPackageDependency function (appmodel.h)
    AI-generated content may be incorrect. Read our transparency notes for more information.

    Was this answer helpful?

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.