using Aletheia.Sdk.Sample;
using Aletheia.Sdk.Aspects.DependencyInjection;
using Aletheia.Sdk.Capability.Messaging.DependencyInjection;
using Aletheia.Sdk.Web.DependencyInjection;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
 
var app = builder.Build();
 
app.Run();

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Inbound command: ask the library to greet a visitor by name.
/// </summary>
public sealed record GreetCommand(string Name);
 
/// <summary>
/// Our library's greeting — the first capability everyone encounters.
/// </summary>
public sealed record GreetResponse(string Message);
 
[Capability("sample.greet")]
public sealed class GreetHandler : ICapabilityHandler<GreetCommand, GreetResponse>
{
    public ValueTask<ExecutionResult<GreetResponse>> HandleAsync(
        GreetCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(command.Name))
        {
            // Gracefully handle execution errors
            return ValueTask.FromResult<ExecutionResult<GreetResponse>>(
                new ExecutionResult<GreetResponse>.Fail(
                    new ExecutionError("EMPTY_NAME", "A name is required to enter the Library.")));
        }
 
        // Return successful execution result
        var message = $"Welcome to the Library, {command.Name}. I am the keeper of all manuscripts.";
        return ValueTask.FromResult<ExecutionResult<GreetResponse>>(
            new ExecutionResult<GreetResponse>.Ok(new GreetResponse(message)));
    }
}

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Inbound command: choose an error mode to trigger.
/// </summary>
public sealed record ErrorDemoCommand(string Mode);
 
/// <summary>
/// Response when no error is triggered — the normal path.
/// </summary>
public sealed record ErrorDemoResponse(string Message);
 
/// <summary>
/// Demonstrates that all domain errors return 422 — the code field distinguishes them.
/// Mode "empty-name" → EMPTY_NAME, "missing" → NOT_FOUND, "conflict" → CONFLICT.
/// Mode "success" → 200 (normal response, proving errors are the exception path).
/// </summary>
[Capability("sample.error-demo")]
public sealed class ErrorDemoHandler : ICapabilityHandler<ErrorDemoCommand, ErrorDemoResponse>
{
    public ValueTask<ExecutionResult<ErrorDemoResponse>> HandleAsync(
        ErrorDemoCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        return command.Mode switch
        {
            "empty-name" => ValueTask.FromResult<ExecutionResult<ErrorDemoResponse>>(
                new ExecutionResult<ErrorDemoResponse>.Fail(
                    new ExecutionError("EMPTY_NAME", "A name is required to enter the Library."))),
 
            "missing" => ValueTask.FromResult<ExecutionResult<ErrorDemoResponse>>(
                new ExecutionResult<ErrorDemoResponse>.Fail(
                    new ExecutionError("NOT_FOUND", "The requested manuscript does not exist in the archives."))),
 
            "conflict" => ValueTask.FromResult<ExecutionResult<ErrorDemoResponse>>(
                new ExecutionResult<ErrorDemoResponse>.Fail(
                    new ExecutionError("CONFLICT", "Another scribe has already modified this manuscript."))),
 
            _ => ValueTask.FromResult<ExecutionResult<ErrorDemoResponse>>(
                new ExecutionResult<ErrorDemoResponse>.Ok(
                    new ErrorDemoResponse("No errors — the capability executed successfully."))),
        };
    }
}

using Aletheia.Sdk.Capability.Messaging.DependencyInjection;
using Aletheia.Sdk.Web.DependencyInjection;
 
using Aletheia.Sdk.Capability.DependencyInjection;
using Aletheia.Sdk.Capability.Http;
using Aletheia.Sdk.Capability.Http.DependencyInjection;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
 
builder.Services.AddCapabilityHandlersFromAssemblyContaining<GreetHandler>();
builder.Services.AddCapabilityHttp();
 
var app = builder.Build();
 
app.MapCapabilities();
 
app.Run();

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Sample entity used to demonstrate the full Aletheia platform stack with
/// <strong>every supported scalar CLR type</strong> and its nullable variant:
/// <c>string</c>, <c>bool</c>, <c>int</c>, <c>long</c>, <c>float</c>,
/// <c>double</c>, <c>decimal</c>, <c>DateOnly</c>, <c>DateTimeOffset</c>,
/// <c>Guid</c>, <c>Uri</c> — non-nullable and nullable — plus a
/// <c>List&lt;string&gt;</c> collection to demonstrate list support.
/// <br/>
/// Uses <c>[OperationEndpoints]</c> + <c>MapOperations()</c> to expose five REST
/// endpoints under <c>api/entities/data-records</c> (POST, GET, PUT, DELETE).
/// </summary>
[Entity(Path = "data-records")]
[Identity(IdentityGenerator.Random)]
[OperationEndpoints]
public partial class DataRecord
{
    // ── Non-nullable scalars ─────────────────────────────────────────────────
 
    [Predicate("label")]
    public string Label { get; set; } = string.Empty;
 
    [Predicate("active")]
    public bool Active { get; set; }
 
    [Predicate("count")]
    public int Count { get; set; }
 
    [Predicate("serial")]
    public long Serial { get; set; }
 
    [Predicate("ratio")]
    public float Ratio { get; set; }
 
    [Predicate("score")]
    public double Score { get; set; }
 
    [Predicate("amount")]
    public decimal Amount { get; set; }
 
    [Predicate("effectiveDate")]
    public DateOnly EffectiveDate { get; set; }
 
    [Predicate("timestamp")]
    public DateTimeOffset Timestamp { get; set; }
 
    [Predicate("correlationId")]
    public Guid CorrelationId { get; set; }
 
    [Predicate("reference")]
    public Uri Reference { get; set; } = new Uri("https://www.aletheia.arkenforge.de/");
 
    // ── Nullable variants ────────────────────────────────────────────────────
 
    [Predicate("notes")]
    public string? Notes { get; set; }
 
    [Predicate("flagged")]
    public bool? Flagged { get; set; }
 
    [Predicate("limit")]
    public int? Limit { get; set; }
 
    [Predicate("sequence")]
    public long? Sequence { get; set; }
 
    [Predicate("factor")]
    public float? Factor { get; set; }
 
