Cratis.Arc.ProxyGenerator.Build 22.4.0

Prefix Reserved

dotnet add package Cratis.Arc.ProxyGenerator.Build --version 22.4.0

NuGet\Install-Package Cratis.Arc.ProxyGenerator.Build -Version 22.4.0

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="Cratis.Arc.ProxyGenerator.Build" Version="22.4.0" />

For projects that support PackageReference, copy this XML node into the project file to reference the package.

<PackageVersion Include="Cratis.Arc.ProxyGenerator.Build" Version="22.4.0" />
                    

                            Directory.Packages.props

<PackageReference Include="Cratis.Arc.ProxyGenerator.Build" />
                    

                            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 Cratis.Arc.ProxyGenerator.Build --version 22.4.0

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

#r "nuget: Cratis.Arc.ProxyGenerator.Build, 22.4.0"

#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 Cratis.Arc.ProxyGenerator.Build@22.4.0

#: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=Cratis.Arc.ProxyGenerator.Build&version=22.4.0
                    

                            Install as a Cake Addin

#tool nuget:?package=Cratis.Arc.ProxyGenerator.Build&version=22.4.0
                    

                            Install as a Cake Tool

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

Cratis Arc

Arc is an opinionated CQRS application framework for ASP.NET Core with commands, queries, validation, authorization, and TypeScript proxy generation.

Arc hosts application behavior, executes command and query pipelines, exposes recognized contracts over HTTP, and generates TypeScript clients for them. Its packages also cover observable queries, validation, identity and tenancy, React integration, current-state persistence, OpenAPI, analyzers, and testing. Chronicle event sourcing and Cratis Components are optional integrations.

Start here

Browse the Arc documentation
Choose a documented application path
Understand Arc's independent boundary
Start an Arc host
Inspect packages and repository layout

What Arc owns

Boundary	Arc provides
Hosting	ASP.NET Core hosting plus an Arc.Core HTTP host for workers, consoles, and custom services
Commands	Model-bound and controller-based execution, validation, authorization, filters, scopes, typed results, and generated endpoints
Queries	Model-bound and controller-based reads, paging and sorting, observable updates, WebSocket or Server-Sent Events transport, and query diagnostics
Validation	Data annotations, FluentValidation, concept/command/query validators, generated client rules, and optional server preflight from React forms
Identity and tenancy	Pluggable authentication, identity details, role-based authorization, and header, query, claim, subdomain, fixed, or development tenant resolution
Generated contracts	TypeScript proxies, referenced types, validation metadata, identity details, incremental output cleanup, and package/type mapping
Frontend packages	TypeScript command/query runtimes, React hooks and forms, dialogs, observable-query composition, and optional React/MVVM integration
Persistence integration	MongoDB and Entity Framework Core current-state adapters plus optional Chronicle-backed event-sourced behavior
Evaluation and tooling	OpenAPI, runtime introspection, analyzers, source generators, command scenarios, proxy-generation checks, Vite helpers, and ESLint rules

Each row is a documented capability area, not a promise of compatibility with every package, host, provider, browser, or product version.

Choose a path

Arc documentation is organized around the job you need to complete:

Execute commands — model-bound or controller-based changes, pipelines, validation, authorization, filters, and response handling.
Expose queries and observable results — request/response reads, paging, sorting, streaming updates, diagnostics, and generated clients.
Build the frontend — TypeScript runtimes, React hooks and forms, dialogs, identity, messaging, and optional MVVM packages.
Configure identity and access — authentication, identity details, authorization, roles, and frontend visibility boundaries.
Resolve tenants — request resolvers, scoped tenant context, and provider-specific database or namespace mapping.
Use current-state persistence — application services, MongoDB, or Entity Framework Core without requiring an event log.
Add Chronicle event sourcing — events, projections, reducers, aggregates, reactors, concurrency, and Chronicle-specific testing.
Inspect and verify the application boundary — introspection, OpenAPI, analyzers, generated metadata, and command scenarios.

The canonical Arc page remains the front door; product-owned documentation and source carry the detail.

Arc does not require event sourcing

Arc.Core does not depend on Chronicle. Commands and queries can use current-state persistence or application services without an event log. Choose the persistence and integrations that fit each application boundary.

The Chronicle integration is optional and supplies event-sourced behavior when configured. Arc retains its command, query, validation, authorization, and generated-contract boundary.

Relationship to Components

Components is a React component library aligned with Arc application patterns. See the Components documentation for its packages and setup.

Applications may use Arc without Components and remain responsible for their own frontend, accessibility, browser, and design-system verification.

Start an Arc host

Arc's .NET packages embed this product-family README. The example below uses the umbrella Cratis.Arc package to start an Arc host; when viewing this README from a specialized package page, use that package's manifest and reference documentation for its own installation scope.

Use the .NET SDK declared by Arc's current global.json. Install the host package:

dotnet add package Cratis.Arc

Create and run an Arc host:

using Cratis.Arc;

var builder = ArcApplication.CreateBuilder(args);
builder.AddCratisArc();

var app = builder.Build();
app.UseCratisArc();
await app.RunAsync();

Starting the host confirms the basic Arc setup. Continue with the Arc documentation, and use GitHub Issues when the observed behavior does not match the documentation.

