@nativescript/windows 0.1.0-alpha.2 → 0.1.0-alpha.21

package/framework/__PROJECT_NAME__/App.xaml.cs

@@ -19,16 +19,46 @@ namespace __PROJECT_NAME__
             this.UnhandledException += OnUnhandledException;
         }
 
-        protected override void OnLaunched(LaunchActivatedEventArgs e)
+        protected override async void OnLaunched(LaunchActivatedEventArgs e)
         {
             _runtimeHost.Initialize();
+
+            // Show crash report from the previous run if one exists.
+            try
+            {
+                var panicLogPath = System.IO.Path.Combine(
+                    ApplicationData.Current.LocalFolder.Path, "nativescript-panic.log");
+                if (System.IO.File.Exists(panicLogPath))
+                {
+                    var content = System.IO.File.ReadAllText(panicLogPath);
+                    System.IO.File.Delete(panicLogPath);
+                    if (!string.IsNullOrWhiteSpace(content))
+                        await CrashDiagnostics.ShowCrashDialogAsync("Crash from previous run", content);
+                }
+            }
+            catch { }
+
+            string jsError = null;
             try
             {
                 _runtimeHost.RunMainScript();
+                jsError = _runtimeHost.GetLastJsError();
+                if (!string.IsNullOrEmpty(jsError))
+                {
+                    CrashDiagnostics.WriteMessage("JS Error", jsError);
+                    var report = CrashDiagnostics.BuildErrorReport(null, jsError);
+                    CrashDiagnostics.WriteToTraceLog(report);
+                    await CrashDiagnostics.ShowCrashDialogAsync("JavaScript Error", report);
+                }
             }
             catch (Exception scriptEx)
             {
+                jsError = _runtimeHost.GetLastJsError();
                 System.Diagnostics.Debug.WriteLine($"[NativeScript] Script exception: {scriptEx.Message}");
+                CrashDiagnostics.WriteExceptionReport("RunMainScript", scriptEx, null);
+                var report = CrashDiagnostics.BuildErrorReport(scriptEx, jsError);
+                CrashDiagnostics.WriteToTraceLog(report);
+                await CrashDiagnostics.ShowCrashDialogAsync("Script Execution Error", report);
             }
 
 #if DEBUG
@@ -66,10 +96,17 @@ namespace __PROJECT_NAME__
 
         private void OnUnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e)
         {
+            e.Handled = true;
+            var jsError = _runtimeHost.GetLastJsError();
             CrashDiagnostics.WriteExceptionReport(
                 "Xaml.UnhandledException",
                 e.Exception,
-                "Message=" + e.Message + "; Handled=" + e.Handled);
+                "JsError=" + (jsError ?? "<none>"));
+
+            var report = CrashDiagnostics.BuildErrorReport(e.Exception, jsError);
+            CrashDiagnostics.WriteToTraceLog(report);
+            var _ = CrashDiagnostics.ShowCrashDialogAsync(
+                e.Message ?? "Unhandled exception", report);
         }
 
 #if DEBUG

package/framework/__PROJECT_NAME__/CrashDiagnostics.cs

@@ -2,7 +2,10 @@ using System;
 using System.IO;
 using System.Text;
 using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.ApplicationModel.DataTransfer;
 using Windows.Storage;
+using Windows.UI.Popups;
 
 namespace __PROJECT_NAME__
 {
@@ -53,6 +56,135 @@ namespace __PROJECT_NAME__
             AppendToLog(sb.ToString());
         }
 