    [Predicate("precision")]
    public double? Precision { get; set; }
 
    [Predicate("fee")]
    public decimal? Fee { get; set; }
 
    [Predicate("expiresOn")]
    public DateOnly? ExpiresOn { get; set; }
 
    [Predicate("archivedAt")]
    public DateTimeOffset? ArchivedAt { get; set; }
 
    [Predicate("alternateId")]
    public Guid? AlternateId { get; set; }
 
    [Predicate("canonicalUri")]
    public Uri? CanonicalUri { get; set; }
}

using Aletheia.Sdk.Capability.Http;
using Aletheia.Sdk.Capability.Http.DependencyInjection;
 
using Aletheia.Sdk.Operations.Http;
using Aletheia.Sdk.Operations.Http.DependencyInjection;
using Aletheia.Sdk.Repository.DependencyInjection;
using Aletheia.Sdk.Repository.InMemory.DependencyInjection;
using Aletheia.Sdk.Repository.GraphDb.DependencyInjection;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
// ...
builder.Services.AddCapabilityHandlersFromAssemblyContaining<GreetHandler>();
builder.Services.AddCapabilityHttp();
 
var repoBuilder = builder.Services.AddEntityRepository(builder.Configuration);
if (string.Equals(builder.Configuration["EntityRepository:Backend"], "GraphDb", StringComparison.OrdinalIgnoreCase))
    repoBuilder.UseGraphDb();
else
    repoBuilder.UseInMemory();
builder.Services.AddOperationEndpointsHttpFromAssemblyContaining<DataRecord>();
 
var app = builder.Build();
 
app.MapCapabilities();
 
app.MapOperations();
 
app.Run();

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Entity.Contracts;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A Scribe — a person who writes Manuscripts.
/// Demonstrates EntityRefCollection: one Scribe writes many Manuscripts.
/// </summary>
[Entity(Path = "scribes")]
[Identity(IdentityGenerator.Random)]
[OperationEndpoints]
public partial class Scribe
{
    [Predicate("name")]
    public string Name { get; set; } = string.Empty;
 
    [Predicate("title")]
    public string Title { get; set; } = string.Empty;
 
    // An inverse relationship to the Scribe entity.
    // It automatically is populated with the Manuscripts that reference this Scribe in their Scribes collection.
    [Inverse(nameof(Manuscript.WrittenBy), "writtenBy")]
    public partial EntityRefCollection<Manuscript> Wrote { get; }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Entity.Contracts;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A Manuscript — the central entity of the Aletheia Study.
/// Represents a scroll entering the Great Library. Every new contributor
/// should start here to understand the Entity slice.
/// </summary>
[Entity(Path = "manuscripts")]
[Identity(IdentityGenerator.Random)]
[OperationEndpoints]
public partial class Manuscript
{
    [Required]
    [Predicate("title")]
    public string Title { get; set; } = string.Empty;
 
    [Predicate("author")]
    public string Author { get; set; } = string.Empty;
 
    [Owning("genre")]
    public partial EntityRef<Genre>? Genre { get; set; }
 
    [Predicate("shelf")]
    public string Shelf { get; set; } = string.Empty;
 
    [Predicate("year")]
    public int Year { get; set; }
 
    [Predicate("isSealed")]
    public bool IsSealed { get; set; }
 
    // A relationship to the Scribe entity.
    // Due to the relation direction, a Manuscript cannot exist without a relationship to Scribes (someone has to write the manuscript).
    // However, a Scribe can exist without a relationship to Manuscripts (maybe they haven't written anything yet).
    [Owning("writtenBy")]
    public partial EntityRefCollection<Scribe> WrittenBy { get; }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A Genre — a fixed category of manuscripts. Demonstrates the [Enumeration] pattern:
/// sealed entity with public static readonly instances (SKOS-like named individuals).
/// The IRI is deterministic from the Key property via PropertyBasedPlain identity.
/// </summary>
[Entity(Path = "genres", PredicatePath = "genre")]
[Identity(IdentityGenerator.PropertyBasedPlain)]
[Enumeration]
[OperationEndpoints]
public partial class Genre
{
    [IdentityPart(0)]
    [Predicate("key")]
    public partial string Key { get; init; }
 
    [Predicate("displayName")]
    public string DisplayName { get; set; } = string.Empty;
 
    public static readonly Genre Philosophy = new() { Key = "philosophy", DisplayName = "Philosophy" };
    public static readonly Genre History     = new() { Key = "history", DisplayName = "History" };
    public static readonly Genre Poetry      = new() { Key = "poetry", DisplayName = "Poetry" };
    public static readonly Genre Science     = new() { Key = "science", DisplayName = "Science" };
    public static readonly Genre Magic       = new() { Key = "magic", DisplayName = "Magic" };
 
    /// <summary>All five named genre individuals in declaration order.</summary>
    public static IReadOnlyList<Genre> All { get; } = [Philosophy, History, Poetry, Science, Magic];
 
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A Catalog Entry — demonstrates PropertyBasedPlain identity: the IRI is built
/// from Author + Title, producing human-readable, collision-safe identifiers
/// like /catalog-entries/plato-the-republic.
/// </summary>
[Entity(Path = "catalog-entries", PredicatePath = "catalogEntry")]
[Identity(IdentityGenerator.PropertyBasedPlain)]
[OperationEndpoints]
public partial class CatalogEntry
{
    [IdentityPart(0)]
    [Predicate("author")]
    public partial string Author { get; init; }
 
