@nativescript/windows 0.1.0-alpha.76 → 0.1.0-alpha.78

package/framework/__PROJECT_NAME__/Directory.Build.targets

@@ -6,7 +6,7 @@
        easily overridden per-app or via MSBuild /p: properties. -->
 
   <!-- Inline merge task: will merge App_Resources/Windows/Package.appxmanifest or Package.appxmanifest.partial.xml into the generated Package.appxmanifest -->
-  <UsingTask TaskName="MergeAppxManifest" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
+  <UsingTask TaskName="MergeAppxManifest" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll" Condition="'$(MSBuildRuntimeType)' != 'Core'">
     <ParameterGroup>
       <SourceManifest ParameterType="System.String" Required="true" />
       <TargetManifest ParameterType="System.String" Required="true" />
@@ -85,7 +85,7 @@
     </Task>
   </UsingTask>
 
-  <Target Name="MergeAppResourcesManifest" AfterTargets="ApplyManifestOverrides" Condition="Exists('$(MSBuildProjectDirectory)\Package.appxmanifest')">
+  <Target Name="MergeAppResourcesManifest" AfterTargets="ApplyManifestOverrides" Condition="Exists('$(MSBuildProjectDirectory)\Package.appxmanifest') and '$(MSBuildRuntimeType)' != 'Core'">
     <PropertyGroup>
       <_AppResourcesManifest>$(MSBuildProjectDirectory)\App_Resources\Windows\Package.appxmanifest</_AppResourcesManifest>
       <!-- Allow CLI or callers to override the source manifest via MSBuild property 'AppResourcesManifestPath' -->

package/framework/dotnet-bridge/Bridge.BinaryDispatch.cs

@@ -33,11 +33,23 @@ public static partial class Bridge
     {
         var op = r.ReadByte();
 
-        if (op == 0x04) // release
-        {
-            s_handles.TryRemove(r.ReadI32(), out _);
-            return DispatchResult.Void;
-        }
+            if (op == 0x04) // release
+            {
+                var handleToRemove = r.ReadI32();
+                s_handles.TryRemove(handleToRemove, out _);
+                if (s_nativePtrs.TryRemove(handleToRemove, out var nativePtr))
+                {
+                    try
+                    {
+                        Marshal.Release(new IntPtr(nativePtr));
+                    }
+                    catch
+                    {
+                        // best-effort
+                    }
+                }
+                return DispatchResult.Void;
+            }
 
         if (op == 0x05) // members by handle
         {

package/framework/dotnet-bridge/Bridge.Dispatch.cs

@@ -18,11 +18,24 @@ public static partial class Bridge
     {
         var method = req.Method ?? throw new ArgumentException("Method is required");
 
-        if (method == "__release" && req.Handle.HasValue)
-        {
-            s_handles.TryRemove(req.Handle.Value, out _);
-            return DispatchResult.Void;
-        }
+            if (method == "__release" && req.Handle.HasValue)
+            {
+                var id = req.Handle.Value;
+                s_handles.TryRemove(id, out _);
+                if (s_nativePtrs.TryRemove(id, out var nativePtr))
+                {
+                    try
+                    {
+                        Marshal.Release(new IntPtr(nativePtr));
+                    }
+                    catch
+                    {
+                        // swallow - best-effort release
+                    }
+                }
+
+                return DispatchResult.Void;
+            }
 
         object? target = null;
         Type type;
@@ -244,8 +257,28 @@ public static partial class Bridge
             catch { }
         }
 
-        var id = Interlocked.Increment(ref s_nextHandle);
-        s_handles[id] = value;
+            var id = Interlocked.Increment(ref s_nextHandle);
+            s_handles[id] = value;
+
+            // Try to obtain a canonical IUnknown pointer for COM/WinRT objects so the
+            // runtime can call native vtable methods directly. We addref via
+            // Marshal.GetIUnknownForObject and store the raw pointer; it will be
+            // released on __release.
+            try
+            {
+                if (value != null)
+                {
+                    var p = Marshal.GetIUnknownForObject(value);
+                    if (p != IntPtr.Zero)
+                    {
+                        s_nativePtrs[id] = p.ToInt64();
+                    }
+                }
+            }
+            catch
+            {
+                // Not a COM object or failed to obtain native pointer; ignore.
+            }
         var typeName = t.FullName ?? t.Name;
         return IsAwaitable(value, t)
             ? DispatchResult.TaskHandle(id, typeName)

package/framework/dotnet-bridge/Bridge.cs

@@ -48,9 +48,15 @@ public static partial class Bridge
         s_propCache.Clear();
         s_ctorCache.Clear();
         s_handles.Clear();
+        s_nativePtrs.Clear();
         s_nextHandle = 0;
     }
 
+    // Optional mapping from exported handle id -> native IUnknown pointer (Int64)
+    // Populated when a managed object can yield a native COM pointer via
+    // Marshal.GetIUnknownForObject. Cleared and released on __release.
+    internal static readonly ConcurrentDictionary<int, long> s_nativePtrs = new();
+
     // Returns a JSON object mapping top-level namespace roots (e.g. "NativeScript")
     // to the assembly simple-name that most likely contains that namespace's types.
     // Reuses s_assemblySearchDirs so plugin and NuGet assemblies are included.
@@ -326,6 +332,132 @@ public static partial class Bridge
         return 0;
     }
 
