@nativescript/windows 0.1.0-alpha.1

package/build.ps1

@@ -0,0 +1,107 @@
+#Requires -Version 5.1
+<#
+.SYNOPSIS
+    Builds both nativescript.dll configurations and copies them into
+    template/framework/libs/ ready for npm publish.
+
+.DESCRIPTION
+    Produces four DLLs (x64 + arm64, release + devtools) from the workspace
+    Rust crate and places them at:
+
+        framework/libs/x64/nativescript.dll            # release, no devtools
+        framework/libs/arm64/nativescript.dll
+        framework/libs/devtools/x64/nativescript.dll   # release-with-devtools
+        framework/libs/devtools/arm64/nativescript.dll
+
+    Run from anywhere; the script locates the repo root via its own path.
+
+.PARAMETER SkipArm64
+    Skip the arm64 cross-compilation steps (faster, x64-only output).
+
+.PARAMETER SkipRelease
+    Skip the stripped release builds (devtools builds only).
+
+.PARAMETER SkipDevtools
+    Skip the devtools builds (release builds only).
+#>
+param(
+    [switch]$SkipArm64,
+    [switch]$SkipRelease,
+    [switch]$SkipDevtools
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+# ── Paths ─────────────────────────────────────────────────────────────────────
+
+$ScriptDir  = $PSScriptRoot
+$RepoRoot   = (Resolve-Path (Join-Path $ScriptDir "..")).Path
+$FrameworkLibs = Join-Path $ScriptDir "framework\libs"
+
+Write-Host "Repo root  : $RepoRoot"
+Write-Host "Output dir : $FrameworkLibs"
+
+# ── Helper ────────────────────────────────────────────────────────────────────
+
+function Copy-Dll {
+    param([string]$Src, [string]$Dest)
+    $null = New-Item -ItemType Directory -Force -Path (Split-Path $Dest)
+    Copy-Item -Force $Src $Dest
+    Write-Host "  copied  $(Split-Path $Src -Leaf)  →  $(Resolve-Path $Dest -Relative 2>$null)"
+}
+
+function Build-Crate {
+    param(
+        [string]$Profile,       # e.g. "release" or "release-with-devtools"
+        [string]$Target,        # e.g. "x86_64-pc-windows-msvc"
+        [string[]]$ExtraArgs    # e.g. @("--features","devtools")
+    )
+    $args = @("build", "--profile", $Profile, "-p", "nativescript", "--target", $Target) + $ExtraArgs
+    Write-Host ""
+    Write-Host "cargo $($args -join ' ')"
+    Push-Location $RepoRoot
+    try {
+        & cargo @args
+        if ($LASTEXITCODE -ne 0) { throw "cargo build failed (exit $LASTEXITCODE)" }
+    } finally {
+        Pop-Location
+    }
+}
+
+# ── Targets ───────────────────────────────────────────────────────────────────
+
+$Targets = @(
+    @{ Arch = "x64";   RustTarget = "x86_64-pc-windows-msvc"  }
+)
+if (-not $SkipArm64) {
+    $Targets += @{ Arch = "arm64"; RustTarget = "aarch64-pc-windows-msvc" }
+}
+
+# ── Build ─────────────────────────────────────────────────────────────────────
+
+foreach ($t in $Targets) {
+    $arch        = $t.Arch
+    $rustTarget  = $t.RustTarget
+
+    if (-not $SkipRelease) {
+        Write-Host "`n=== Release ($arch) ===" -ForegroundColor Cyan
+        Build-Crate -Profile "release" -Target $rustTarget
+        $dll = Join-Path $RepoRoot "target\$rustTarget\release\nativescript.dll"
+        Copy-Dll -Src $dll -Dest (Join-Path $FrameworkLibs "$arch\nativescript.dll")
+    }
+
+    if (-not $SkipDevtools) {
+        Write-Host "`n=== Release-with-devtools ($arch) ===" -ForegroundColor Cyan
+        Build-Crate -Profile "release-with-devtools" -Target $rustTarget -ExtraArgs @("--features", "devtools")
+        $dll = Join-Path $RepoRoot "target\$rustTarget\release-with-devtools\nativescript.dll"
+        Copy-Dll -Src $dll -Dest (Join-Path $FrameworkLibs "devtools\$arch\nativescript.dll")
+    }
+}
+
+Write-Host ""
+Write-Host "Done." -ForegroundColor Green
+Write-Host ""
+Write-Host "libs layout:"
+Get-ChildItem -Recurse $FrameworkLibs -Filter "*.dll" |
+    ForEach-Object { "  " + $_.FullName.Substring($FrameworkLibs.Length + 1) }

package/framework/__PROJECT_NAME__/App/main.js

@@ -0,0 +1,12 @@
+const page = new Windows.UI.Xaml.Controls.Page();
+const text = new Windows.UI.Xaml.Controls.TextBlock();
+text.Text = "Hello from NativeScript on Windows!";
+text.FontSize = 24;
+text.HorizontalAlignment = Windows.UI.Xaml.HorizontalAlignment.Center;
+text.VerticalAlignment = Windows.UI.Xaml.VerticalAlignment.Center;
+
+const grid = new Windows.UI.Xaml.Controls.Grid();
+grid.Children.Append(text);
+page.Content = grid;
+
+Windows.UI.Xaml.Window.Current.Content = page;

package/framework/__PROJECT_NAME__/App.xaml

@@ -0,0 +1,7 @@
+<Application
+    x:Class="__PROJECT_NAME__.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:__PROJECT_NAME__">
+
+</Application>

package/framework/__PROJECT_NAME__/App.xaml.cs

@@ -0,0 +1,79 @@
+using System;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.Storage;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Navigation;
+
+namespace __PROJECT_NAME__
+{
+    sealed partial class App : Application
+    {
+        private const string LastLaunchArgsKey = "LastLaunchArgs";
+        private readonly RuntimeHost _runtimeHost = new RuntimeHost();
+
+        public App()
+        {
+            CrashDiagnostics.InstallGlobalHandlers();
+            this.Suspending += OnSuspending;
+            this.UnhandledException += OnUnhandledException;
+        }
+
+        protected override void OnLaunched(LaunchActivatedEventArgs e)
+        {
+            _runtimeHost.Initialize();
+            try
+            {
+                _runtimeHost.RunMainScript();
+            }
+            catch (Exception scriptEx)
+            {
+                System.Diagnostics.Debug.WriteLine($"[NativeScript] Script exception: {scriptEx.Message}");
+            }
+
+#if DEBUG
+            Windows.UI.Xaml.Media.CompositionTarget.Rendering += OnRenderFrame;
+#endif
+
+            if (Window.Current.Content == null)
+            {
+                Window.Current.Content = new Windows.UI.Xaml.Controls.TextBlock
+                {
+                    Text = "NativeScript runtime initialized but no UI was rendered.\n" +
+                           "Check the Output window for JS errors.",
+                    Margin = new Windows.UI.Xaml.Thickness(20),
+                    TextWrapping = Windows.UI.Xaml.TextWrapping.Wrap,
+                    FontSize = 16,
+                };
+            }
+
+            if (!e.PrelaunchActivated)
+            {
+                Window.Current.Activate();
+            }
+        }
+
+        private void OnSuspending(object sender, SuspendingEventArgs e)
+        {
+            var deferral = e.SuspendingOperation.GetDeferral();
+#if DEBUG
+            Windows.UI.Xaml.Media.CompositionTarget.Rendering -= OnRenderFrame;
+#endif
+            ApplicationData.Current.LocalSettings.Values[LastLaunchArgsKey] = string.Empty;
+            _runtimeHost.Dispose();
+            deferral.Complete();
+        }
+
+        private void OnUnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e)
+        {
+            CrashDiagnostics.WriteExceptionReport(
+                "Xaml.UnhandledException",
+                e.Exception,
+                "Message=" + e.Message + "; Handled=" + e.Handled);
+        }
+
+#if DEBUG
+        private void OnRenderFrame(object sender, object e) => _runtimeHost.PumpDevtools();
+#endif
+    }
+}