    [IdentityPart(1)]
    [Predicate("title")]
    public partial string Title { get; init; }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A MagicalScribe — a Scribe who wields arcane power.
/// Inherits every property, endpoint, and the identity strategy from <see cref="Scribe"/>.
/// Adds only <c>Mana</c> — their reserve of magical energy.
/// </summary>
/// <remarks>
/// The derived type must not set <c>Path</c> or <c>[Identity]</c> on <c>[Entity]</c> —
/// the base type owns both. <c>[Entity(PredicatePath = "magical-scribe")]</c> scopes
/// the new predicate under the inherited path, and
/// <c>[OperationEndpoints("magical-scribes")]</c> gives it dedicated CRUD routes.
/// <br/>
/// Because a MagicalScribe <em>is</em> a Scribe at the RDF level (multi-type projection),
/// a <c>GET api/entities/scribes</c> list also returns magical-scribe instances.
/// </remarks>
[Entity(PredicatePath = "magical-scribe")]
[OperationEndpoints("magical-scribes")]
public partial class MagicalScribe : Scribe
{
    /// <summary>Reserve of magical energy — the one thing that sets them apart.</summary>
    [Predicate("mana")]
    public int Mana { get; set; }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A DeterministicRecord — same scalar shape as DataRecord, but uses
/// <see cref="IdentityGenerator.PropertyBasedEncoded"/> for deterministic GUIDv5 IRIs.
/// The IRI is a hash of the <c>Key</c> property under a namespace GUID,
/// so the same key always produces the same IRI — but the IRI reveals nothing
/// about the key value.
/// <br/>
/// Compare with <see cref="DataRecord"/> (Random UUIDv4) and
/// <see cref="Genre"/> (PropertyBasedPlain, human-readable IRI).
/// Together they demonstrate all three identity strategies.
/// </summary>
[Entity(Path = "deterministic-records")]
[Identity(IdentityGenerator.PropertyBasedEncoded)]
[OperationEndpoints]
public partial class DeterministicRecord
{
    /// <summary>
    /// The identity part — hashed into the GUIDv5 IRI.
    /// Same key → same IRI every time. Different key → different IRI.
    /// </summary>
    [IdentityPart(0)]
    [Predicate("key")]
    public partial string Key { get; init; }
 
    [Predicate("label")]
    public string Label { get; set; } = string.Empty;
 
    [Predicate("count")]
    public int Count { get; set; }
 
    [Predicate("active")]
    public bool Active { get; set; }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Entity.Contracts;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A Wing — a section of the Library, curated by a Scribe.
/// Demonstrates laziness of EntityRef (N:1 relation) — each Wing has one Curator.
/// </summary>
[Entity(Path = "wings")]
[Identity(IdentityGenerator.Random)]
[OperationEndpoints]
public partial class Wing
{
    [Predicate("name")]
    public string Name { get; set; } = string.Empty;
 
    [Predicate("floor")]
    public int Floor { get; set; }
 
    [Owning("curator")]
    public partial EntityRef<Scribe>? Curator { get; set; }
 
    [Owning("manuscripts")]
    public partial EntityRefCollection<Manuscript> Manuscripts { get; }
}

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Execution;
using Aletheia.Sdk.Repository.Contracts;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Ask Aletheia for the details of a Wing — she walks the relationships.
/// </summary>
public sealed record WingDetailCommand(string WingIri);
 
/// <summary>
/// The Wing's details, including its Curator's name and manuscript count.
/// </summary>
public sealed record WingDetailResponse(string WingName, string? CuratorName, int ManuscriptCount);
 
[Capability("sample.wing-detail")]
public sealed class WingDetailHandler : ICapabilityHandler<WingDetailCommand, WingDetailResponse>
{
    private readonly IEntityStore _store;
 
    public WingDetailHandler(IEntityStore store) => _store = store;
 
    public async ValueTask<ExecutionResult<WingDetailResponse>> HandleAsync(
        WingDetailCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        var wing = await _store.LoadAsync<Wing>(command.WingIri, cancellationToken);
        if (wing is null)
        {
            return new ExecutionResult<WingDetailResponse>.Fail(
                new ExecutionError("WING_NOT_FOUND", $"No Wing found at '{command.WingIri}'."));
        }
 
        using var session = EntitySession.Begin(_store);
 
        // Lazy-resolve the Curator via EntityRef<T>.GetAwaiter()
        var curator = wing.Curator is not null ? await wing.Curator : null;
 
        return new ExecutionResult<WingDetailResponse>.Ok(new WingDetailResponse(
            wing.Name,
            curator?.Name,
            wing.Manuscripts is not null ? wing.Manuscripts.Iris.Count : 0));
    }
}

using System.Collections.Immutable;
using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
using Aletheia.Sdk.Operations.Linq;
using Aletheia.Sdk.Repository.Contracts;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Search the Library's manuscripts by keyword.
/// </summary>
public sealed record CatalogCommand(string Keyword);
 
/// <summary>
/// A single manuscript match from the catalog search.
/// </summary>
public sealed record CatalogMatch(string Title, string Author, string Iri);
 
/// <summary>
/// Results of a catalog search.
/// </summary>
public sealed record CatalogResponse(IReadOnlyList<CatalogMatch> Matches);
 
[Capability("sample.catalog")]
public sealed class CatalogHandler : ICapabilityHandler<CatalogCommand, CatalogResponse>
{
    private readonly IEntityStore _store;
 
    public CatalogHandler(IEntityStore store) => _store = store;
 
    public async ValueTask<ExecutionResult<CatalogResponse>> HandleAsync(
        CatalogCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        // Using Sdk.Operations.Linq to query the entity store for manuscripts that match the keyword in their title.
        var matches = _store
            .Query<Manuscript>()
            .Where(m => m.Title != null && m.Title.Contains(command.Keyword))
            .ToList();
 
        return new ExecutionResult<CatalogResponse>.Ok(new CatalogResponse(
            matches
                .Select(m => new CatalogMatch(m.Title!, m.Author!, m.Iri))
                .ToImmutableList()
        ));
    }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Entity.Contracts;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// A Seal — a frozen record of the Library. Also demonstrates ObjectBearing:
/// each Seal can store a binary object of the sealed scroll.
/// </summary>
[Entity(Path = "seals")]
[Identity(IdentityGenerator.Random)]
[OperationEndpoints]
[ObjectBearing("seal-scrolls")]
public partial class Seal
{
    [Predicate("name")]
    public string Name { get; set; } = string.Empty;
 
    [Predicate("description")]
    public string Description { get; set; } = string.Empty;
 
