fix: allow safe fresh-clone DryRun builds

tests/MBN_STOCK_WEBVIEW.LegacyWeb.Tests/LegacyDevelopmentLiveStartupContractTests.cs

@@ -88,6 +88,13 @@ public sealed class LegacyDevelopmentLiveStartupContractTests
         Assert.Contains("#if DEBUG", app, StringComparison.Ordinal);
         Assert.Contains("const bool isDebugBuild = true;", app, StringComparison.Ordinal);
         Assert.Contains("const bool isDebugBuild = false;", app, StringComparison.Ordinal);
+        Assert.Contains("#if SOURCE_ONLY_RUNTIME", app, StringComparison.Ordinal);
+        Assert.Contains("const bool isSourceOnlyBuild = true;", app,
+            StringComparison.Ordinal);
+        Assert.Contains("const bool isSourceOnlyBuild = false;", app,
+            StringComparison.Ordinal);
+        Assert.Contains("isSourceOnlyBuild", app, StringComparison.Ordinal);
+        Assert.Contains("? null", app, StringComparison.Ordinal);
         Assert.Contains("args.Arguments", app, StringComparison.Ordinal);
         Assert.Contains("Environment.GetCommandLineArgs()", app, StringComparison.Ordinal);
         Assert.Contains("ResolveLaunchArguments(", app, StringComparison.Ordinal);

tests/MBN_STOCK_WEBVIEW.LegacyWeb.Tests/LegacyRuntimeAssetDeploymentContractTests.cs

@@ -268,6 +268,154 @@ public sealed class LegacyRuntimeAssetDeploymentContractTests
         Assert.Single(rejectionTarget.Elements("Error"));
     }
 