package/framework/__PROJECT_NAME__/CrashDiagnostics.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.Storage;
+
+namespace __PROJECT_NAME__
+{
+    internal static class CrashDiagnostics
+    {
+        private static bool _installed;
+
+        public static void InstallGlobalHandlers()
+        {
+            if (_installed) return;
+            _installed = true;
+
+            AppDomain.CurrentDomain.UnhandledException += (_, args) =>
+            {
+                var ex = args.ExceptionObject as Exception;
+                WriteExceptionReport("AppDomain.UnhandledException", ex, "IsTerminating=" + args.IsTerminating);
+            };
+
+            TaskScheduler.UnobservedTaskException += (_, args) =>
+            {
+                WriteExceptionReport("TaskScheduler.UnobservedTaskException", args.Exception, null);
+            };
+        }
+
+        public static void WriteExceptionReport(string source, Exception ex, string details)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("============================================================");
+            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
+            sb.AppendLine("Source: " + source);
+            if (!string.IsNullOrWhiteSpace(details)) sb.AppendLine("Details: " + details);
+            if (ex != null) { sb.AppendLine("Exception:"); sb.AppendLine(ex.ToString()); }
+            else sb.AppendLine("Exception: <null>");
+            sb.AppendLine("Managed stack snapshot:");
+            sb.AppendLine(Environment.StackTrace);
+            sb.AppendLine();
+            AppendToLog(sb.ToString());
+        }
+
+        public static void WriteMessage(string source, string message)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("============================================================");
+            sb.AppendLine("Timestamp: " + DateTimeOffset.UtcNow.ToString("o"));
+            sb.AppendLine("Source: " + source);
+            sb.AppendLine("Message: " + message);
+            sb.AppendLine();
+            AppendToLog(sb.ToString());
+        }
+
+        private static void AppendToLog(string content)
+        {
+            try
+            {
+                var logPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "nativescript-crash.log");
+                File.AppendAllText(logPath, content, Encoding.UTF8);
+            }
+            catch { }
+        }
+    }
+}