    [Owning("sealedManuscripts")]
    public partial EntityRefCollection<Manuscript> SealedManuscripts { get; }
}

using Aletheia.Sdk.Repository.InMemory.DependencyInjection;
using Aletheia.Sdk.Repository.GraphDb.DependencyInjection;
 
using Aletheia.Sdk.ObjectStorage.Http;
using Aletheia.Sdk.ObjectStorage.Http.DependencyInjection;
using Aletheia.Sdk.ObjectStorage.InMemory.DependencyInjection;
using Aletheia.Sdk.Aspects.Abstractions.Contracts;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
// ...
    repoBuilder.UseInMemory();
builder.Services.AddOperationEndpointsHttpFromAssemblyContaining<DataRecord>();
 
builder.Services.AddInMemoryObjectStorage();
builder.Services.AddObjectStorageHttpFromAssemblyContaining<Manuscript>();
 
var app = builder.Build();
 
// ...
 
app.MapOperations();
 
app.MapObjectOperations();
 
app.Run();

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
using Aletheia.Sdk.Operations;
using Aletheia.Sdk.Repository.Transaction;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Register the same catalog entry twice to make a deliberate fail of the transaction.
/// </summary>
public sealed record DuplicateCatalogEntryCommand();
 
/// <summary>
/// The result of creating duplicate catalog entries. Should never be returned.
/// </summary>
public sealed record DuplicateCatalogEntryResponse();
 
[Capability("sample.duplicate-catalog-entry")]
public sealed class DuplicateCatalogEntryHandler : ICapabilityHandler<DuplicateCatalogEntryCommand, DuplicateCatalogEntryResponse>
{
    private readonly ITransactionalEntityStore _store;
 
    public DuplicateCatalogEntryHandler(ITransactionalEntityStore store) => _store = store;
 
