fix: finalize primary dx path follow-ups

Author: Hongwei-MB

docs/articles/getting-started.md

@@ -1,6 +1,6 @@
 # Getting Started
 
-Get a hybrid desktop app running in under five minutes — a native Avalonia window hosting your web frontend, with type-safe bridge calls between C# and JavaScript.
+Get a hybrid desktop app running in under five minutes — a native Avalonia window hosting your web frontend so you can start building product features right away.
 
 ## The main path
 
@@ -51,6 +51,12 @@ fulora dev
 
 You'll see a native window open with your app inside, ready for normal product work.
 
+After these three steps, you have:
+
+- A native desktop window hosting your web app
+- A web frontend and native host already wired together
+- Fulora services ready for normal app development
+
 Alternatively, use `dotnet new` directly:
 
 ```bash
@@ -59,13 +65,17 @@ cd MyApp
 dotnet run --project MyApp.Desktop
 ```
 
-## What you'll end up with
+## Fulora services already use the bridge underneath
+
+When you use `fulora new`, you mostly work with app-level services and UI code first. Under the hood, those services talk across the Fulora bridge for you.
+
+- Your frontend still runs inside a native WebView
+- Your native code still runs in-process in C#
+- Fulora services use generated bridge contracts underneath, so app code can stay focused on product features
 
-After the three steps above, you have a native desktop window hosting your web app, with Fulora services ready for normal app development.
+This means you can start by building screens and calling services, then learn the bridge layer when you need custom native capabilities or plugin work.
 
-- The **UI** runs inside a native WebView
-- The **backend** runs in-process in C#
-- Fulora connects them with generated bridge contracts underneath
+If you want the mental model, it looks like this:
 
 ```
 ┌───────────────────────────────────┐
@@ -84,16 +94,6 @@ After the three steps above, you have a native desktop window hosting your web a
 └───────────────────────────────────┘
 ```
 
-## Fulora services already use the bridge underneath
-
-When you use `fulora new`, you mostly work with app-level services and UI code first. Under the hood, those services talk across the Fulora bridge for you.
-
-- Your frontend still runs inside a native WebView
-- Your native code still runs in-process in C#
-- Fulora services use generated bridge contracts underneath, so app code can stay focused on product features
-
-This means you can start by building screens and calling services, then learn the bridge layer when you need custom native capabilities or plugin work.
-
 ## Manual path: add Fulora to an existing Avalonia app
 
 If you already have an Avalonia project or need full control over the setup.

tests/Agibuild.Fulora.UnitTests/AppDistributionTests.cs

@@ -461,25 +461,82 @@ public void PackageCommand_profile_defaults_allow_explicit_false_notarize_overri
     }
 
     [Fact]
-    public void PackageCommand_profile_defaults_allow_explicit_runtime_and_channel_overrides()
+    public void PackageCommand_profile_defaults_apply_when_options_are_implicit()
     {
         var command = PackageCommand.Create();
         var runtimeOption = Assert.IsType<Option<string>>(command.Options.Single(o => o.Name == "--runtime"));
         var channelOption = Assert.IsType<Option<string>>(command.Options.Single(o => o.Name == "--channel"));
-        var profile = PackageProfileDefaults.Resolve("desktop-public");
+        var notarizeOption = Assert.IsType<Option<bool>>(command.Options.Single(o => o.Name == "--notarize"));
+        var profile = PackageProfileDefaults.Resolve("mac-notarized");
+        var root = new RootCommand("test");
+        root.Subcommands.Add(command);
+        var parseResult = root.Parse("package --profile mac-notarized");
+
+        var runtimeResult = parseResult.GetResult(runtimeOption);
+        var channelResult = parseResult.GetResult(channelOption);
+        var notarizeResult = parseResult.GetResult(notarizeOption);
+
+        Assert.NotNull(runtimeResult);
+        Assert.NotNull(channelResult);
+        Assert.NotNull(notarizeResult);
+        Assert.True(runtimeResult!.Implicit);
+        Assert.True(channelResult!.Implicit);
+        Assert.True(notarizeResult!.Implicit);
+        Assert.Equal("osx-arm64", PackageCommand.GetValue(runtimeOption, parseResult, profile.Runtime));
+        Assert.Equal("stable", PackageCommand.GetValue(channelOption, parseResult, profile.Channel));
+        Assert.True(PackageCommand.GetValue(notarizeOption, parseResult, profile.Notarize));
+    }
+
+    [Fact]
+    public void PackageCommand_profile_defaults_allow_explicit_runtime_channel_and_notarize_overrides()
+    {
+        var command = PackageCommand.Create();
+        var runtimeOption = Assert.IsType<Option<string>>(command.Options.Single(o => o.Name == "--runtime"));
+        var channelOption = Assert.IsType<Option<string>>(command.Options.Single(o => o.Name == "--channel"));
+        var notarizeOption = Assert.IsType<Option<bool>>(command.Options.Single(o => o.Name == "--notarize"));
+        var profile = PackageProfileDefaults.Resolve("mac-notarized");
         var root = new RootCommand("test");
         root.Subcommands.Add(command);
-        var parseResult = root.Parse("package --profile desktop-public --runtime linux-x64 --channel preview");
+        var parseResult = root.Parse("package --profile mac-notarized --runtime osx-x64 --channel preview --notarize false");
 
         var runtimeResult = parseResult.GetResult(runtimeOption);
         var channelResult = parseResult.GetResult(channelOption);
+        var notarizeResult = parseResult.GetResult(notarizeOption);
 
         Assert.NotNull(runtimeResult);
         Assert.NotNull(channelResult);
+        Assert.NotNull(notarizeResult);
         Assert.False(runtimeResult!.Implicit);
         Assert.False(channelResult!.Implicit);
-        Assert.Equal("linux-x64", PackageCommand.GetValue(runtimeOption, parseResult, profile.Runtime));
+        Assert.False(notarizeResult!.Implicit);
+        Assert.Equal("osx-x64", PackageCommand.GetValue(runtimeOption, parseResult, profile.Runtime));
         Assert.Equal("preview", PackageCommand.GetValue(channelOption, parseResult, profile.Channel));
+        Assert.False(PackageCommand.GetValue(notarizeOption, parseResult, profile.Notarize));
+    }
+
+    [Fact]
+    public void PackageCommand_try_resolve_profile_reports_unknown_profiles()
+    {
+        using var stderr = new StringWriter();
+        var previousError = Console.Error;
+        Console.SetError(stderr);
+
+        try
+        {
+            var resolved = PackageCommand.TryResolveProfile("unknown-profile", out var profile);
+
+            Assert.False(resolved);
+            Assert.Equal(string.Empty, profile.Name);
+            Assert.Equal("stable", profile.Channel);
+            Assert.Null(profile.Runtime);
+            Assert.False(profile.Notarize);
+            Assert.Contains("Unknown package profile 'unknown-profile'.", stderr.ToString(), StringComparison.Ordinal);
+            Assert.Contains("desktop-internal, desktop-public, mac-notarized", stderr.ToString(), StringComparison.Ordinal);
+        }
+        finally
+        {
+            Console.SetError(previousError);
+        }
     }
 
     [Fact]