package/framework/__PROJECT_NAME__/Package.appxmanifest

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<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">
+
+  <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>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
+  </Dependencies>
+
+  <Resources>
+    <Resource Language="x-generate"/>
+  </Resources>
+
+  <Applications>
+    <Application Id="App"
+      Executable="$targetnametoken$.exe"
+      EntryPoint="__PROJECT_NAME__.App">
+      <uap:VisualElements
+        DisplayName="__PROJECT_NAME__"
+        Square150x150Logo="Assets\Square150x150Logo.png"
+        Square44x44Logo="Assets\Square44x44Logo.png"
+        Description="A NativeScript Windows application"
+        BackgroundColor="transparent">
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png"/>
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+
+  <Capabilities>
+    <Capability Name="internetClient" />
+    <Capability Name="privateNetworkClientServer" />
+  </Capabilities>
+</Package>

package/framework/__PROJECT_NAME__/Program.cs

@@ -0,0 +1,15 @@
+using Windows.UI.Xaml;
+
+namespace __PROJECT_NAME__
+{
+    public static class Program
+    {
+        public static void Main(string[] args)
+        {
+            Application.Start(p =>
+            {
+                var app = new App();
+            });
+        }
+    }
+}

package/framework/__PROJECT_NAME__/Properties/Default.rd.xml

@@ -0,0 +1,9 @@
+<!--
+    Runtime Directives for .NET Native.
+    See https://go.microsoft.com/fwlink/?LinkID=391919
+-->
+<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
+  <Application>
+    <Assembly Name="*Application*" Dynamic="Required All" />
+  </Application>
+</Directives>

package/framework/__PROJECT_NAME__/RuntimeHost.cs

