Muonroi.Governance.Abstractions 1.0.0-alpha.16

Muonroi.Governance.Abstractions

OSS contracts for license governance: the interfaces, value types, and configuration models that all Muonroi license-aware components program against.

This package is contracts only — it ships no runtime behavior. It defines ILicenseGuard, LicenseState, LicenseTier, the policy interfaces, fingerprint abstractions, and the full LicenseConfigs options graph. Application code, middleware, and plugin authors reference this package to stay decoupled from the concrete implementation.

The runtime implementation lives in Muonroi.Governance (OSS) and enterprise extensions in Muonroi.Governance.Enterprise.

Installation

dotnet add package Muonroi.Governance.Abstractions --prerelease

In most scenarios you depend on Muonroi.Governance or Muonroi.Governance.Enterprise instead; those packages pull this one in transitively. Depend on this package directly only when writing a plugin, adapter, or middleware that must not couple to the implementation.

Quick Start

Consuming ILicenseGuard in a service

Inject ILicenseGuard (registered by Muonroi.Governance) and call its contract methods:

using Muonroi.Governance.License;

public class ReportService(ILicenseGuard licenseGuard)
{
    public byte[] GeneratePdf(ReportRequest request)
    {
        // Throws LicenseException when the feature is not available for the current tier.
        licenseGuard.EnsureFeature("pdf.export");

        // Gate arbitrary actions — logs or throws depending on FailMode config.
        licenseGuard.EnsureValid("report.generate", actionName: "GeneratePdf");

        return BuildPdf(request);
    }

    public bool CanUseMultiTenant() =>
        licenseGuard.HasFeature(FreeTierFeatures.Premium.MultiTenant);
}

Implementing ILicenseStore in a custom adapter

using Muonroi.Governance.License;

public sealed class DatabaseLicenseStore : ILicenseStore
{
    public LicensePayload? Load() { /* read from DB */ }
    public void Save(LicensePayload payload) { /* persist to DB */ }
    public ActivationProof? LoadActivationProof() { /* ... */ }
    public void SaveActivationProof(ActivationProof proof) { /* ... */ }
    public string? LoadActivationJwt() { /* ... */ }
    public void SaveActivationJwt(string jwt) { /* ... */ }
}

// Register the custom store in the DI container before AddMuonroiGovernance().
builder.Services.AddSingleton<ILicenseStore, DatabaseLicenseStore>();

Implementing ILicenseGuardEnhancer for custom enforcement

using Muonroi.Governance.License;
using Muonroi.Governance.Abstractions.License;

public sealed class AuditLicenseEnhancer : ILicenseGuardEnhancer
{
    public void OnStartup(LicenseConfigs configs, LicenseState state)
        => Console.WriteLine($"License tier: {state.TrustedTier}");

    public void OnEnsureValid(string actionType, LicenseState state)
        => Console.WriteLine($"Checking action: {actionType}");

    public void OnRecordAction(LicenseActionContext context, LicenseState state) { }
}

Features

• ILicenseGuard — tier query (Tier, IsFreeMode), feature gating (HasFeature, EnsureFeature), action validation (EnsureValid), chain recording (RecordAction, GetChainToken), and secure decryption (DecryptSecurely)
• LicenseState — immutable snapshot of validity, tier, expiry, features, and ActivationProof; HasFeature delegates to LicenseCapabilityResolver with backward-compatible key resolution
• FreeTierFeatures — well-known feature key constants for free-tier (db.query, http.request, …) and premium capabilities (multi-tenant, rule-engine, audit-trail, …)
• LicenseConfigs — complete options graph: mode (Offline/Online), fingerprint scope, fail mode, chain storage, anti-tampering, TPM anchoring, plus nested OnlineLicenseConfigs, MEnterpriseSecurityConfigs, and MComplianceConfigs
• ILicenseStore — load/save LicensePayload, ActivationProof, and activation JWT
• ILicenseFingerprintProvider / IFingerprintChainStore / IFingerprintSigner — device fingerprint and chain-signing contracts
• ILicenseGuardEnhancer — hook into startup, EnsureValid, and RecordAction without modifying the guard
• IMPolicyDecisionService — evaluate MPolicyDecisionRequest (user, tenant, permissions bitmask, claims) and receive MPolicyDecisionResult (allowed/denied/fallback with authoritative flag)
• IPolicyStore — load and save LicensePolicy (enforcement rules + per-feature quotas)
• IAssemblyHashCollector — assembly integrity fingerprint contract

Configuration

LicenseConfigs is bound from appsettings.json under the "LicenseConfigs" section by the implementation packages. Key properties:

{
  "LicenseConfigs": {
    "Mode": "Offline",
    "LicenseFilePath": "licenses/license.key",
    "PublicKeyPath": "licenses/public.pem",
    "FailMode": "Soft",
    "FingerprintScope": "ProjectOnly"
  }
}

API Reference

Samples

No dedicated sample exists for this package. See the implementation packages for runnable examples:

• Muonroi.Governance — OSS runtime; registers ILicenseGuard and default implementations
• Muonroi.Governance.Enterprise — enterprise runtime; anti-tampering, heartbeat, compliance export, TPM anchoring

Compatibility

• Target framework: net8.0
• License: Apache-2.0 (OSS)

Related Packages

• Muonroi.Governance — OSS runtime implementing the contracts in this package
• Muonroi.Governance.Enterprise — enterprise extension layer (anti-tampering, TPM, compliance, control-plane integration)
• Muonroi.Core.Abstractions — base exception types (MException) and core contracts
• Muonroi.Tenancy.Abstractions — tenant context contracts consumed by governance enforcement

License

Licensed under the Apache License, Version 2.0.