    public async ValueTask<ExecutionResult<DuplicateCatalogEntryResponse>> HandleAsync(
        DuplicateCatalogEntryCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
 
        using var _ = EntityOperations.Use(_store);
 
        var catalogEntry1 = new CatalogEntry { Author = "Plato", Title = "The Republic" };
        var catalogEntry2 = new CatalogEntry { Author = "Plato", Title = "The Republic" };
 
        await using var tx = EntityOperations.BeginTransaction();
        tx.Create(catalogEntry1);
        tx.Create(catalogEntry2); // This will cause a duplicate identity error when committing the transaction.
        await tx.CommitAsync(cancellationToken);
 
        return new ExecutionResult<DuplicateCatalogEntryResponse>.Ok(
            new DuplicateCatalogEntryResponse()
        );
    }
}

using Aletheia.Sdk.Aspects.Abstractions;
using Aletheia.Sdk.Aspects.Abstractions.Contracts;
using Aletheia.Sdk.Aspects.Message;
 
public static class CapabilityAspects
{
    public static void RegisterCapabilityAspects(this IAspectStore aspectStore)
    {
        // Registers a message aspect that validates catalog search keywords.
        // The aspect uses SHACL (Shapes Constraint Language) to define the validation rules.
        // The aspect is identified by the IRI "urn:aletheia:aspects:catalog-keyword-v1" and is associated with the CatalogCommand entity type.
        // The validation rules specify that a catalog search keyword must be at least 3 characters long.
        // The aspect is registered with the aspect store, making it available for use in the application.
        var catalogKeywordAspect = new InlineTtlMessageAspect("urn:aletheia:aspects:catalog-keyword-v1", """
            @prefix sh:   <http://www.w3.org/ns/shacl#> .
            @prefix aletheia: <https://www.aletheia.arkenforge.de/> .
            <urn:aletheia:aspects:catalog-keyword-shape>
                a sh:NodeShape ;
                sh:targetClass <urn:Aletheia.Sdk.Sample.CatalogCommand> ;
                sh:property [
                    sh:path aletheia:Keyword ; sh:minLength 3 ;
                    sh:message "A catalog search keyword must be at least 3 characters." ;
                ] .
            """);
        aspectStore.RegisterMessage(catalogKeywordAspect);
        aspectStore.RegisterCapabilityAspect(new CapabilityAspect
        {
            Iri = "urn:aletheia:aspects:capability:catalog-v1",
            CommandAspectIri = "urn:aletheia:aspects:catalog-keyword-v1"
        });
 
        catalogKeywordAspect = new InlineTtlMessageAspect("urn:aletheia:aspects:catalog-keyword-v2", """
            @prefix sh:   <http://www.w3.org/ns/shacl#> .
            @prefix aletheia: <https://www.aletheia.arkenforge.de/> .
            <urn:aletheia:aspects:catalog-keyword-shape>
                a sh:NodeShape ;
                sh:targetClass <urn:Aletheia.Sdk.Sample.CatalogCommand> ;
                sh:property [
                    sh:path aletheia:Keyword ; sh:minLength 3 ;
                    sh:message "A catalog search keyword must be at least 3 characters." ;
                ] .
            """);
        aspectStore.RegisterMessage(catalogKeywordAspect);
        aspectStore.RegisterCapabilityAspect(new CapabilityAspect
        {
            Iri = "urn:aletheia:aspects:capability:catalog-v2",
            CommandAspectIri = "urn:aletheia:aspects:catalog-keyword-v2"
        });
    }
}

using Aletheia.Sdk.Aspects.Abstractions.Contracts;
using Aletheia.Sdk.Aspects.Operation;
 
public static class OperationAspects
{
    public static void RegisterOperationAspects(this IAspectStore aspectStore)
    {
        // Registers an operation aspect that validates manuscripts before they are written to the repository.
        // The aspect uses SHACL (Shapes Constraint Language) to define the validation rules.
        // The aspect is identified by the IRI "urn:aletheia:aspects:manuscript-write-v1" and is associated with the Manuscript entity type.
        // The validation rules specify that a manuscript must have a non-empty title.
        // The aspect is registered with the aspect store, making it available for use in the application.
        aspectStore.RegisterOperation(new InlineTtlOperationAspect("urn:aletheia:aspects:manuscript-write-v1", """
            @prefix sh:          <http://www.w3.org/ns/shacl#> .
            @prefix manuscripts: <https://www.aletheia.arkenforge.de/predicates/manuscripts/> .
            <urn:aletheia:aspects:manuscript-shape>
                a sh:NodeShape ;
                sh:targetClass <https://www.aletheia.arkenforge.de/types/manuscripts> ;
                sh:property [
                    sh:path manuscripts:title ; sh:minCount 1 ; sh:minLength 1 ;
                    sh:message "A manuscript must have a non-empty title." ;
                ] .
            """, null)
        );
    }
}

using Aletheia.Sdk.Aspects.Abstractions.Contracts;
using Aletheia.Sdk.Aspects.Query;
 
public static class QueryAspects
{
    public static void RegisterQueryAspects(this IAspectStore aspectStore)
    {
 
        // Registers a query aspect for filtering manuscripts based on their seal status.
        // The aspect uses SPARQL (Semantic Web Query Language) to define the query rules.
        // The aspect is identified by the IRI "urn:aletheia:aspects:manuscript-query-v1" and is associated with the Manuscript entity type.
        // The query rules specify that only manuscripts that are not sealed should be returned.
        // The aspect is registered with the aspect store, making it available for use in the application.
        var manuscriptQueryAspect = new InlineTtlQueryAspect("urn:aletheia:aspects:manuscript-query-v1",
            """
                ?manuscript <https://www.aletheia.arkenforge.de/predicates/manuscripts/isSealed> ?sealed .
                FILTER(?sealed = false)
            """,
            null);
        aspectStore.RegisterQuery(manuscriptQueryAspect);
    }
}

using Aletheia.Sdk.Aspects.Abstractions.Contracts;
using Aletheia.Sdk.Aspects.Operation;
 
/// <summary>
/// Object-level aspects — guards for [ObjectBearing] upload routes.
/// These apply to the object storage pipeline, not entity properties.
/// </summary>
public static class ObjectAspects
{
    public static void RegisterObjectAspects(this IAspectStore aspectStore)
    {
        // Registers an object-lock aspect that prevents re-uploading a Seal's scroll.
        // Once the Seal entity has an objectKey (a blob has been uploaded), the aspect
        // blocks further uploads. Delete the blob first to unlock.
        // Uses a pure SPARQL WHERE clause — no SHACL shape, just a graph pattern check.
        aspectStore.RegisterOperation(new InlineTtlOperationAspect("urn:aletheia:aspects:operation:seal-lock-v1", null, """
            ?entityIri <https://www.aletheia.arkenforge.de/predicates/seals/objectKey> ?existingKey .
            BIND(?entityIri AS ?focusNode)
            BIND("This seal already bears a scroll. Delete the object before re-uploading." AS ?message)
            """));
    }
}

using Aletheia.Sdk.Aspects.Abstractions.Contracts;
using Aletheia.Sdk.Aspects.View;
 
/// <summary>
/// Registers the frontend-purpose view aspects of the tutorial — the Manuscript
/// form shape the browser validates against before submitting.
/// <br/><br/>
/// Views are feedback, never enforcement: the capability pipeline never checks
/// them. The exploration endpoints serve their Turtle source, and the view
/// aspect engine validates JSON form values on demand
/// (<c>POST api/entities/aspect-definitions/{iri}/validate</c>), reporting
/// findings of every severity mapped to JSON paths.
/// <br/><br/>
/// Every <c>sh:path</c> is a predicate in the canonical JSON namespace
/// (<see cref="Aletheia.Sdk.Aspects.Abstractions.Aspect.JsonNamespace"/>) — its
/// local name is the JSON key.
/// </summary>
public static class ViewAspects
{
    public static void RegisterViewAspects(this IAspectStore aspectStore)
    {
        // The Manuscript form shape: title required (violation when empty),
        // pages a positive integer, authorNote optional but warned on when
        // shorter than five characters.
        aspectStore.RegisterView(new InlineTtlViewAspect("urn:aletheia:views:manuscript-form", """
            @prefix sh:   <http://www.w3.org/ns/shacl#> .
            @prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
            @prefix json: <https://www.aletheia.arkenforge.de/json/> .
            <urn:aletheia:views:manuscript-form>
                a sh:NodeShape ;
                sh:targetClass <urn:aletheia:views:ManuscriptForm> ;
                sh:property [
                    sh:path json:title ; sh:minCount 1 ; sh:minLength 1 ;
                    sh:datatype xsd:string ;
                    sh:message "view.manuscript.title" ;
                ] ;
                sh:property [
                    sh:path json:pages ; sh:minCount 1 ;
                    sh:datatype xsd:integer ; sh:minInclusive 1 ;
                    sh:message "view.manuscript.pages" ;
                ] ;
                sh:property [
                    sh:path json:authorNote ;
                    sh:datatype xsd:string ; sh:minLength 5 ;
                    sh:severity sh:Warning ;
                    sh:message "view.manuscript.authorNote" ;
                ] .
            """)
        );
    }
}

 
app.MapObjectOperations();
 
CapabilityAspects.RegisterCapabilityAspects(app.Services.GetRequiredService<IAspectStore>());
QueryAspects.RegisterQueryAspects(app.Services.GetRequiredService<IAspectStore>());
OperationAspects.RegisterOperationAspects(app.Services.GetRequiredService<IAspectStore>());
ObjectAspects.RegisterObjectAspects(app.Services.GetRequiredService<IAspectStore>());
ViewAspects.RegisterViewAspects(app.Services.GetRequiredService<IAspectStore>());
 
app.Run();

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Returns all evnets for a given entity IRI, or all events if no IRI is provided.
/// </summary>
/// <param name="Iri">Iri of the entity to retrieve events for. If null, all events are returned.</param>
public sealed record EntityEventLogCommand(string? Iri);
 
/// <summary>
/// Response carries the events
/// </summary>
public sealed record EntityEventLogResponse(IReadOnlyList<EntityEventLogEntry> Events);
 
[Capability("sample.entity-event-log")]
public sealed class EntityEventLogHandler : ICapabilityHandler<EntityEventLogCommand, EntityEventLogResponse>
{
    private readonly EntityEventLog _log;
 
    public EntityEventLogHandler(EntityEventLog log)
    {
        _log = log;
    }
 
