Fallout.Core 11.0.18

Prefix Reserved
.NET 10.0 This package targets .NET 10.0. The package is compatible with this framework or higher. .NET Standard 2.1 This package targets .NET Standard 2.1. The package is compatible with this framework or higher. 
dotnet add package Fallout.Core --version 11.0.18
                    


                    

                
NuGet\Install-Package Fallout.Core -Version 11.0.18
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="Fallout.Core" Version="11.0.18" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
<PackageVersion Include="Fallout.Core" Version="11.0.18" />
                    


                            Directory.Packages.props
                        

                    

                
<PackageReference Include="Fallout.Core" />
                    


                            Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package. 
paket add Fallout.Core --version 11.0.18
                    


                    

                
#r "nuget: Fallout.Core, 11.0.18"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
#:package Fallout.Core@11.0.18
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package. 
#addin nuget:?package=Fallout.Core&version=11.0.18
                    


                            Install as a Cake Addin
                        

                    

                
#tool nuget:?package=Fallout.Core&version=11.0.18
                    


                            Install as a Cake Tool

Fallout.Core

The reactor core. Pure domain physics — no I/O, no process, no console, no logging, no meltdown.

Fallout.Core is the bottom layer of Fallout. It holds the immutable domain shape of the build execution pipeline and the pure graph algorithms that schedule it:

  • ITargetModel — read-only projection of a build target (identity, status, dependency names). The stable surface that higher layers and the future plugin SDK read against.
  • ExecutionStatus — the lifecycle states of a target.
  • TopoSort / PlanResult<T> — a pure, side-effect-free topological sort with strongly-connected-component cycle detection. Takes nodes and an edge function in; returns an ordering and any cycles out. It never throws, never mutates its inputs, and never reads ambient state.

Invariants

Everything in this assembly is held to a strict purity bar, enforced by an architecture-fitness test:

  • No reference to any other Fallout project.
  • No dependency on System.IO, System.Diagnostics.Process, Console, or Serilog.
  • No statics holding mutable state.

If you need to touch the filesystem, spawn a process, write to the console, or log — that logic belongs in Fallout.Build or higher, not here. The orchestration that calls these algorithms (reading parameters, failing the build on a cycle, mutating target state) lives in Fallout.Build; the core only computes.

Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 was computed.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 was computed.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 is compatible.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
.NET Core netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.1 is compatible. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

  • .NETStandard 2.1

    • No dependencies.

  • net10.0

    • No dependencies.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
11.0.18 129 5/29/2026