+        public static string BuildErrorReport(Exception ex, string jsError = null, string extraDetails = null)
+        {
+            var sb = new StringBuilder();
+
+            if (!string.IsNullOrWhiteSpace(jsError))
+            {
+                sb.AppendLine("── JavaScript Error ──────────────────────────────────────");
+                sb.AppendLine(jsError.Trim());
+                sb.AppendLine();
+            }
+
+            if (ex != null)
+            {
+                sb.AppendLine("── Native Exception ──────────────────────────────────────");
+                sb.AppendLine(ex.GetType().Name + ": " + ex.Message);
+                if (ex.StackTrace != null) sb.AppendLine(ex.StackTrace);
+                var inner = ex.InnerException;
+                while (inner != null)
+                {
+                    sb.AppendLine("Caused by: " + inner.GetType().Name + ": " + inner.Message);
+                    if (inner.StackTrace != null) sb.AppendLine(inner.StackTrace);
+                    inner = inner.InnerException;
+                }
+                sb.AppendLine();
+            }
+
+            // Include panic log from previous or current run
+            try
+            {
+                var panicLog = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-panic.log");
+                if (File.Exists(panicLog))
+                {
+                    var content = File.ReadAllText(panicLog, Encoding.UTF8).Trim();
+                    if (!string.IsNullOrEmpty(content))
+                    {
+                        sb.AppendLine("── Rust Panic Log ────────────────────────────────────────");
+                        sb.AppendLine(content);
+                        sb.AppendLine();
+                    }
+                }
+            }
+            catch { }
+
+            if (!string.IsNullOrWhiteSpace(extraDetails))
+            {
+                sb.AppendLine("── Additional Info ───────────────────────────────────────");
+                sb.AppendLine(extraDetails);
+                sb.AppendLine();
+            }
+
+            sb.AppendLine("──────────────────────────────────────────────────────────");
+            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
+
+            return sb.ToString();
+        }
+
+        public static string CrashLogPath()
+        {
+            try { return Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log"); }
+            catch { return null; }
+        }
+
+        public static async Task ShowCrashDialogAsync(string heading, string errorReport)
+        {
+            try
+            {
+                // Write full details to log so developer can access them even if the
+                // dialog summary is truncated.
+                var logPath = CrashLogPath();
+                if (logPath != null)
+                    File.WriteAllText(logPath, errorReport, Encoding.UTF8);
+
+                // Truncate for the dialog (MessageDialog has practical limits).
+                const int MaxLen = 800;
+                var summary = errorReport.Length > MaxLen
+                    ? errorReport.Substring(0, MaxLen) + "\n\n[truncated — see log for full details]"
+                    : errorReport;
+
+                if (logPath != null)
+                    summary += "\n\nFull log: " + logPath;
+
+                var dialog = new MessageDialog(summary, "NativeScript Runtime Error");
+
+                dialog.Commands.Add(new UICommand("Copy Details", _ =>
+                {
+                    try
+                    {
+                        var dp = new DataPackage();
+                        dp.SetText(errorReport);
+                        Clipboard.SetContent(dp);
+                    }
+                    catch { }
+                }));
+
+                dialog.Commands.Add(new UICommand("Restart App", async _ =>
+                {
+                    try { await CoreApplication.RequestRestartAsync("crash-restart"); }
+                    catch { }
+                }));
+
+                dialog.Commands.Add(new UICommand("Dismiss"));
+                dialog.DefaultCommandIndex = 0;
+                dialog.CancelCommandIndex = 2;
+
+                await dialog.ShowAsync();
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine("[NativeScript] Failed to show crash dialog: " + ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Appends <paramref name="message"/> to ns_trace.log using the Win32 temp path.
+        /// Inside UWP, GetTempPath() virtualises to AC\Temp — the same folder Rust's
+        /// std::env::temp_dir() uses — so this write appears in the CLI's log stream.
+        /// </summary>
+        public static void WriteToTraceLog(string message)
+        {
+            try
+            {
+                // System.IO.Path.GetTempPath() calls Win32 GetTempPathW() which inside a
+                // UWP process returns the container's AC\Temp folder, matching Rust.
+                var tracePath = Path.Combine(System.IO.Path.GetTempPath(), "ns_trace.log");
+                File.AppendAllText(tracePath, message, Encoding.UTF8);
+            }
+            catch { }
+        }
+
         private static void AppendToLog(string content)
         {
             try

package/framework/__PROJECT_NAME__/Package.appxmanifest

@@ -2,17 +2,14 @@
 
 <Package
   xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
-  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
   xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
-  IgnorableNamespaces="uap mp">
+  IgnorableNamespaces="uap">
 
   <Identity
     Name="__APP_IDENTIFIER__"
     Publisher="CN=__PROJECT_NAME__"
     Version="1.0.0.0" />
 
-  <mp:PhoneIdentity PhoneProductId="__APP_IDENTIFIER__" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
-
   <Properties>
     <DisplayName>__PROJECT_NAME__</DisplayName>
     <PublisherDisplayName>__PROJECT_NAME__</PublisherDisplayName>
@@ -24,7 +21,7 @@
   </Dependencies>
 
   <Resources>
-    <Resource Language="x-generate"/>
+    <Resource Language="en-US"/>
   </Resources>
 
   <Applications>

package/framework/__PROJECT_NAME__/RuntimeHost.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text.Json;
 
@@ -26,6 +28,18 @@ namespace __PROJECT_NAME__
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_install_ctrlc_handler))]
         private static extern void runtime_install_ctrlc_handler(int exitCode);
 
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_set_local_folder))]
+        private static extern void runtime_set_local_folder([MarshalAs(UnmanagedType.LPUTF8Str)] string localFolder);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_get_last_js_error))]
+        private static extern IntPtr runtime_get_last_js_error();
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_free_js_error))]
+        private static extern void runtime_free_js_error(IntPtr ptr);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_has_devtools))]
+        private static extern bool runtime_has_devtools();
+
 #if DEBUG
         [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_devtools_start))]
         private static extern IntPtr runtime_devtools_start(long runtime, ushort port);