    public async ValueTask<ExecutionResult<EntityEventLogResponse>> HandleAsync(
        EntityEventLogCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        if (command.Iri is null)
            return new ExecutionResult<EntityEventLogResponse>.Ok(
                new EntityEventLogResponse(_log.GetAll()));
 
        return new ExecutionResult<EntityEventLogResponse>.Ok(
            new EntityEventLogResponse(_log.GetByIri(command.Iri)));
    }
}

namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Entry in the in-process entity event log used by the event demo.
/// </summary>
public sealed record EntityEventLogEntry(
    string EntityIri,
    string TypeName,
    string Operation,
    string BranchIri,
    string Topic,
    DateTimeOffset TimestampUtc);
 
/// <summary>
/// Thread-safe in-process log of entity change events.
/// Exposed via GET /api/diagnostics/entity-events.
/// </summary>
public sealed class EntityEventLog
{
    private readonly List<EntityEventLogEntry> _entries = [];
    private readonly object _lock = new();
 
    public void Add(EntityEventLogEntry entry)
    {
        lock (_lock) _entries.Add(entry);
    }
 
    public IReadOnlyList<EntityEventLogEntry> GetAll()
    {
        lock (_lock) return [.. _entries];
    }
 
    public IReadOnlyList<EntityEventLogEntry> GetByIri(string iri)
    {
        lock (_lock) return [.. _entries.Where(e => e.EntityIri == iri)];
    }
}

using Aletheia.Sdk.Entity.Messaging;
using Aletheia.Sdk.Messaging;
using Microsoft.Extensions.Hosting;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Background service that listens for Manuscript changes and logs them.
/// Part of Chapter 07: The Whisper — every new Manuscript whispers through the Library.
/// </summary>
internal sealed class ManuscriptSubscription (
    IMessageConsumer<string, EntityChangedEnvelope<Manuscript>> consumer,
    EntityEventLog log) : BackgroundService
{
    internal const string Topic = "aletheia.entities.manuscript.history";
 
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var envelope in consumer.ConsumeAsync(Topic, stoppingToken).ConfigureAwait(false))
        {
            log.Add(new EntityEventLogEntry(
                EntityIri: envelope.Payload.Iri.ToString(),
                TypeName: envelope.Payload.TypeName,
                Operation: envelope.Payload.Operation.ToString(),
                BranchIri: envelope.Payload.BranchIri,
                Topic: Topic,
                TimestampUtc: envelope.TimestampUtc));
        }
    }
}

using Aletheia.Sdk.ObjectStorage.InMemory.DependencyInjection;
using Aletheia.Sdk.Aspects.Abstractions.Contracts;
 
using Aletheia.Sdk.Entity.Messaging.DependencyInjection;
using Aletheia.Sdk.Messaging.InMemory.DependencyInjection;
using Aletheia.Sdk.Branch.Http;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
 
builder.Services.AddMessagingInMemory();
builder.Services.AddEntityEvents();
builder.Services.AddEntityMessaging<Manuscript>(opts =>
    opts.TypeIri = "https://www.aletheia.arkenforge.de/entities/Manuscript");
builder.Services.AddSingleton<EntityEventLog>();
builder.Services.AddHostedService<ManuscriptSubscription>();
 
builder.Services.AddCapabilityHandlersFromAssemblyContaining<GreetHandler>();
builder.Services.AddCapabilityHttp();
// ...

using Aletheia.Sdk.Messaging.InMemory.DependencyInjection;
using Aletheia.Sdk.Branch.Http;
 
using Aletheia.Sdk.Branch.Http.DependencyInjection;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
// ...
builder.Services.AddSingleton<EntityEventLog>();
builder.Services.AddHostedService<ManuscriptSubscription>();
 
builder.Services.AddBranchHttp(builder.Configuration);
builder.Services.AddBranchHttpWithAspects(builder.Configuration);
 
builder.Services.AddCapabilityHandlersFromAssemblyContaining<GreetHandler>();
builder.Services.AddCapabilityHttp();
// ...
ObjectAspects.RegisterObjectAspects(app.Services.GetRequiredService<IAspectStore>());
ViewAspects.RegisterViewAspects(app.Services.GetRequiredService<IAspectStore>());
 
app.UseBranchScope();
app.MapBranches();
 
app.Run();

app.UseBranchScope();
app.MapBranches();
 
app.MapSnapshots();
 
app.Run();

 
using Aletheia.Sdk.Branch.Http.DependencyInjection;
 
using Aletheia.Sdk.Structure;
using Aletheia.Sdk.Structure.DependencyInjection;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
// ...
builder.Services.AddBranchHttp(builder.Configuration);
builder.Services.AddBranchHttpWithAspects(builder.Configuration);
 
builder.Services.AddStructure();
builder.Services.AddOperationEndpointsHttp(typeof(Node).Assembly);
builder.Services.AddCapabilityHandlersFromAssemblyContaining<GetConfiguredTreeHandler>();
 
builder.Services.AddCapabilityHandlersFromAssemblyContaining<GreetHandler>();
builder.Services.AddCapabilityHttp();
// ...

using Aletheia.Sdk.Structure;
using Aletheia.Sdk.Structure.DependencyInjection;
 
using Aletheia.Sdk.Aspects.Entity;
using Aletheia.Sdk.Capability.Entity;
using Aletheia.Sdk.Entity.Entity;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
// ...
builder.Services.AddInMemoryObjectStorage();
builder.Services.AddObjectStorageHttpFromAssemblyContaining<Manuscript>();
 
builder.Services.AddAspectsEntity();
builder.Services.AddCapabilityEntity(typeof(GreetHandler).Assembly);
builder.Services.AddEntityEntity(typeof(Manuscript).Assembly);
 
var app = builder.Build();
 
// ...
 
app.MapSnapshots();
 
app.MapEntityEntity();
app.MapCapabilityEntity();
app.MapAspectsEntity();
 
app.Run();

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
using Aletheia.Sdk.Messaging;
using Aletheia.Sdk.Operations;
using Aletheia.Sdk.Repository;
using Aletheia.Sdk.Repository.Contracts;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Fire-and-forget: accept the request, store a pending result, return immediately.
/// </summary>
public sealed record EchoCommand(string Message);
 
/// <summary>
/// Response carries the result IRI — the caller polls this to check completion.
/// </summary>
public sealed record EchoResponse(string ResultIri, bool Accepted);
 
[Capability("sample.echo")]
public sealed class EchoHandler : ICapabilityHandler<EchoCommand, EchoResponse>
{
    private readonly IEntityStore _store;
    private readonly IMessageProducer<string, EchoResult> _producer;
 