+    // Callback id registered by the runtime/JS that should receive unhandled
+    // managed exceptions and unobserved task exceptions.
+    private static int s_unhandledExceptionCallbackId = -1;
+
+    // Called from JS/Rust to request that managed unhandled exceptions be
+    // forwarded to the registered JS callback id.  The callback id must have
+    // been created on the Rust side and point to a JS function stored in the
+    // runtime's `DOTNET_JS_CALLBACKS` map.
+    public static int RegisterUnhandledExceptionCallback(int callbackId)
+    {
+        s_unhandledExceptionCallbackId = callbackId;
+
+        // Subscribe once (idempotent).
+        try
+        {
+            AppDomain.CurrentDomain.UnhandledException -= OnAppDomainUnhandledException;
+            AppDomain.CurrentDomain.UnhandledException += OnAppDomainUnhandledException;
+
+            TaskScheduler.UnobservedTaskException -= OnUnobservedTaskException;
+            TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
+
+            // Try to subscribe to Windows.CoreApplication.UnhandledErrorDetected if available
+            foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                var coreAppType = asm.GetType("Windows.ApplicationModel.Core.CoreApplication");
+                if (coreAppType == null) continue;
+                var ev = coreAppType.GetEvent("UnhandledErrorDetected");
+                if (ev == null) continue;
+                try
+                {
+                    var handlerType = ev.EventHandlerType;
+                    var method = typeof(Bridge).GetMethod(nameof(CoreApplicationUnhandledErrorHandler), BindingFlags.NonPublic | BindingFlags.Static);
+                    if (method != null)
+                    {
+                        var del = Delegate.CreateDelegate(handlerType, method);
+                        ev.AddEventHandler(null, del);
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+
+        return 0;
+    }
+
+    // Return a canonical native pointer (IUnknown / IInspectable) for an
+    // exported handle id. Returns 0 when no pointer is available. If a
+    // pointer isn't already cached in `s_nativePtrs`, attempt to obtain one
+    // via `Marshal.GetIUnknownForObject` and cache it for subsequent calls.
+    public static long GetNativePtrForHandle(int handleId)
+    {
+        if (handleId <= 0) return 0;
+        if (s_nativePtrs.TryGetValue(handleId, out var p)) return p;
+
+        if (!s_handles.TryGetValue(handleId, out var obj) || obj == null)
+            return 0;
+
+        try
+        {
+            var ip = Marshal.GetIUnknownForObject(obj);
+            if (ip != IntPtr.Zero)
+            {
+                var val = ip.ToInt64();
+                s_nativePtrs[handleId] = val;
+                return val;
+            }
+        }
+        catch
+        {
+            // best-effort: not a COM object or failed to obtain native ptr
+        }
+
+        return 0;
+    }
+
+    private static void OnAppDomainUnhandledException(object? sender, UnhandledExceptionEventArgs e)
+    {
+        try
+        {
+            var ex = e.ExceptionObject as Exception;
+            var msg = ex?.ToString() ?? e.ExceptionObject?.ToString() ?? "(unknown)";
+            SendUnhandledToJs("unhandled", msg);
+        }
+        catch { }
+    }
+
+    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+    {
+        try
+        {
+            var msg = e.Exception?.ToString() ?? "(unobserved task exception)";
+            SendUnhandledToJs("unobservedTask", msg);
+        }
+        catch { }
+    }
+
+    // Fallback handler for platform-specific CoreApplication unhandled events.
+    private static void CoreApplicationUnhandledErrorHandler(object? sender, object? args)
+    {
+        try
+        {
+            var msg = args?.ToString() ?? "(core unhandled)";
+            SendUnhandledToJs("coreUnhandled", msg);
+        }
+        catch { }
+    }
+
+    private static unsafe void SendUnhandledToJs(string kind, string message)
+    {
+        try
+        {
+            if (s_jsInvoker == null || s_unhandledExceptionCallbackId <= 0) return;
+            var payload = JsonSerializer.Serialize(new { kind = kind, message = message });
+            var bytes = System.Text.Encoding.UTF8.GetBytes(payload);
+            fixed (byte* p = bytes)
+            {
+                byte* respPtr = null;
+                int respLen = 0;
+                s_jsInvoker(s_unhandledExceptionCallbackId, p, bytes.Length, &respPtr, &respLen);
+                if (respPtr != null && respLen > 0) Marshal.FreeHGlobal((IntPtr)respPtr);
+            }
+        }
+        catch { }
+    }
+
     [UnmanagedCallersOnly(EntryPoint = "Invoke",
         CallConvs = [typeof(System.Runtime.CompilerServices.CallConvCdecl)])]
     public static unsafe int Invoke(

package/framework/dotnet-bridge/DispatchTypes.cs

@@ -115,10 +115,23 @@ internal readonly struct DispatchResult
                 break;
 
             case DispatchKind.Handle:
-                w.WriteStartObject();
-                w.WriteNumber("__handle"u8, _handle);
-                w.WriteString("__type"u8,   _typeName);
-                w.WriteEndObject();
+                    w.WriteStartObject();
+                    w.WriteNumber("__handle"u8, _handle);
+                    w.WriteString("__type"u8,   _typeName);
+                    // If the bridge has a canonical native pointer for this handle,
+                    // expose it as a hex string so the runtime can detect and use it.
+                    if (Bridge.s_nativePtrs.TryGetValue(_handle, out var nativePtr))
+                    {
+                        try
+                        {
+                            w.WriteString("__native_ptr"u8, nativePtr.ToString("x"));
+                        }
+                        catch
+                        {
+                            // ignore formatting errors
+                        }
+                    }
+                    w.WriteEndObject();
                 break;
 
             case DispatchKind.TaskHandle:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/windows",
-  "version": "0.1.0-alpha.76",
+  "version": "0.1.0-alpha.78",
   "description": "NativeScript for using Windows v8",
   "repository": {
         "type": "git",