+    [Fact]
+    public void FreshCloneUsesIsolatedSourceOnlyOutputWithoutWeakeningFullBuilds()
+    {
+        var project = XDocument.Load(ProjectPath);
+
+        var sourceRootWasSpecified = Assert.Single(
+            project.Descendants("LegacyRuntimeSourceRootWasSpecified"));
+        Assert.Equal(
+            "'$(LegacyRuntimeSourceRoot)' != ''",
+            sourceRootWasSpecified.Attribute("Condition")?.Value);
+
+        var modes = project.Descendants("LegacyRuntimeAssetsMode").ToArray();
+        Assert.Equal(2, modes.Length);
+        var requiredMode = Assert.Single(
+            modes,
+            mode => string.Equals(mode.Value, "Required", StringComparison.Ordinal));
+        var requiredCondition = requiredMode.Attribute("Condition")?.Value;
+        Assert.Contains(
+            "$(LegacyRuntimeSourceRootWasSpecified)",
+            requiredCondition,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "'$(Configuration)' == 'Release'",
+            requiredCondition,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "$(GenerateAppxPackageOnBuild)",
+            requiredCondition,
+            StringComparison.Ordinal);
+        Assert.Contains("$(PublishAppxPackage)", requiredCondition, StringComparison.Ordinal);
+
+        var autoMode = Assert.Single(
+            modes,
+            mode => string.Equals(mode.Value, "Auto", StringComparison.Ordinal));
+        Assert.Equal(
+            "'$(LegacyRuntimeAssetsMode)' == ''",
+            autoMode.Attribute("Condition")?.Value);
+
+        var assetsEnabled = Assert.Single(
+            project.Descendants("LegacyRuntimeAssetsEnabled"),
+            element => (element.Attribute("Condition")?.Value ?? string.Empty)
+                .Contains("Exists('$(LegacyRuntimeSourceRoot)')", StringComparison.Ordinal));
+        Assert.Equal("true", assetsEnabled.Value);
+
+        var sourceOnlyOutput = Assert.Single(project.Descendants("BaseOutputPath"));
+        Assert.Equal(@"bin\SourceOnly\", sourceOnlyOutput.Value);
+        Assert.Contains(
+            "$(LegacyRuntimeAssetsEnabled)",
+            sourceOnlyOutput.Attribute("Condition")?.Value,
+            StringComparison.Ordinal);
+        var sourceOnlyIntermediate = Assert.Single(
+            project.Descendants("IntermediateOutputPath"));
+        Assert.Equal(
+            @"obj\SourceOnly\$(Platform)\$(Configuration)\",
+            sourceOnlyIntermediate.Value);
+        Assert.Contains(
+            "$(LegacyRuntimeAssetsEnabled)",
+            sourceOnlyIntermediate.Attribute("Condition")?.Value,
+            StringComparison.Ordinal);
+        var sourceOnlyConstants = Assert.Single(project.Descendants("DefineConstants"));
+        Assert.Contains(
+            "SOURCE_ONLY_RUNTIME",
+            sourceOnlyConstants.Value,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "$(LegacyRuntimeAssetsEnabled)",
+            sourceOnlyConstants.Attribute("Condition")?.Value,
+            StringComparison.Ordinal);
+
+        var validationTarget = Assert.Single(
+            project.Descendants("Target"),
+            element => string.Equals(
+                element.Attribute("Name")?.Value,
+                "ValidateLegacyRuntimeAssets",
+                StringComparison.Ordinal));
+        var sourceOnlyMessage = Assert.Single(validationTarget.Elements("Message"));
+        Assert.Contains(
+            "$(LegacyRuntimeAssetsMode)",
+            sourceOnlyMessage.Attribute("Condition")?.Value,
+            StringComparison.Ordinal);
+        Assert.Contains(
+            "source-only DryRun",
+            sourceOnlyMessage.Attribute("Text")?.Value,
+            StringComparison.Ordinal);
+
+        var runtimeValidationErrors = validationTarget.Elements("Error")
+            .Where(error => (error.Attribute("Condition")?.Value ?? string.Empty)
+                .Contains("Exists(", StringComparison.Ordinal))
+            .ToArray();
+        Assert.NotEmpty(runtimeValidationErrors);
+        Assert.All(runtimeValidationErrors, error =>
+            Assert.Contains(
+                "$(LegacyRuntimeAssetsValidationEnabled)",
+                error.Attribute("Condition")?.Value,
+                StringComparison.Ordinal));
+
+        string[] externalContentIncludes =
+        [
+            @"$(LegacyCutsSourceRoot)\**\*",
+            "@(LegacyPackagedResAsset)",
+            "@(LegacyFinancialPreviewAsset)",
+            "@(LegacyBrandAsset)"
+        ];
+        Assert.All(externalContentIncludes, include =>
+        {
+            var content = Assert.Single(
+                project.Descendants("Content"),
+                element => string.Equals(
+                    element.Attribute("Include")?.Value,
+                    include,
+                    StringComparison.Ordinal));
+            Assert.Contains(
+                "$(LegacyRuntimeAssetsEnabled)",
+                content.Attribute("Condition")?.Value,
+                StringComparison.Ordinal);
+        });
+
+        var databaseCopy = Assert.Single(
+            project.Descendants("Target"),
+            element => string.Equals(
+                element.Attribute("Name")?.Value,
+                "CopyLegacyDatabaseIniToLocalOutput",
+                StringComparison.Ordinal));
+        Assert.Contains(
+            "$(LegacyRuntimeAssetsEnabled)",
+            databaseCopy.Attribute("Condition")?.Value,
+            StringComparison.Ordinal);
+
+        var mainWindow = File.ReadAllText(Path.Combine(
+            RepositoryRoot,
+            "src",
+            "MBN_STOCK_WEBVIEW.LegacyParityApp",
+            "MainWindow.xaml.cs"));
+        Assert.Contains("#if SOURCE_ONLY_RUNTIME", mainWindow, StringComparison.Ordinal);
+        Assert.Contains(
+            "Source-only builds do not initialize a database runtime.",
+            mainWindow,
+            StringComparison.Ordinal);
+
+        var playout = File.ReadAllText(Path.Combine(
+            RepositoryRoot,
+            "src",
+            "MBN_STOCK_WEBVIEW.LegacyParityApp",
+            "MainWindow.Playout.cs"));
+        Assert.Contains("forceSafeDryRun: IsSourceOnlyBuild", playout,
+            StringComparison.Ordinal);
+    }
+
     [Fact]
     public void LegacyRuntimeSourceRootIsOverrideableAndValidatedBeforeBuild()
     {