    public EchoHandler(IEntityStore store, IMessageProducer<string, EchoResult> producer)
    {
        _store = store;
        _producer = producer;
    }
 
    public async ValueTask<ExecutionResult<EchoResponse>> HandleAsync(
        EchoCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        using var _ = EntityOperations.Use(_store);
 
        // Create the pending result entity
        var result = new EchoResult { OriginalMessage = command.Message, IsReady = false };
        await EntityOperations.CreateAsync(result, cancellationToken);
 
        // Publish to the echo topic for background processing
        await _producer.ProduceAsync(new MessageEnvelope<EchoResult>(
            "aletheia.echo.requests",
            result.Iri,
            result,
            ExecutionScope.Current ?? new ExecutionCorrelation(),
            DateTimeOffset.UtcNow), cancellationToken);
 
        return new ExecutionResult<EchoResponse>.Ok(
            new EchoResponse(result.Iri, true));
    }
}

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Capability.Messaging;
using Aletheia.Sdk.Execution;
using Aletheia.Sdk.Operations;
using Aletheia.Sdk.Repository.Contracts;
 
namespace Aletheia.Sdk.Sample;
 
// ── AsyncEcho (user-facing entry point) ──────────────────────────────────────
 
/// <summary>
/// Fire-and-forget via the async capability dispatcher.
/// The caller sends a message, gets back a result IRI immediately, and polls.
/// </summary>
public sealed record AsyncEchoCommand(string Message);
 
/// <summary>
/// Response carries the result IRI — the caller polls this to check completion.
/// </summary>
public sealed record AsyncEchoResponse(string ResultIri, bool Accepted);
 
[Capability("sample.async-echo")]
public sealed class AsyncEchoHandler : ICapabilityHandler<AsyncEchoCommand, AsyncEchoResponse>
{
    private readonly IEntityStore _store;
    private readonly IAsyncCapabilityDispatcher<ProcessEchoCommand, ProcessEchoResponse> _dispatcher;
 
    public AsyncEchoHandler(
        IEntityStore store,
        IAsyncCapabilityDispatcher<ProcessEchoCommand, ProcessEchoResponse> dispatcher)
    {
        _store = store;
        _dispatcher = dispatcher;
    }
 
    public async ValueTask<ExecutionResult<AsyncEchoResponse>> HandleAsync(
        AsyncEchoCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        using var _ = EntityOperations.Use(_store);
 
        // Create the pending result entity
        var result = new EchoResult { OriginalMessage = command.Message, IsReady = false };
        await EntityOperations.CreateAsync(result, cancellationToken);
 
        // Dispatch to the message bus — fire and forget
        await _dispatcher.PublishAsync(
            new ProcessEchoCommand(result.Iri, command.Message),
            cancellationToken: cancellationToken);
 
        return new ExecutionResult<AsyncEchoResponse>.Ok(
            new AsyncEchoResponse(result.Iri, true));
    }
}

using Aletheia.Sdk.Capability;
using Aletheia.Sdk.Execution;
using Aletheia.Sdk.Operations;
using Aletheia.Sdk.Repository.Contracts;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Command dispatched via the message bus by <see cref="AsyncEchoHandler"/>.
/// Carries the result IRI so the background handler knows which EchoResult to update.
/// </summary>
public sealed record ProcessEchoCommand(string ResultIri, string Message);
 
/// <summary>
/// Response from the background processor — not surfaced to the original caller.
/// </summary>
public sealed record ProcessEchoResponse(string EchoMessage);
 
/// <summary>
/// Runs on a background thread via the CapabilityCommandPumpService.
/// Loads the pending EchoResult, marks it ready, and saves.
/// </summary>
/// <remarks>
/// This handler exists separately from <see cref="EchoHandler"/> because async
/// dispatch has different semantics: the caller owns the pending entity,
/// the handler only updates it. <see cref="EchoHandler"/> owns its entity —
/// it creates it. Different responsibilities, different capabilities.
/// </remarks>
[Capability("sample.process-echo")]
public sealed class ProcessEchoHandler : ICapabilityHandler<ProcessEchoCommand, ProcessEchoResponse>
{
    private readonly IEntityStore _store;
 
    public ProcessEchoHandler(IEntityStore store) => _store = store;
 
    public async ValueTask<ExecutionResult<ProcessEchoResponse>> HandleAsync(
        ProcessEchoCommand command,
        CapabilityContext context,
        CancellationToken cancellationToken = default)
    {
        var result = await _store.LoadAsync<EchoResult>(command.ResultIri, cancellationToken);
        if (result is null)
        {
            return new ExecutionResult<ProcessEchoResponse>.Fail(
                new ExecutionError("NOT_FOUND", $"EchoResult '{command.ResultIri}' not found."));
        }
 
        using var _ = EntityOperations.Use(_store);
 
        result.EchoMessage = $"processed: {command.Message}";
        result.IsReady = true;
        await EntityOperations.UpdateAsync(result, cancellationToken);
 
        return new ExecutionResult<ProcessEchoResponse>.Ok(
            new ProcessEchoResponse(result.EchoMessage));
    }
}

using Aletheia.Sdk.Entity;
using Aletheia.Sdk.Operations;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// An Echo Result — stores the outcome of an async echo request.
/// Created immediately with isReady=false, then updated by the background processor.
/// </summary>
[Entity(Path = "echo-results")]
[Identity(IdentityGenerator.Random)]
[OperationEndpoints]
public partial class EchoResult
{
    [Predicate("originalMessage")]
    public string OriginalMessage { get; set; } = string.Empty;
 
    [Predicate("echoMessage")]
    public string EchoMessage { get; set; } = string.Empty;
 