@@ -0,0 +1,196 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text.Json;
+
+namespace __PROJECT_NAME__
+{
+    internal sealed class RuntimeHost : IDisposable
+    {
+        private const string NativeScriptLibrary = "nativescript";
+
+        [DllImport("kernel32.dll")]
+        private static extern bool AttachConsole(int dwProcessId);
+
+        private const int ATTACH_PARENT_PROCESS = -1;
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_init))]
+        private static extern long runtime_init([MarshalAs(UnmanagedType.LPUTF8Str)] string appRoot);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_deinit))]
+        private static extern void runtime_deinit(long runtime);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_runscript))]
+        private static extern void runtime_runscript(long runtime, [MarshalAs(UnmanagedType.LPUTF8Str)] string script, [MarshalAs(UnmanagedType.LPUTF8Str)] string filename);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_install_ctrlc_handler))]
+        private static extern void runtime_install_ctrlc_handler(int exitCode);
+
+#if DEBUG
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_devtools_start))]
+        private static extern IntPtr runtime_devtools_start(long runtime, ushort port);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_devtools_pump))]
+        private static extern void runtime_devtools_pump(long runtime);
+
+        [DllImport(NativeScriptLibrary, EntryPoint = nameof(runtime_free_string))]
+        private static extern void runtime_free_string(IntPtr ptr);
+
+        public string DevtoolsFrontendUrl { get; private set; }
+
+        public void PumpDevtools()
+        {
+            if (!_initialized) return;
+            try { runtime_devtools_pump(_runtime); }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] Pump failed: {ex.Message}");
+            }
+        }
+
+        private void StartDevtoolsSafely()
+        {
+            IntPtr urlPtr = IntPtr.Zero;
+            try
+            {
+                urlPtr = runtime_devtools_start(_runtime, 42000);
+                if (urlPtr == IntPtr.Zero) return;
+                var wsUrl = Marshal.PtrToStringUTF8(urlPtr);
+                DevtoolsFrontendUrl = wsUrl != null
+                    ? $"devtools://devtools/bundled/inspector.html?ws={wsUrl.Replace("ws://", "")}"
+                    : null;
+                if (DevtoolsFrontendUrl != null)
+                    System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] {DevtoolsFrontendUrl}");
+            }
+            catch (Exception ex)
+            {
+                DevtoolsFrontendUrl = null;
+                System.Diagnostics.Debug.WriteLine($"[NativeScript DevTools] Start failed: {ex.Message}");
+            }
+            finally
+            {
+                if (urlPtr != IntPtr.Zero) runtime_free_string(urlPtr);
+            }
+        }
+#endif
+
+        private long _runtime;
+        private bool _initialized;
+
+        public void Initialize()
+        {
+            if (_initialized) return;
+            AttachConsole(ATTACH_PARENT_PROCESS);
+            runtime_install_ctrlc_handler(0);
+            _runtime = runtime_init(AppContext.BaseDirectory);
+#if DEBUG
+            if (ConsumeDebugBreakMarker())
+                StartDevtoolsSafely();
+#endif
+            _initialized = true;
+        }
+
+#if DEBUG
+        /// <summary>
+        /// Returns true and deletes the marker if the CLI wrote ns-debugbreak to LocalFolder,
+        /// matching the Android sentinel-file pattern used by the NativeScript CLI.
+        /// </summary>
+        private static bool ConsumeDebugBreakMarker()
+        {
+            try
+            {
+                var markerPath = System.IO.Path.Combine(
+                    Windows.Storage.ApplicationData.Current.LocalFolder.Path,
+                    "ns-debugbreak");
+                if (!System.IO.File.Exists(markerPath))
+                    return false;
+                System.IO.File.Delete(markerPath);
+                return true;
+            }
+            catch { return false; }
+        }
+#endif
+
+        public void RunMainScript()
+        {
+            if (!_initialized)
+                throw new InvalidOperationException("Runtime must be initialized before running scripts.");
+
+            var entryPath = ResolveEntryScriptPath();
+            var script = File.ReadAllText(Path.GetFullPath(entryPath));
+            try
+            {
+                runtime_runscript(_runtime, script, Path.GetFileName(entryPath));
+            }
+            catch (Exception ex)
+            {
+                CrashDiagnostics.WriteExceptionReport("RuntimeHost.RunMainScript", ex, "EntryScript=" + entryPath);
+                System.Diagnostics.Debug.WriteLine($"[NativeScript Runtime] Script execution failed ({entryPath}): {ex}");
+                throw;
+            }
+        }
+
+        private sealed class RuntimePackageConfig
+        {
+            public string Main { get; set; } = string.Empty;
+            public string WindowsMain { get; set; } = string.Empty;
+        }
+
+        private static string ResolveEntryScriptPath()
+        {
+            var baseDir = AppContext.BaseDirectory;
+            var defaultPath = Path.Combine(baseDir, "App", "main.js");
+            var packageJsonPath = Path.Combine(baseDir, "package.json");
+
+            if (!File.Exists(packageJsonPath)) return defaultPath;
+
+            try
+            {
+                var config = ParsePackageConfig(packageJsonPath);
+                if (!string.IsNullOrWhiteSpace(config.WindowsMain))
+                {
+                    var p = ResolveScriptPath(baseDir, config.WindowsMain);
+                    if (p != null) return p;
+                }
+                if (!string.IsNullOrWhiteSpace(config.Main))
+                {
+                    var p = ResolveScriptPath(baseDir, config.Main);
+                    if (p != null) return p;
+                }
+            }
+            catch { }
+
+            return defaultPath;
+        }
+
+        private static RuntimePackageConfig ParsePackageConfig(string packageJsonPath)
+        {
+            using var doc = JsonDocument.Parse(File.ReadAllText(packageJsonPath));
+            var config = new RuntimePackageConfig();
+            if (doc.RootElement.TryGetProperty("main", out var main) && main.ValueKind == JsonValueKind.String)
+                config.Main = main.GetString();
+            if (doc.RootElement.TryGetProperty("windows", out var win) && win.ValueKind == JsonValueKind.Object &&
+                win.TryGetProperty("main", out var winMain) && winMain.ValueKind == JsonValueKind.String)
+                config.WindowsMain = winMain.GetString();
+            return config;
+        }
+
+        private static string ResolveScriptPath(string baseDir, string scriptPath)
+        {
+            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;
+        }
+
+        public void Dispose()
+        {
+            if (!_initialized) return;
+            runtime_deinit(_runtime);
+            _runtime = 0;
+            _initialized = false;
+        }
+    }
+}