@@ -38,9 +52,11 @@ namespace __PROJECT_NAME__
 
         public string DevtoolsFrontendUrl { get; private set; }
 
+        private bool _devtoolsAvailable;
+
         public void PumpDevtools()
         {
-            if (!_initialized) return;
+            if (!_initialized || !_devtoolsAvailable) return;
             try { runtime_devtools_pump(_runtime); }
             catch (Exception ex)
             {
@@ -50,6 +66,7 @@ namespace __PROJECT_NAME__
 
         private void StartDevtoolsSafely()
         {
+            if (!runtime_has_devtools()) return;
             IntPtr urlPtr = IntPtr.Zero;
             try
             {
@@ -60,7 +77,10 @@ namespace __PROJECT_NAME__
                     ? $"devtools://devtools/bundled/inspector.html?ws={wsUrl.Replace("ws://", "")}"
                     : null;
                 if (DevtoolsFrontendUrl != null)
+                {
+                    _devtoolsAvailable = true;
                     System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] {DevtoolsFrontendUrl}");
+                }
             }
             catch (Exception ex)
             {
@@ -82,6 +102,7 @@ namespace __PROJECT_NAME__
             if (_initialized) return;
             AttachConsole(ATTACH_PARENT_PROCESS);
             runtime_install_ctrlc_handler(0);
+            runtime_set_local_folder(Windows.Storage.ApplicationData.Current.LocalFolder.Path);
             _runtime = runtime_init(AppContext.BaseDirectory);
 #if DEBUG
             if (ConsumeDebugBreakMarker())
@@ -117,16 +138,38 @@ namespace __PROJECT_NAME__
                 throw new InvalidOperationException("Runtime must be initialized before running scripts.");
 
             var entryPath = ResolveEntryScriptPath();
-            var script = File.ReadAllText(Path.GetFullPath(entryPath));
-            try
+            if (entryPath == null)
             {
-                runtime_runscript(_runtime, script, Path.GetFileName(entryPath));
+                System.Diagnostics.Debug.WriteLine("[NativeScript Runtime] No entry script found — bundle missing from app directory.");
+                return;
             }
-            catch (Exception ex)
+
+            var dir = Path.GetDirectoryName(Path.GetFullPath(entryPath));
+            var chunks = new List<string>();
+            foreach (var chunkName in new[] { "runtime.js", "vendor.js" })
             {
-                CrashDiagnostics.WriteExceptionReport("RuntimeHost.RunMainScript", ex, "EntryScript=" + entryPath);
-                System.Diagnostics.Debug.WriteLine($"[NativeScript Runtime] Script execution failed ({entryPath}): {ex}");
-                throw;
+                var chunkPath = Path.Combine(dir, chunkName);
+                if (File.Exists(chunkPath) &&
+                    !string.Equals(chunkPath, Path.GetFullPath(entryPath), StringComparison.OrdinalIgnoreCase))
+                {
+                    chunks.Add(chunkPath);
+                }
+            }
+            chunks.Add(entryPath);
+
+            foreach (var scriptPath in chunks)
+            {
+                var script = File.ReadAllText(Path.GetFullPath(scriptPath));
+                try
+                {
+                    runtime_runscript(_runtime, script, Path.GetFileName(scriptPath));
+                }
+                catch (Exception ex)
+                {
+                    CrashDiagnostics.WriteExceptionReport("RuntimeHost.RunMainScript", ex, "Script=" + scriptPath);
+                    System.Diagnostics.Debug.WriteLine($"[NativeScript Runtime] Script execution failed ({scriptPath}): {ex}");
+                    throw;
+                }
             }
         }
 
@@ -139,28 +182,65 @@ namespace __PROJECT_NAME__
         private static string ResolveEntryScriptPath()
         {
             var baseDir = AppContext.BaseDirectory;
-            var defaultPath = Path.Combine(baseDir, "App", "main.js");
-            var packageJsonPath = Path.Combine(baseDir, "package.json");
+            // EXE lives in <project>/bin/; webpack bundle lives in <project>/app/.
+            var parentDir = Path.GetDirectoryName(
+                baseDir.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar))
+                ?? baseDir;
+
+            // Candidate app directories: sibling of bin/ first, then directly under baseDir.
+            var appDirCandidates = new[]
+            {
+                Path.Combine(parentDir, "app"),
+                Path.Combine(parentDir, "App"),
+                Path.Combine(baseDir, "app"),
+                Path.Combine(baseDir, "App"),
+            };
 
-            if (!File.Exists(packageJsonPath)) return defaultPath;
+            string packageJsonPath = null;
+            string resolvedBaseDir = null;
+            foreach (var dir in appDirCandidates)
+            {
+                var candidate = Path.Combine(dir, "package.json");
+                if (File.Exists(candidate))
+                {
+                    packageJsonPath = candidate;
+                    resolvedBaseDir = dir;
+                    break;
+                }
+            }
+
+            // Also accept package.json at the project root (parent of bin/).
+            if (packageJsonPath == null && File.Exists(Path.Combine(parentDir, "package.json")))
+            {
+                packageJsonPath = Path.Combine(parentDir, "package.json");
+                resolvedBaseDir = parentDir;
+            }
+
+            string Fallback() =>
+                appDirCandidates
+                    .SelectMany(d => new[] { Path.Combine(d, "bundle.js"), Path.Combine(d, "bundle.mjs") })
+                    .FirstOrDefault(File.Exists);
+
+            if (packageJsonPath == null)
+                return Fallback();
 
             try
             {
                 var config = ParsePackageConfig(packageJsonPath);
                 if (!string.IsNullOrWhiteSpace(config.WindowsMain))
                 {
-                    var p = ResolveScriptPath(baseDir, config.WindowsMain);
+                    var p = ResolveScriptPath(resolvedBaseDir, config.WindowsMain);
                     if (p != null) return p;
                 }
                 if (!string.IsNullOrWhiteSpace(config.Main))
                 {
-                    var p = ResolveScriptPath(baseDir, config.Main);
+                    var p = ResolveScriptPath(resolvedBaseDir, config.Main);
                     if (p != null) return p;
                 }
             }
             catch { }
 
-            return defaultPath;
+            return Fallback();
         }
 
         private static RuntimePackageConfig ParsePackageConfig(string packageJsonPath)
@@ -179,10 +259,34 @@ namespace __PROJECT_NAME__
         {
             if (string.IsNullOrWhiteSpace(scriptPath)) return null;
             var normalized = scriptPath.Replace('/', Path.DirectorySeparatorChar);
-            var direct = Path.IsPathRooted(normalized) ? normalized : Path.Combine(baseDir, normalized);
-            if (File.Exists(direct)) return direct;
-            var appPath = Path.Combine(baseDir, "App", normalized);
-            return File.Exists(appPath) ? appPath : null;
+            foreach (var candidate in new[] { normalized, normalized + ".js", normalized + ".mjs" })
+            {
+                var direct = Path.IsPathRooted(candidate) ? candidate : Path.Combine(baseDir, candidate);
+                if (File.Exists(direct)) return direct;
+                var appLower = Path.Combine(baseDir, "app", candidate);
+                if (File.Exists(appLower)) return appLower;
+                var appUpper = Path.Combine(baseDir, "App", candidate);
+                if (File.Exists(appUpper)) return appUpper;
+            }
+            return null;
+        }
+
+        /// Returns the last JavaScript error (message + stack trace) captured during
+        /// script execution, or null if no error was recorded since the last call.
+        public string GetLastJsError()
+        {
+            if (!_initialized) return null;
+            IntPtr ptr = IntPtr.Zero;
+            try
+            {
+                ptr = runtime_get_last_js_error();
+                return ptr == IntPtr.Zero ? null : Marshal.PtrToStringUTF8(ptr);
+            }
+            catch { return null; }
+            finally
+            {
+                if (ptr != IntPtr.Zero) runtime_free_js_error(ptr);
+            }
         }
 
         public void Dispose()

package/framework/__PROJECT_NAME__/__PROJECT_NAME__.csproj

@@ -19,12 +19,24 @@
     <NSWindowsRoot>$(MSBuildProjectDirectory)\..</NSWindowsRoot>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <!-- Derived library platform for selecting prebuilt native libs.
+         Prefer $(Platform); fall back to trimming 'win-' from $(RuntimeIdentifier); default to x64. -->
+    <NSLibPlatform Condition="'$(Platform)' != ''">$(Platform)</NSLibPlatform>
+    <NSLibPlatform Condition="'$(NSLibPlatform)' == '' and '$(RuntimeIdentifier)' != ''">$([System.Text.RegularExpressions.Regex]::Replace('$(RuntimeIdentifier)','^win-',''))</NSLibPlatform>
+    <NSLibPlatform Condition="'$(NSLibPlatform)' == ''">x64</NSLibPlatform>
+    <!-- Windows SDK .NET runtime pack location (resolved from NuGet cache) -->
+    <_WinSdkNetRefPkg>$(NuGetPackageRoot)microsoft.windows.sdk.net.ref</_WinSdkNetRefPkg>
+    <_WinSdkNetRefVer Condition="Exists('$(_WinSdkNetRefPkg)\10.0.26100.57')">10.0.26100.57</_WinSdkNetRefVer>
+    <_WinSdkNetRefLib Condition="'$(_WinSdkNetRefVer)' != ''">$(_WinSdkNetRefPkg)\$(_WinSdkNetRefVer)\lib\net8.0</_WinSdkNetRefLib>
+  </PropertyGroup>
+
   <ItemGroup>
     <AppxManifest Include="Package.appxmanifest" />
     <Content Include="Properties\Default.rd.xml" />
 
     <!-- App JS/resource files — copied to the output directory on every build -->
-    <Content Include="App\**\*">
+    <Content Include="app\**\*">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
@@ -33,35 +45,49 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
-    <!-- Debug: devtools-enabled runtime DLL -->
-    <Content Include="$(NSWindowsRoot)\libs\devtools\$(Platform)\nativescript.dll"
-             Condition="'$(Configuration)' == 'Debug'">
-      <Link>nativescript.dll</Link>
+    <!-- UWP logo/splash assets required for Add-AppxPackage -Register -->
+    <Content Include="Assets\**\*" Condition="Exists('Assets')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Windows SDK .NET runtime pack assemblies — required when the dotnet workload
+         is not installed; copied from the NuGet package cache. -->
+    <Content Include="$(_WinSdkNetRefLib)\Microsoft.Windows.UI.Xaml.dll"
+             Condition="'$(_WinSdkNetRefLib)' != '' and Exists('$(_WinSdkNetRefLib)\Microsoft.Windows.UI.Xaml.dll')">
+      <Link>Microsoft.Windows.UI.Xaml.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(_WinSdkNetRefLib)\WinRT.Runtime.dll"
+             Condition="'$(_WinSdkNetRefLib)' != '' and Exists('$(_WinSdkNetRefLib)\WinRT.Runtime.dll')">
+      <Link>WinRT.Runtime.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+    <Content Include="$(_WinSdkNetRefLib)\Microsoft.Windows.SDK.NET.dll"
+             Condition="'$(_WinSdkNetRefLib)' != '' and Exists('$(_WinSdkNetRefLib)\Microsoft.Windows.SDK.NET.dll')">
+      <Link>Microsoft.Windows.SDK.NET.dll</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
-    <!-- Release: production runtime DLL -->
-    <Content Include="$(NSWindowsRoot)\libs\$(Platform)\nativescript.dll"
-             Condition="'$(Configuration)' != 'Debug'">
+    <!-- Debug: devtools-enabled runtime DLL (platform fallback via NSLibPlatform) -->
+    <Content Include="$(NSWindowsRoot)\libs\devtools\$(NSLibPlatform)\nativescript.dll"
+             Condition="'$(Configuration)' == 'Debug' and Exists('$(NSWindowsRoot)\libs\devtools\$(NSLibPlatform)\nativescript.dll')">
       <Link>nativescript.dll</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
 
-    <!-- .NET bridge — published on first build by the target below; enables ns.dotnet.*
-         APIs from JavaScript. Must land at dotnet-bridge\publish\ relative to the
-         executable so the Rust runtime can locate DotNetBridge.dll via
-         AppContext.BaseDirectory. Condition guards against a missing source tree. -->
-    <Content Include="$(NSWindowsRoot)\dotnet-bridge\publish\**\*"
-             Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\publish')">
-      <Link>dotnet-bridge\publish\%(RecursiveDir)%(Filename)%(Extension)</Link>
+    <!-- Release: production runtime DLL (platform fallback via NSLibPlatform) -->
+    <Content Include="$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll"
+             Condition="'$(Configuration)' != 'Debug' and Exists('$(NSWindowsRoot)\libs\$(NSLibPlatform)\nativescript.dll')">
+      <Link>nativescript.dll</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+
   </ItemGroup>
 
   <!--
-    Publishes DotNetBridge.dll before the app build so the Content glob above has
-    something to pick up.  Inputs/Outputs make this incremental: MSBuild skips the
-    Exec entirely when DotNetBridge.dll is newer than both source files.
+    Publishes DotNetBridge.dll before the app build.
+    Inputs/Outputs make this incremental: MSBuild skips the Exec when DotNetBridge.dll
+    is already newer than both source files.
   -->
   <Target Name="PublishDotNetBridge"
           BeforeTargets="Build"
@@ -72,4 +98,30 @@
     <Message Text="[NativeScript] Publishing DotNetBridge..." Importance="high" />
     <Exec Command="dotnet publish &quot;$(NSWindowsRoot)\dotnet-bridge\DotNetBridge.csproj&quot; -c Release -o &quot;$(NSWindowsRoot)\dotnet-bridge\publish&quot; --no-self-contained /nologo" />
   </Target>
+
+  <!--
+    Copies the published bridge files to the output directory AFTER PublishDotNetBridge
+    runs, avoiding the MSBuild evaluation-order problem where Condition="Exists(...)"
+    on a static Content item is checked before the publish target creates the directory.
+    Must land at dotnet-bridge\publish\ relative to the EXE so the Rust runtime can
+    locate DotNetBridge.dll via AppContext.BaseDirectory.
+  -->
+  <Target Name="CopyDotNetBridge"
+          AfterTargets="PublishDotNetBridge"
+          BeforeTargets="Build"
+          Condition="Exists('$(NSWindowsRoot)\dotnet-bridge\publish')">
+    <ItemGroup>
+      <_DotNetBridgeFiles Include="$(NSWindowsRoot)\dotnet-bridge\publish\**\*" />
+    </ItemGroup>
+    <Copy SourceFiles="@(_DotNetBridgeFiles)"
+          DestinationFiles="@(_DotNetBridgeFiles->'$(OutDir)dotnet-bridge\publish\%(RecursiveDir)%(Filename)%(Extension)')"
+          SkipUnchangedFiles="true" />
+  </Target>
+
+  <!-- Allow project-level Windows overrides: place App_Resources\Windows\app.csproj to extend/override generated settings -->
+  <Import Project="App_Resources\Windows\app.csproj" Condition="Exists('App_Resources\Windows\app.csproj')" />
+
+  <!-- CLI-generated plugin imports (managed by the CLI during prepare) -->
+  <Import Project="plugins\Plugins.props" Condition="Exists('plugins\Plugins.props')" />
+  <Import Project="plugins\Plugins.targets" Condition="Exists('plugins\Plugins.targets')" />
 </Project>