    [Predicate("isReady")]
    public bool IsReady { get; set; }
}

using Aletheia.Sdk.Messaging;
using Aletheia.Sdk.Operations;
using Aletheia.Sdk.Repository.Contracts;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Background subscription that processes Echo requests asynchronously.
/// Listens on the echo topic, processes the message, and marks the result as ready.
/// </summary>
internal sealed class EchoSubscription(
    IMessageConsumer<string, EchoResult> consumer,
    IEntityStore store) : BackgroundService
{
    internal const string Topic = "aletheia.echo.requests";
 
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var envelope in consumer.ConsumeAsync(Topic, stoppingToken).ConfigureAwait(false))
        {
            var echo = envelope.Payload;
            using var _ = EntityOperations.Use(store);
 
            // Simulate async work — the Echo takes a moment to respond
            await Task.Delay(200, stoppingToken);
 
            var loaded = await store.LoadAsync<EchoResult>(echo.Iri, stoppingToken);
            if (loaded is not null)
            {
                loaded.EchoMessage = $"Echo: {loaded.OriginalMessage}";
                loaded.IsReady = true;
                await EntityOperations.UpdateAsync(loaded, stoppingToken);
            }
        }
    }
}

builder.Services.AddCapabilityEntity(typeof(GreetHandler).Assembly);
builder.Services.AddEntityEntity(typeof(Manuscript).Assembly);
 
builder.Services.AddHostedService<EchoSubscription>();
builder.Services.AddCapabilityMessaging();
 
var app = builder.Build();
 
// ...

using System.Text.Json;
using Aletheia.Sdk.AI.Scenarios;
 
namespace Aletheia.Sdk.Sample;
 
/// <summary>
/// Registers the tutorial's AI scenario flows — the file-to-form use-case as a
/// two-step flow: a vision model reads an uploaded image, then a builder model
/// constructs a Manuscript form value that the runner validates in-loop against
/// the manuscript-form view (chapter 08).
/// <br/><br/>
/// Step roles resolve through <c>AIOptions.ModelRoles</c> in appsettings.json —
/// <c>vision</c> points at the local <c>moondream</c> model, the builder falls back
/// to the default <c>llama3.2</c> model, both served by Ollama.
/// </summary>
public static class AiScenarios
{
    /// <summary>The Manuscript form shape from chapter 08 — the flow validates against it.</summary>
    public const string ManuscriptFormViewIri = "urn:aletheia:views:manuscript-form";
 
    public static void RegisterAiScenarios(this ScenarioRegistry registry)
    {
        registry.Register(new ScenarioDefinition(
            Key: "manuscript-from-image",
            Description: "Read a scanned manuscript cover, then build a validated Manuscript form value.",
            Steps:
            [
                new ScenarioStep(
                    Name: "vision",
                    ModelRole: "vision",
                    Instruction: "Read this scanned manuscript cover. " +
                        "Answer exactly: what title is printed on it, and what number is the page count? " +
                        "Reply with one short line only.",
                    OutputSchema: ManuscriptSchema(),
                    MaxRetries: 0,
                    TextOutput: true),
                new ScenarioStep(
                    Name: "builder",
                    ModelRole: "builder",
                    Instruction: "The next message describes a manuscript cover. " +
                        "Extract the book title and the page count from it. " +
                        "Respond with a single JSON object with exactly the keys title (string) and pages (integer).",
                    OutputSchema: ManuscriptSchema(),
                    MaxRetries: 3,
                    ViewIri: ManuscriptFormViewIri),
            ]));
    }
 
    private static JsonElement ManuscriptSchema() => JsonSchema(
        ("title", "string"),
        ("pages", "integer"));
 
    private static JsonElement JsonSchema(params (string Name, string Type)[] properties)
    {
        var props = new Dictionary<string, object>();
        var required = new List<string>();
        foreach (var (name, type) in properties)
        {
            props[name] = new { type };
            required.Add(name);
        }
 
        return JsonSerializer.SerializeToElement(new
        {
            type = "object",
            properties = props,
            required,
        });
    }
}

using Aletheia.Sdk.Capability.Entity;
using Aletheia.Sdk.Entity.Entity;
 
using Aletheia.Sdk.AI.DependencyInjection;
using Aletheia.Sdk.AI.Http;
using Aletheia.Sdk.AI.Scenarios;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
// ...
builder.Services.AddCapabilityEntity(typeof(GreetHandler).Assembly);
builder.Services.AddEntityEntity(typeof(Manuscript).Assembly);
 
builder.Services.AddAI(builder.Configuration);
builder.Services.AddAIOntology();
builder.Services.AddAITools();
 
builder.Services.AddHostedService<EchoSubscription>();
builder.Services.AddCapabilityMessaging();
// ...
app.MapCapabilityEntity();
app.MapAspectsEntity();
 
AiScenarios.RegisterAiScenarios(app.Services.GetRequiredService<ScenarioRegistry>());
app.MapAiEndpoints();
 
app.Run();

using Aletheia.Sdk.AI.Http;
using Aletheia.Sdk.AI.Scenarios;
 
using Aletheia.Sdk.Authorization.DependencyInjection;
using Aletheia.Sdk.Authorization.Http.DependencyInjection;
using Aletheia.Sdk.Authorization.Entity;
 
var builder =  WebApplication.CreateBuilder(args);
builder.Services.AddAspects();
 
builder.Services.AddRoleBasedAuthorization();
builder.Services.AddAuthorizationHttp(builder.Configuration);
builder.Services.AddOperationEndpointsHttp(typeof(Agent).Assembly);
 
builder.Services.AddMessagingInMemory();
builder.Services.AddEntityEvents();
// ...
AiScenarios.RegisterAiScenarios(app.Services.GetRequiredService<ScenarioRegistry>());
app.MapAiEndpoints();
 
app.UseAgentTokenMiddleware();
 
app.Run();

builder.Services.AddHostedService<EchoSubscription>();
builder.Services.AddCapabilityMessaging();
 
builder.Services.AddWebInterface("/viewer");
 
var app = builder.Build();
 
// ...
 
app.UseAgentTokenMiddleware();
 
app.UseWebInterface();
 
app.Run();