Packages and repository layout

Surface	Role
`Cratis.Arc` / `Cratis.Arc.Core`	.NET hosting, command/query pipelines, validation, identity, tenancy, HTTP, introspection, and application conventions
`Cratis.Arc.ProxyGenerator.Build`	Build-time TypeScript proxy generation for recognized application artifacts
`Cratis.Arc.MongoDB` / `Cratis.Arc.EntityFrameworkCore*`	Optional current-state persistence and observation adapters
`Cratis.Arc.Chronicle`	Optional event-sourced command, projection, reducer, aggregate, reactor, tenancy, and compliance integration
`Cratis.Arc.OpenApi` / `Cratis.Arc.Swagger`	Optional OpenAPI document transformation for Arc concepts and endpoints
`Cratis.Arc.Testing` / `Cratis.Arc.Chronicle.Testing`	Command-scenario and optional Chronicle event/read-model testing helpers
`@cratis/arc`	TypeScript command, query, validation, identity, and messaging runtime used by generated proxies
`@cratis/arc.react`	React hooks, forms, dialogs, identity, messaging, and query composition for Arc contracts
`@cratis/arc.react.mvvm`	Optional React/MVVM and dependency-injection integration
`@cratis/arc.vite` / `@cratis/eslint-plugin-arc`	Vite metadata/query helpers and Arc-specific frontend lint rules
`Source/DotNET`	.NET framework source
`Source/JavaScript`	TypeScript and React package source
`Documentation`	Product-owned documentation rendered on cratis.io
`TestApps`	Sample and integration applications used by repository checks

Package existence does not imply compatibility with every frontend, runtime, persistence provider, or product version. Check the package manifests and documentation for the versions you use.

Documentation map

Contributing

Arc is a framework-library repository. Changes to public APIs, analyzers, generated output, and package shapes can affect consumers and require the owning repository's compatibility and release review.

Repository development currently requires the SDK and toolchain versions declared by global.json and package.json. Follow the Cratis contribution guide and the framework instructions before changing public surfaces.

Before submitting documentation-only work, verify its links, anchors, and examples explicitly; current automated documentation checks are path-scoped. Source changes must pass the owning repository's applicable build, specification, TypeScript, and documentation gates.

Community and repository

Path	Destination
Questions and discussion	Cratis Discord
Bugs and feature requests	GitHub Issues
Releases	GitHub Releases
Documentation	www.cratis.io/arc
Security reports	Private security reporting
License	`LICENSE`

There are no supported framework assets in this package.

Learn more about Target Frameworks and .NET Standard.

net10.0
- handlebars.net (>= 2.1.6)
- Microsoft.Build.Framework (>= 18.8.2)
- Microsoft.Build.Utilities.Core (>= 18.8.2)
- Microsoft.Extensions.DependencyModel (>= 10.0.11)
- Microsoft.NET.StringTools (>= 18.8.2)
- System.Reflection.MetadataLoadContext (>= 10.0.10)
net8.0
- handlebars.net (>= 2.1.6)
- Microsoft.Build.Framework (>= 17.14.28)
- Microsoft.Build.Utilities.Core (>= 17.14.28)
- Microsoft.Extensions.DependencyModel (>= 9.0.18)
- Microsoft.NET.StringTools (>= 18.8.2)
- System.Collections.Immutable (>= 10.0.10)
- System.Reflection.MetadataLoadContext (>= 9.0.18)
- System.Text.Json (>= 9.0.18)
net9.0
- handlebars.net (>= 2.1.6)
- Microsoft.Build.Framework (>= 17.14.28)
- Microsoft.Build.Utilities.Core (>= 17.14.28)
- Microsoft.Extensions.DependencyModel (>= 9.0.18)
- Microsoft.NET.StringTools (>= 18.8.2)
- System.Collections.Immutable (>= 10.0.10)
- System.Reflection.MetadataLoadContext (>= 9.0.18)
- System.Text.Json (>= 9.0.18)

NuGet packages (2)

Showing the top 2 NuGet packages that depend on Cratis.Arc.ProxyGenerator.Build:

Package	Downloads
Cratis Simplified setup for Cratis Arc applications with Chronicle event sourcing and MongoDB storage	112.0K
Cratis.Chronicle.Api Package Description	82.1K

GitHub repositories

This package is not used by any popular GitHub repositories.

Version	Downloads	Last Updated
22.4.0	0	8/27/2026
22.3.0	251	8/25/2026
22.2.0	95	8/25/2026
22.1.1	190	8/25/2026
22.1.0	390	8/23/2026
22.0.2	125	8/22/2026
22.0.1	151	8/22/2026
22.0.0	156	8/21/2026
21.19.4	170	8/20/2026
21.19.3	983	8/19/2026
21.19.2	265	8/18/2026
21.19.1	202	8/18/2026
21.19.0	1,134	8/16/2026
21.18.0	109	8/16/2026
21.17.1	107	8/16/2026
21.17.0	193	8/15/2026
21.16.0	109	8/15/2026
21.15.0	173	8/14/2026
21.14.3	660	8/14/2026
21.14.2	325	8/13/2026