### Breaking changes
• **Inlined vs-solutionpersistence parser • renamed Fallout.SolutionModel → Fallout.Solution; namespace Fallout.Common.ProjectModel → Fallout.Solutions*• (closes #248). The vendored Microsoft fork (vendor/vs-solutionpersistence/, submodule, fork-of-fork-of-Microsoft) is gone — sources inlined into a new Fallout.Persistence.Solution project under src/Persistence/. The facade was renamed and rehoused alongside it (src/Persistence/Fallout.Solution/), with the long-standing rebrand-era namespace mismatch (Fallout.Common.ProjectModel) fixed to match the assembly name (Fallout.Solutions, plural per BCL convention to avoid Fallout.Solution.Solution awkwardness).
 • **Package IDs**: Fallout.SolutionModel → Fallout.Solution, Fallout.VisualStudio.SolutionPersistence → Fallout.Persistence.Solution. Consumers that explicitly referenced either need to update their PackageReference/ProjectReference.
 • **Namespaces**: Fallout.Common.ProjectModel → Fallout.Solutions; Microsoft.VisualStudio.SolutionPersistence.{Model,Serializer,Utilities,...} → Fallout.Persistence.Solution.{Model,Serializer,Utilities,...}. Replace using statements accordingly. The Nuke.Common.ProjectModel.* transition-shim path is preserved (ShimMarker.cs now mirrors both Fallout.Common.* → Nuke.Common.* and Fallout.Solutions.* → Nuke.Common.ProjectModel.*), so NUKE-era consumer code using using Nuke.Common.ProjectModel; [Solution] readonly Solution Solution; keeps compiling.
 • **Onion layering**: this PR establishes src/Persistence/ as the layered home for persistence-ring code. Future persistence-related projects go under the same directory.
 • **Visibility narrowing deferred**: parser types remain public for this PR; the IVT decorations in Fallout.Persistence.Solution.csproj are future-intent. Per-type internal narrowing will follow in a later PR (cascading CS0050 analysis needed).
 • **Codefix follow-up**: Fallout.Migrate.Analyzers's Nuke→Fallout rewriter still produces Fallout.Common.ProjectModel.* rather than Fallout.Solutions.*. Tracked separately.
 • **Consumer-compat sentinel updated**: tests/Consumers/Fallout.Consumer.Local/ (added in the prior PR to detect exactly this kind of rename) had its ProjectReference path and using statement updated in this PR — that update IS the documented consumer migration recipe. Nuke.Consumer and Fallout.Consumer.NuGet (pinned to 11.0.8) were unaffected, confirming the shim coverage and prior-release stability hold.
• **AES-GCM v2 secret format for EncryptionUtility — parameters.json encrypted values*• (#214, closes #212). The secret-encryption scheme used by fallout :secrets is now AES-GCM with per-secret random salt • nonce and 600,000 PBKDF2-SHA256 iterations (OWASP 2023). Previous v1: (AES-CBC, static salt, 10,000 iterations, unauthenticated) values **continue to decrypt*• — the Decrypt path dispatches on v1:/v2:/unprefixed-legacy. New Encrypt calls always emit v2:.
 • **On-disk format**: v2:base64(salt[16] || nonce[12] || tag[16] || ciphertext). v1: was v1:base64(salt-as-iv || ciphertext) with a static Ivan Medvedev salt.
 • **Migration path**: existing .fallout/parameters.json files with v1: values stay readable. Re-running fallout :secrets to add or update **any*• secret naturally re-encrypts that entry under v2: (existing SaveSecrets flow already calls Encrypt per value). A whole-file rekey command can be added if there's demand.
 • **Mixed-version repos**: developers on Fallout < 11.0 pulling a parameters.json that contains v2: values from a teammate on 11.0• get Could not decrypt 'X' with provided password. Upgrade direction is fine (v1: reads keep working); downgrade is not.
 • **Rfc2898DeriveBytes constructor obsoletion (SYSLIB0060)*• cleared — both legacy and current paths now use the static Rfc2898DeriveBytes.Pbkdf2(...). No public-API impact; just stops the warning.
• **Fallout.GlobalTool package renamed to Fallout.Cli*• (#206). The dotnet-tool install command is now dotnet tool install -g Fallout.Cli. The CLI **command name stays fallout*• — no script or invocation changes needed.
 • **NuGet package ID changes**: Fallout.GlobalTool (frozen at 10.3.40, then unlisted) → Fallout.Cli (10.3.41 onward, then 11.0.x).
 • **Project / assembly / namespace rename**: src/Fallout.GlobalTool/ → src/Fallout.Cli/, tests/Fallout.GlobalTool.Tests/ → tests/Fallout.Cli.Tests/, namespace Fallout.GlobalTool[.*] → namespace Fallout.Cli[.*] across 48 files. Internal types only — no public-API consumer breakage from the namespace rename itself.
 • **Migration for consumers**: see [docs/migration/from-globaltool-to-cli.md](docs/migration/from-globaltool-to-cli.md). Short form: dotnet tool uninstall -g Fallout.GlobalTool && dotnet tool install -g Fallout.Cli, and in repos with a local manifest, edit .config/dotnet-tools.json to replace fallout.globaltool with fallout.cli.
 • **Update-notification text*• in UpdateNotificationAttribute already points at the new name, so existing Fallout.GlobalTool installs will prompt users toward Fallout.Cli on next run.
• **Thin bootstrappers • .config/dotnet-tools.json manifest; build.cmd dropped*• (#204, PR-B of #203). The per-repo build.cmd/build.sh/build.ps1 shape changes substantially — and the [GitHubActions] generator now emits a different workflow shape downstream consumers will see on the next regen.
 • **build.cmd is gone*• from the canonical scaffold. fallout :setup no longer emits it. New repos get only build.sh • build.ps1.
 • **build.sh / build.ps1 are ~60-line thin shims**: provision dotnet (kept verbatim from the pre-existing block), dotnet tool restore, exec dotnet fallout $@. The BUILD_PROJECT_FILE / BUILD_DIRECTORY config • explicit dotnet build • dotnet run --project lines are gone — Fallout.Cli's in-tool runner (added in #201) does that work now.
 • **.config/dotnet-tools.json*• is the new home of the pin. fallout :setup writes one with the tool pinned at the running CLI's own version. Skipped if one already exists (consumer may have other local tools pinned).
 • **[GitHubActions] generator*• (Fallout.Common/CI/GitHubActions/Configuration/GitHubActionsRunStep.cs): the single run: ./{BuildCmdPath} {targets} step is replaced with three steps — actions/setup-dotnet@v4 (reads global.json), dotnet tool restore, dotnet fallout {targets}. Downstream consumers using [GitHubActions(InvokedTargets = ...)] see the new shape on next workflow regen.
 • **BuildCmdPath property*• on GitHubActionsAttribute is no longer consumed (the run-step no longer references it). The Azure Pipelines / AppVeyor / TeamCity / SpaceAutomation generators still fall back to a literal build.cmd if BuildCmdPath is unset — keeps those legacy providers functional for the demand-driven revival (#8) without forcing this repo to keep a build.cmd.
 • **Migration**: existing repos can keep their fat bootstrappers and they'll work indefinitely (the bootstrapper does its own dotnet build • dotnet run --project, doesn't depend on the global tool). To adopt the new shape, re-run fallout :setup --force (or hand-edit the shims to match the new template).
• **Last-mile Newtonsoft removal — closes the #83 migration tree*• (#119 STJ-6, #115 STJ-2 tail). Every Fallout source file is STJ-native; Newtonsoft.Json.dll survives in the closure only as a transitive of NuGet.Packaging and Serilog.Formatting.Compact.Reader. The Newtonsoft.Json PackageVersion is gone from Directory.Packages.props entirely.
 • **GitHubActions.GitHubEvent is now JsonObject*• (was Newtonsoft JObject). Consumers that introspect the event payload need to swap using Newtonsoft.Json.Linq → using System.Text.Json.Nodes and update accessors ([key].Value<T>() → [key].GetValue<T>(), Property(name) → indexer, etc.).
 • **Fallout.Utilities.Net HttpRequestExtensions.WithJsonContent / HttpResponseExtensions.GetBodyAsJson defaults are STJ.*• The [Obsolete]-marked Newtonsoft overloads (JsonSerializerSettings parameter, JObject return) are gone. JsonSerializerOptions overloads remain for explicit configuration; the parameterless default uses STJ with default options. GetBodyAsJsonObject returns System.Text.Json.Nodes.JsonObject.
 • **SlackMessageActionButton.Type / TeamsMessage.Type / TeamsMessage.Context**: hand-written [JsonProperty(...)] attributes swapped to [JsonPropertyName(...)]. Consumer impact only if you subclass these types and added [JsonProperty]-style attributes — switch to [JsonPropertyName].
 • **TwitterTasks**: internal error-parsing path swapped from JObject.Parse to JsonNode.Parse. No public-API change.
 • **ArgumentsFromParametersFileAttribute*• (#115 STJ-2 tail): parameters.json reading swapped from JObject to JsonObject. Behaviour identical for valid input; STJ may be slightly stricter about malformed JSON.
• **SchemaUtility rewritten on System.Text.Json — NJsonSchema gone*• (#114, STJ-1 of #83). The build-parameter schema generator (which emits .fallout/build.schema.json for editor autocomplete) no longer goes through NJsonSchema. It now hand-rolls the draft-04 schema using JsonNode/JsonObject directly — same output shape, no Rico-entanglement.
 • **Dropped packages**: NJsonSchema, NJsonSchema.NewtonsoftJson, NJsonSchema.Annotations, Namotion.Reflection — four packages and ~12 transitive dependencies gone from Fallout.Build. Newtonsoft.Json stays in the closure only via Fallout.Common's *Tasks.cs (Slack/Twitter/Teams) until #119 lands.
 • **API**: SchemaUtility.GetJsonString(IFalloutBuild) and GetJsonDocument(IFalloutBuild) unchanged for consumers.
 • **Behavior preserved**: well-known definitions in canonical order (Host, ExecutableTarget, Verbosity, FalloutBuild), allOf:[user, base] envelope, [CustomParameter] subclasses render as plain string (not recursive), value-type Nullable<T> → [T, null], reference-type nullables → [null, T] for primitives / oneOf [null, $ref] for refs, [TypeConverter]-attributed types (AbsolutePath, Solution, etc.) render as string.
• **Fallout.Tooling engine migrated to System.Text.Json*• (#117 STJ-4, #118 STJ-5). The tool-options ↔ JSON layer that powers every tool wrapper is now STJ-native:
 • Options.InternalOptions is now System.Text.Json.Nodes.JsonObject (was Newtonsoft JObject). Options.JsonSerializer and Options.JsonSerializerSettings are gone — use Options.SerializerOptions (JsonSerializerOptions) instead.
 • The Options→InternalOptions converter is now a JsonConverterFactory registered on SerializerOptions.Converters (STJ doesn't inherit class-level [JsonConverter] attributes onto subclasses). LookupTable<,> round-trips through a parallel ObjectFromFieldConverter factory; Enumeration subclasses go through a new EnumerationJsonConverterFactory that bridges [TypeConverter]-attributed types (which STJ doesn't honour natively).
 • All 62 generated tool wrappers regenerated with [JsonPropertyName] instead of [JsonProperty] (#118). The generator's own JSON model (Fallout.Tooling.Generator) is migrated too — Tool / Property / DataClass / Enumeration / Task use [JsonRequired] / [JsonPropertyName] / [JsonIgnore] from System.Text.Json.Serialization.
 • IReadOnlyDictionary<string, object> round-trips deserialize values as JsonElement (not string as Newtonsoft did); DelegateHelper.ParseCollection coerces both shapes back to string.
 • **Newtonsoft.Json PackageReference removed*• from Fallout.Tooling, Fallout.Tooling.Generator, and Fallout.Utilities.Text.Json. Object.ToJObject deleted (closes the residual #116 tail). Fallout.Common still references Newtonsoft for *Tasks.cs files until #119 (STJ-6) lands.
 • Migration for consumers: replace Options.JsonSerializerSettings → Options.SerializerOptions; replace obj.ToJObject(serializer) → JsonSerializer.SerializeToNode(obj, Options.SerializerOptions).AsObject(); tool wrappers using hand-written [JsonProperty] (e.g. SlackMessage.Type) need to switch to [JsonPropertyName].
• **Fallout.Utilities.Text.Json Newtonsoft surface removed*• (#116, STJ-3 of #83). The [Obsolete]-marked Newtonsoft.Json overloads added in 10.3.x are gone:
 • **Deleted types:*• JObjectExtensions (GetChildren/GetPropertyValue/GetPropertyStringValue/GetPropertyValueOrNull on JObject), AllWritableContractResolver, Base64JsonConverter<T>, Object.ToJObject.
 • **JsonExtensions stripped to System.Text.Json only**: DefaultSerializerSettings removed (use DefaultSerializerOptions); the JsonSerializerSettings-taking overloads of ToJson / GetJson / ReadJson / WriteJson / UpdateJson and the JObject-returning GetJson/ReadJson/UpdateJson(Action<JObject>) are gone. Equivalent STJ surface: same method names taking JsonSerializerOptions (now defaulted to DefaultSerializerOptions when omitted), plus GetJsonObject / ReadJsonObject / UpdateJsonObject(Action<JsonObject>) for JsonNode-based access.
 • **Migration**: replace obj.ToJson(settings) with obj.ToJson(JsonExtensions.DefaultSerializerOptions) (or pass your own JsonSerializerOptions); replace content.GetJson<JObject>() with content.GetJsonObject(); replace JObject.GetPropertyValue<T>(name) with JsonObject.GetPropertyValue<T>(name) (same method name, different receiver type via using System.Text.Json.Nodes).
• **Fixed Fallout.SolutionModel 10.2.24–10.2.34 unrestorable*• (#107): the vendored SolutionPersistence wrapper was IsPackable=false, so dotnet pack fell back to emitting the dependency under the *assembly• name (Microsoft.VisualStudio.SolutionPersistence) at the Fallout version — which doesn't exist on nuget.org. Wrapper now packs as Fallout.VisualStudio.SolutionPersistence (PackageId set explicitly; AssemblyName preserved for drop-in type identity), so Fallout.SolutionModel.nuspec declares the correct transitive dep. Also affected Fallout.Common, Fallout.Build, Fallout.ProjectModel, Fallout.Components — all fixed.
• **--skip-duplicate on the publish push*• (#108): release.yml's IPublish.PushSettings now enables skip-duplicate, so a partial publish failure (e.g. one package's API key permission gap) no longer makes reruns error on the already-uploaded versions. Pipeline is idempotent.
• **Fixed build.ps1 bootstrap on PowerShell 7.5+*• (#15): the script now uses Join-Path for SDK resolution so newer PowerShell's stricter path handling doesn't break the launcher.
• **Fixed solution folder names starting with digits*• (#16): StronglyTypedSolutionGenerator prefixes a leading underscore when the folder name would produce an invalid C# identifier.
• **Retired GitVersion.Tool*• (#81) — version is now sourced exclusively from Nerdbank.GitVersioning via version.json. MajorMinorPatchVersion and friends in Build.cs read NB.GV's $(Version) MSBuild output.
• **Trimmed unused / replaceable dependencies*• (#75, #78, #79, #80, #82): dropped JetBrains.ReSharper.GlobalTools, the matkoch Spectre.Console fork (swapped for upstream Spectre.Console), Microsoft.ApplicationInsights, Codecov.Tool, and xunit.runner.console. See docs/dependencies.md for the current graph.
• **Bumped Scriban 7.1.0 → 7.2.0*• (#84) to clear NU1903.
• **Fixed [GitHubActions] CheckoutRef breaking cross-repo / fork PRs**. The generator emitted ref: ${{ github.head_ref }} but didn't set repository:, so the default ${{ github.repository }} was used. For PRs from a fork, the source branch only exists on the fork; checkout tried to resolve it on origin and failed with branch or tag could not be found (regressed in #175). Generator now also emits repository: ${{ github.event.pull_request.head.repo.full_name || github.repository }} whenever CheckoutRef is set — works for fork PRs, same-repo PRs, AND push events (the || fallback). Regenerate via any dotnet fallout <target> to pick up the fix.
• **Fixed fallout-migrate producing unrestorable _build.csproj*• (closes #217). The Nuke → Fallout namespace rewrite carried the original NUKE Version=10.1.0 pins onto Fallout.* packages — but Fallout.* was never published at 10.1.0, so NuGet hit NU1603 (not found, falling back to next-higher) and WarningsAsErrors in the migrated project escalated to fatal. Migrate now bumps inline Version=... attributes on Nuke → Fallout PackageReferences to the running migrate tool's own version in the same regex pass, and strips the stale System.Security.Cryptography.Xml <PackageReference> (NUKE-era projects often pinned an older major that conflicts with Fallout.Common's transitive ≥ 10.0.6 — NU1605 downgrade). CPM-managed references (no inline Version) keep namespace-only rewrite — version stays in Directory.Packages.props.
### Added
• **Extracted Fallout.Core — the pure domain • graph foundation*• (#88, v11 plugin-architecture foundation). New bottom-layer project (netstandard2.1;net10.0) holding the side-effect-free types of the build execution pipeline: ITargetModel (read-only target projection — the seed for the v12 plugin SDK), ExecutionStatus, and TopoSort / PlanResult<T> (pure topological sort • strongly-connected-component cycle detection). Fallout.Core references nothing else in the repo and is held to a strict purity bar — no System.IO, Process, Console, or Serilog — enforced by a NetArchTest architecture-fitness test (broader suite tracked in #95).
 • **Fully backward-compatible.*• ExecutionStatus moved assemblies (Fallout.Build → Fallout.Core) but is [TypeForwardedTo], and namespaces are unchanged, so existing consumer using Fallout.Common.Execution; code compiles untouched. The live ExecutableTarget stays in Fallout.Build and now implements ITargetModel; ExecutionPlanner is reduced to a thin orchestration wrapper over Fallout.Core's pure TopoSort (it still owns reading the strict parameter, failing the build on a cycle, and mutating target state).
 • The graph primitives (Vertex / StronglyConnectedComponent*) moved from Fallout.Utilities into Fallout.Core as an internal implementation detail of TopoSort; they had no external consumers.
### Process
• **Added Default to backwards compatibility rule to the AGENTS.md AI brief*• (#262). Critical rules now state the principle explicitly — prefer additive over breaking changes; [Obsolete], transition shims, and overload-based extension before a hard break. The existing breaking-change PR-creation flow (label • ⚠️ callout • version.json bump • CHANGELOG entry with migration path) remains the mechanics for when a break is unavoidable. Issue [#262](https://github.com/ChrisonSimtian/Fallout/issues/262) stays open for the broader policy discussion (LTS stance for the Nuke.* shims, what qualifies as backwards compatible for on-disk formats and CI workflow generators, when transition-shim generators are the right answer, etc.).

Full changelog at https://github.com/ChrisonSimtian/Fallout/blob/main/CHANGELOG.md