package/framework/__PROJECT_NAME__/__PROJECT_NAME__.csproj

@@ -0,0 +1,50 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net10.0-windows10.0.26100.0</TargetFramework>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <RootNamespace>__PROJECT_NAME__</RootNamespace>
+    <AssemblyName>__PROJECT_NAME__</AssemblyName>
+    <UseUwp>true</UseUwp>
+    <Platforms>x64;arm64</Platforms>
+    <RuntimeIdentifiers>win-x64;win-arm64</RuntimeIdentifiers>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <EnableMsixTooling>true</EnableMsixTooling>
+    <AppxPackageSigningEnabled>false</AppxPackageSigningEnabled>
+    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <Nullable>disable</Nullable>
+    <DefineConstants>$(DefineConstants);DISABLE_XAML_GENERATED_MAIN</DefineConstants>
+    <!-- Parent of the project directory — contains the pre-built libs/ folder from the npm package -->
+    <NSWindowsRoot>$(MSBuildProjectDirectory)\..</NSWindowsRoot>
+  </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\**\*">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- App_Resources: platform-specific assets (images, fonts, etc.) -->
+    <Content Include="App_Resources\**\*" Condition="Exists('App_Resources')">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Debug: devtools-enabled runtime DLL -->
+    <Content Include="$(NSWindowsRoot)\libs\devtools\$(Platform)\nativescript.dll"
+             Condition="'$(Configuration)' == 'Debug'">
+      <Link>nativescript.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+
+    <!-- Release: production runtime DLL -->
+    <Content Include="$(NSWindowsRoot)\libs\$(Platform)\nativescript.dll"
+             Condition="'$(Configuration)' != 'Debug'">
+      <Link>nativescript.dll</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+</Project>

package/framework/libs/README.md

@@ -0,0 +1,17 @@
+# Runtime DLLs
+
+This directory contains the pre-built NativeScript Windows runtime DLLs.
+
+Expected structure:
+
+```
+libs/
+  x64/nativescript.dll          # Release build, 64-bit
+  arm64/nativescript.dll        # Release build, ARM64
+  devtools/
+    x64/nativescript.dll        # Debug build with DevTools, 64-bit
+    arm64/nativescript.dll      # Debug build with DevTools, ARM64
+```
+
+These are populated by the CI release pipeline (cargo build --release / --features devtools).
+They are not included in the git repository — download a release package or build from source.

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@nativescript/windows",
+  "version": "0.1.0-alpha.1",
+  "description": "NativeScript for using Windows v8",
+  "repository": {
+        "type": "git",
+        "url": "https://github.com/NativeScript/windows.git"
+  },
+  "scripts": {
+    "build": "pwsh -File build.ps1",
+    "build:x64": "pwsh -File build.ps1 -SkipArm64"
+  },
+  "keywords": ["nativescript", "windows", "winrt", "uwp"],
+  "license": "Apache-2.0",
+  "files": [
+    "**/*"
+  ]
+}