@eventmodelers/cli 1.0.73 → 1.0.74

package/stacks/cratis-csharp/templates/.claude/skills/build-state-change/SKILL.md

@@ -1,191 +0,0 @@
----
-name: build-state-change
-description: >
-  Implement Event Sourcing write slices the Cratis way — using Cratis Arc (CQRS) + Cratis Chronicle
-  (event sourcing) in a .NET / C# project. A write slice is: Command → Handle() → Event(s), with
-  optional validators, constraints, and DCB business rules. Use when: (1) implementing a new write
-  slice / command in a Cratis project, (2) a slice.json has a non-empty commands[] / events[] section,
-  (3) the user provides an Event Modeling artifact, specification, or natural-language description of a
-  command and asks to implement it, (4) the user says "implement", "create", "add" a write slice,
-  command, or state change in a Cratis Arc / Chronicle project.
----
-
-# Cratis — Write Slice (State Change)
-
-A write slice mutates state by recording events. In Cratis Arc the whole path lives in **one `.cs`
-file**:
-
-```
-[Command] record + Handle()  →  validator/constraint  →  [EventType] record(s)  →  dotnet build  →  specs
-```
-
-> **Read first:** [../_shared/cratis-conventions.md](../_shared/cratis-conventions.md) — the
-> non-negotiable Cratis rules. Everything below assumes them.
-
-## Step 0 — Discover the target project's conventions
-
-Before writing code, read the project's `.build-kit/CLAUDE.md` and **at least one existing slice** (the starter
-ships one under `SomeModule/SomeFeature/`). Confirm:
-
-- The namespace root (read the `.csproj` `<RootNamespace>` and existing `.cs` files — never
-  hard-code it; the namespace mirrors the folders and drops any `.Features.` segment).
-- How existing commands return results (single event / tuple / `Result<,>` / `void`).
-- How `ConceptAs<T>` identity types are declared and where they live.
-- Whether existing `.cs` files use a file header (the starter uses none).
-
-> **Comments & description:** each slice element carries a `comments: string[]` array and a
-> `description`. Use them as implementation hints. When done, resolve each used comment:
-> `POST <BASE_URL>/api/org/<ORG_ID>/boards/<BOARD_ID>/nodes/<nodeId>/comments/<commentId>/resolve`
-> (get IDs first via GET on the same path).
-
-## Step 1 — Understand the input (`slice.json` is the source of truth)
-
-Extract, regardless of input format:
-
-| Element | What to extract |
-|---|---|
-| **Command** | Name (imperative), fields, which field is the event source / `[Key]` |
-| **Events** | Names (past tense), fields, which events this command appends |
-| **Business rules** | Preconditions, invariants, idempotency — from `description` / `comments` only |
-| **State needed for rules** | Which read model must be inspected (DCB) to evaluate a rule |
-| **Specifications** | Each GWT / scenario maps 1:1 to an executable spec |
-| **Storylines** (optional) | `storylines[]` — ordered walkthrough "beats"; a `COMMAND → EVENT` transition in one is a supplementary spec source, see Step 5a |
-
-**If a field is not in `slice.json`, it does not go in the code.** If requirements are unclear, ask
-the user before proceeding.
-
-### Determine the trigger
-If unclear how the command is dispatched, ask:
-> - **UI / REST** — exposed automatically by Arc; add a React component + integration spec.
-> - **Automation only** — dispatched internally by a reactor (no UI). The command still exists; no `.tsx`.
-
-## Step 2 — Create concept types (if needed)
-
-For any new identity / value, add one `ConceptAs<T>` per file in the feature folder. Use the canonical
-Guid-identity pattern (with `NotSet`, `New()`, and the `EventSourceId` conversion) — see the shared
-conventions doc and [references/patterns.md](references/patterns.md).
-
-## Step 3 — Write the slice `.cs` file
-
-`<Module>/<Feature>/<Slice>/<Slice>.cs` — ALL backend artifacts in this one file; namespace
-`<Root>.<Module>.<Feature>.<Slice>` (no file header unless the project uses one).
-
-### Events first
-```csharp
-[EventType]                                   // NEVER any arguments
-public record AuthorRegistered(AuthorName Name);
-```
-Past tense, no nullable properties, one purpose each. If the context's events already exist elsewhere,
-reuse them — don't redefine.
-
-### Command with `Handle()` on the record
-```csharp
-[Command]
-public record RegisterAuthor(AuthorName Name)
-{
-    public AuthorRegistered Handle() => new(Name);   // Arc appends the returned event
-}
-```
-
-Pick the return shape that matches the slice:
-- **single event** → `EventName Handle()`
-- **generate + return a new id** → `(NewId, EventName) Handle()` (Arc returns the id as
-  `CommandResult<T>.response`)
-- **multiple events** → `IEnumerable<object> Handle() => [ new A(...), new B(...) ];`
-- **success/error** → `Result<TSuccess, TError> Handle()`
-- **side-effect only** → `void Handle()`
-
-Event source: a `[Key]` parameter, an `EventSourceId`-convertible concept, or `ICanProvideEventSourceId`.
-
-### Business rules (DCB) — inject the read model
-When a rule depends on event-sourced state, take the read model as a `Handle()` parameter; Arc injects
-current state. Throw / return an error for violations:
-```csharp
-[Command]
-public record RegisterAuthor(AuthorName Name)
-{
-    public Result<AuthorRegistered, RegistrationError> Handle(AuthorByName existing) =>
-        existing is not null
-            ? RegistrationError.NameAlreadyTaken
-            : new AuthorRegistered(Name);
-}
-```
-Only encode rules that appear in the slice `description` / `comments`. See
-[references/patterns.md](references/patterns.md) for the full DCB and constraint patterns.
-
-### Validation (optional but recommended)
-```csharp
-public class RegisterAuthorValidator : CommandValidator<RegisterAuthor>
-{
-    public RegisterAuthorValidator() =>
-        RuleFor(c => c.Name).NotEmpty().WithMessage("Name is required").MaximumLength(100);
-}
-```
-Extend `CommandValidator<T>` — auto-discovered, no registration. One `RuleFor` per validation in the slice.
-
-## Step 4 — Build
-
-From the project root: `dotnet build`. Fix ALL warnings and errors before continuing (warnings = errors).
-This also regenerates the TypeScript proxies the frontend depends on.
-
-## Step 5 — Write specs (one per scenario in `slice.json`)
-
-Put integration specs in `<Module>/<Feature>/<Slice>/when_<behavior>/and_<scenario>.cs`. Cover, from the
-slice's specifications:
-- **Happy path** — command succeeds, correct event appended.
-- **Each validation failure** — one spec per rule.
-- **Each DCB business-rule violation** — one spec per read-model condition in `Handle()`.
-- **Each constraint violation.**
-
-Use the Cratis BDD pattern (`Specification`, `Establish` / `Because` / `[Fact] should_*`). For
-Chronicle integration specs use `Given<context>` + `ChronicleOutOfProcessFixture` and assert with
-`Context.ShouldHaveAppendedEvent<T>(...)`. See [references/patterns.md](references/patterns.md).
-
-Run `dotnet test --filter "FullyQualifiedName~<SliceName>"`. Fix all failures.
-
-## Step 5a — Storyline-derived specs (optional)
-
-If `storylines[]` is non-empty — a storyline embedded in this slice's slice.json already belongs
-entirely to this slice, no need to match beats against `commands[]` by id/title — look for a
-`COMMAND → EVENT` transition: a `type: "COMMAND"` beat, followed by its resulting event beat(s) —
-possibly followed by a READMODEL beat after that.
-
-- **Establish** — append every event from the storyline's start up to (not including) the command
-  beat.
-- **Because** — `Handle()` the command, built from the beat's `fields`.
-- **should_\*** — assert the expected event(s) (the beat(s) immediately following the command).
-
-Only the `COMMAND → EVENT` half lives here — if the storyline continues `EVENT → READMODEL`, that
-half is a separate spec in **build-state-view** (its Step 4a). Don't chase a single spec across
-both a command dispatch and a read-model assertion unless the project already has an established
-pattern doing that — Chronicle integration specs assert appended events, not read-model state,
-and vice versa for projection specs.
-
-Place these alongside the `specifications[]`-derived specs but in their own
-`and_<storyline-title>.cs` file, so a reader can tell at a glance which specs are exhaustive
-coverage and which are one narrated walkthrough.
-
-Skip silently (no spec) when the transition isn't isolable — e.g. the command beat has no
-traceable preceding events.
-
-## Step 6 — Frontend (only if the command is UI-triggered)
-
-After `dotnet build` generated the proxy (co-located next to the `.cs`), add
-`<Module>/<Feature>/<Slice>/<Component>.tsx` importing the proxy from `./`, using `CommandDialog` /
-inline form. Add a barrel `index.ts`. Register it in the feature's composition
-page. See the shared conventions doc's React section and [references/patterns.md](references/patterns.md).
-
-## Final verification — does the implementation match `slice.json`?
-
-- [ ] Every `commands[]` field → a Command record property (no invented, none missing).
-- [ ] Every `events[]` entry → an `[EventType]` record; names match exactly; fields match.
-- [ ] Every specification / GWT scenario → an executable spec.
-- [ ] No business rule in `Handle()` that is absent from the slice `description` / `comments`.
-- [ ] A `storylines[]` `COMMAND → EVENT` transition for this command has a spec, or was
-      deliberately skipped (not silently ignored).
-- [ ] `dotnet build` is clean (0 warnings / 0 errors); slice specs pass.
-
-## References
-- [references/patterns.md](references/patterns.md) — full command/event/validator/constraint/DCB code,
-  integration specs, and the React command UI patterns.
-- [../_shared/cratis-conventions.md](../_shared/cratis-conventions.md) — the Cratis conventions.

package/stacks/cratis-csharp/templates/.claude/skills/build-state-change/references/patterns.md

@@ -1,234 +0,0 @@
-# Write Slice Patterns — Cratis Arc + Chronicle
-
-Complete code for state-change (write) slices. All artifacts go in a single
-`<Module>/<Feature>/<Slice>/<Slice>.cs` file (the shipped starter uses `SomeModule/SomeFeature/...` —
-match whatever the existing slices use). The example slices use no file header (match the project).
-Namespace mirrors the folders and drops any `.Features.`. The examples below use short illustrative
-names (`MyApp.Authors.Registration`); mirror your project's actual module/feature layout instead.
-
----
-
-## 1. Concept (one per file, in the feature folder)
-
-```csharp
-// Features/Authors/AuthorId.cs
-namespace MyApp.Authors;
-
-public record AuthorId(Guid Value) : ConceptAs<Guid>(Value)
-{
-    public static readonly AuthorId NotSet = new(Guid.Empty);
-    public static implicit operator Guid(AuthorId id) => id.Value;
-    public static implicit operator AuthorId(Guid value) => new(value);
-    public static implicit operator EventSourceId(AuthorId id) => new(id.Value.ToString());
-    public static AuthorId New() => new(Guid.NewGuid());
-}
-
-// Features/Authors/AuthorName.cs
-public record AuthorName(string Value) : ConceptAs<string>(Value)
-{
-    public static readonly AuthorName NotSet = new(string.Empty);
-    public static implicit operator string(AuthorName name) => name.Value;
-    public static implicit operator AuthorName(string value) => new(value);
-}
-```
-
----
-
-## 2. Simplest write slice — single event
-
-```csharp
-// Features/Authors/Registration/Registration.cs
-namespace MyApp.Authors.Registration;
-
-using Cratis.Arc.Commands.ModelBound;
-using Cratis.Chronicle.Events;
-
-[Command]
-public record RegisterAuthor([Key] AuthorId Id, AuthorName Name)
-{
-    public AuthorRegistered Handle() => new(Name);
-}
-
-[EventType]
-public record AuthorRegistered(AuthorName Name);
-
-public class RegisterAuthorValidator : CommandValidator<RegisterAuthor>
-{
-    public RegisterAuthorValidator() =>
-        RuleFor(c => c.Name).NotEmpty().WithMessage("Name is required").MaximumLength(100);
-}
-```
-
-The `[Key]` parameter is the event source id. With a concept that converts to `EventSourceId`, you may
-omit `[Key]` and let Arc resolve it.
-
----
-
-## 3. Generate-and-return a new id
-
-```csharp
-[Command]
-public record RegisterAuthor(AuthorName Name)
-{
-    public (AuthorId, AuthorRegistered) Handle()
-    {
-        var id = AuthorId.New();
-        return (id, new AuthorRegistered(Name));   // id flows back as CommandResult<AuthorId>.response
-    }
-}
-```
-
----
-
-## 4. Multiple events
-
-```csharp
-[Command]
-public record TransferFunds(AccountId FromId, AccountId ToId, decimal Amount)
-{
-    public IEnumerable<object> Handle() =>
-    [
-        new FundsWithdrawn(FromId, Amount),
-        new FundsDeposited(ToId, Amount),
-    ];
-}
-```
-
----
-
-## 5. Injected dependency / constraint
-
-`Handle()` parameters are DI-resolved. Use for external services or constraints (e.g. uniqueness):
-
-```csharp
-[Command]
-public record OpenDebitAccount([Key] AccountId Id, string Name, OwnerId OwnerId)
-{
-    public async Task<DebitAccountOpened> Handle(IUniqueAccountConstraint constraint)
-    {
-        await constraint.Validate(Name);          // throws on violation
-        return new DebitAccountOpened(Name, OwnerId);
-    }
-}
-```
-
----
-
-## 6. Business rule via DCB (inject a read model)
-
-When a rule depends on event-sourced state, accept the relevant read model as a `Handle()` parameter.
-Arc materializes current state from the event log and injects it. Return a `Result<,>` for a clean
-success/error contract:
-
-```csharp
-[Command]
-public record ReserveBook([Key] BookId Id, MemberId Member)
-{
-    public Result<BookReserved, ReservationError> Handle(BookAvailability availability)
-    {
-        if (availability is null || !availability.IsAvailable)
-            return ReservationError.NotAvailable;
-        return new BookReserved(Member);
-    }
-}
-
-public enum ReservationError { NotAvailable }
-```
-
-Only encode rules that appear in the slice `description` / `comments`.
-
----
-
-## 7. Integration spec (Chronicle, full stack)
-
-`Features/Authors/Registration/when_registering/and_there_are_no_authors.cs`
-
-```csharp
-using context = MyApp.Authors.Registration.when_registering.and_there_are_no_authors.context;
-
-namespace MyApp.Authors.Registration.when_registering;
-
-[Collection(ChronicleCollection.Name)]
-public class and_there_are_no_authors(context context) : Given<context>(context)
-{
-    public class context(ChronicleOutOfProcessFixture fixture) : given.an_http_client(fixture)
-    {
-        public CommandResult<AuthorId>? Result;
-
-        async Task Because() =>
-            Result = await Client.ExecuteCommand<RegisterAuthor, AuthorId>(
-                "/api/authors/register",
-                new RegisterAuthor(AuthorId.New(), new AuthorName("John Doe")));
-    }
-
-    [Fact] void should_be_successful() => Context.Result!.IsSuccess.ShouldBeTrue();
-    [Fact] void should_have_appended_one_event() =>
-        Context.ShouldHaveTailSequenceNumber(EventSequenceNumber.First);
-    [Fact] void should_append_author_registered_event() =>
-        Context.ShouldHaveAppendedEvent<AuthorRegistered>(
-            EventSequenceNumber.First, Context.Result!.Response,
-            evt => evt.Name.Value.ShouldEqual("John Doe"));
-}
-```
-
-### Pure unit spec on `Handle()` (no I/O)
-
-```csharp
-namespace MyApp.Authors.Registration.for_RegisterAuthor;
-
-public class when_registering : Specification
-{
-    RegisterAuthor _command;
-    AuthorRegistered _event;
-
-    void Establish() => _command = new(AuthorId.New(), new AuthorName("John"));
-    void Because() => _event = _command.Handle();
-
-    [Fact] void should_carry_the_name() => _event.Name.Value.ShouldEqual("John");
-}
-```
-
----
-
-## 8. React command UI (after `dotnet build` generated the proxy)
-
-The proxy (`RegisterAuthor.ts`) is generated **next to** `Registration.cs` (the starter's `.csproj`
-sets `CratisProxiesUseSourceFileAsOutputFile=true`), so import it from the **same folder**. Add a barrel
-`index.ts` (`export * from './AddAuthor'`) like the shipped example slice.
-
-```tsx
-// Authors/Registration/AddAuthor.tsx
-import { CommandDialog } from '@cratis/components/CommandDialog';
-import { InputTextField } from '@cratis/components/CommandForm';
-import { RegisterAuthor } from './RegisterAuthor';   // co-located generated proxy
-
-export const AddAuthor = () => (
-    <CommandDialog command={RegisterAuthor} title="Add author" okLabel="Add" cancelLabel="Cancel">
-        <InputTextField<RegisterAuthor> value={c => c.name} title="Name" />
-    </CommandDialog>
-);
-```
-
-Inline form alternative:
-
-```tsx
-const [command] = RegisterAuthor.use();
-const submit = async () => {
-    const result = await command.execute();
-    if (result.isSuccess) onSuccess(result.response);
-};
-```
-
-Never import `Dialog` from `primereact/dialog` — use the Cratis wrappers. PrimeReact CSS variables for
-colors. No `any`. Full descriptive variable names.
-
----
-
-## Checklist
-
-- One `.cs` file, namespace without `.Features.` (no file header unless the project uses one).
-- `[Command]` with `Handle()` on the record — no handler class.
-- `[EventType]` with **no** arguments; past-tense names; no nullable fields.
-- `ConceptAs<T>` for every identity / value — no raw `Guid` / `string` in the domain.
-- `CommandValidator<T>` for validations; read-model parameter for DCB rules.
-- One spec per scenario in `slice.json`; `dotnet build` clean; specs pass.

package/stacks/cratis-csharp/templates/.claude/skills/build-state-view/SKILL.md

@@ -1,149 +0,0 @@
----
-name: build-state-view
-description: >
-  Implement read slices the Cratis way — a [ReadModel] record with static query methods, fed by a
-  Chronicle projection or reducer, plus the React component that renders it. Use when: (1) implementing
-  a new read slice / projection in a Cratis project, (2) a slice.json has a non-empty readModel /
-  projections / queries section, (3) the user provides a read-slice Event Modeling artifact or
-  specification and asks to implement it, (4) the user says "implement", "create", "add" a read slice,
-  read model, projection, reducer, or query in a Cratis Arc / Chronicle project.
----
-
-# Cratis — Read Slice (State View)
-
-A read slice projects events into a queryable read model. In Cratis the path lives in **one `.cs`
-file**:
-
-```
-[ReadModel] record + static queries  →  projection or reducer  →  dotnet build  →  React
-```
-
-> **Read first:** [../_shared/cratis-conventions.md](../_shared/cratis-conventions.md). Everything
-> below assumes those rules.
-
-## Step 0 — Discover conventions
-
-Read `.build-kit/CLAUDE.md` and one existing read slice. Confirm the namespace root, how existing read models
-declare queries (snapshot vs observable), whether projections use model-bound attributes or
-`IProjectionFor<T>`, and the MongoDB collection wiring. Resolve slice `comments` when done (see the
-state-change skill's Step 0 for the resolve endpoint).
-
-## Step 1 — Understand the input (`slice.json` is the source of truth)
-
-| Element | What to extract |
-|---|---|
-| **Read model** | Name, fields, the key field |
-| **Source events** | Which events feed each field (projections **join events, never read models**) |
-| **Queries** | The queries to expose; whether each is snapshot or real-time (observable) |
-| **Specifications** | Each scenario → an executable spec proving the projection result |
-| **Storylines** (optional) | `storylines[]` — ordered walkthrough "beats"; a read-model chain in one is a supplementary spec source, see Step 4a |
-
-If a field has no source event in `slice.json`, do not invent one. One read model per use case —
-never reuse a model across slices.
-
-## Step 2 — Write the slice `.cs` file
-
-`<Module>/<Feature>/<Slice>/<Slice>.cs` — namespace `<Root>.<Module>.<Feature>.<Slice>` (mirror the folders; drop any `.Features.`).
-
-### Read model + static query methods
-```csharp
-[ReadModel]
-public record AuthorListItem(AuthorId Id, AuthorName Name, int BookCount)
-{
-    public static async Task<IEnumerable<AuthorListItem>> AllAuthors(
-        IMongoCollection<AuthorListItem> collection)
-        => await collection.Find(_ => true).ToListAsync();
-
-    public static async Task<AuthorListItem?> GetAuthor(
-        AuthorId id, IMongoCollection<AuthorListItem> collection)
-        => await collection.Find(a => a.Id == id).FirstOrDefaultAsync();
-
-    // Real-time push — return ISubject<T> directly (never Task<ISubject<T>>)
-    public static ISubject<IEnumerable<AuthorListItem>> ObserveAllAuthors(
-        IMongoCollection<AuthorListItem> collection)
-        => collection.Observe();
-}
-```
-- `[ReadModel]` required. Query methods are **`public static`** on the record; the method name becomes
-  the TS query proxy class name. No controller, no `IReadModels`.
-- Favor reactive (`ISubject<T>`) queries when the slice wants live updates.
-
-### Choose projection vs reducer
-- **Projection** — shaped read models, field mapping, joins, children (most read slices).
-- **Reducer** — running aggregates (balances, counts, sums) where state accumulates across events.
-
-### Projection (declarative; AutoMap on by default)
-```csharp
-public class AuthorListItemProjection : IProjectionFor<AuthorListItem>
-{
-    public void Define(IProjectionBuilderFor<AuthorListItem> builder) => builder
-        .From<AuthorRegistered>(from => from.Set(m => m.Name).To(e => e.Name))
-        .From<BookAdded>(from => from.Add(m => m.BookCount).With(_ => 1));
-}
-```
-Or model-bound shorthand for simple cases:
-```csharp
-[ReadModel]
-public record AuthorInfo([Key] Guid Id, [FromEvent<AuthorRegistered>] string Name);
-```
-
-Projections/reducers are discovered automatically — no registration. See
-[references/patterns.md](references/patterns.md) for joins, children, composite keys, and reducers.
-
-## Step 3 — Build
-
-`dotnet build` from the project root — zero warnings / errors. This generates the query proxy the
-frontend imports.
-
-## Step 4 — Specs
-
-Write specs proving the projection/reducer produces the expected read model from a sequence of events —
-one spec per scenario in `slice.json`. Run `dotnet test --filter "FullyQualifiedName~<SliceName>"`.
-See [references/patterns.md](references/patterns.md).
-
-## Step 4a — Storyline-derived specs (optional)
-
-If the slice's `storylines[]` array (in `slice.json`, alongside `specifications[]`) is non-empty —
-a storyline embedded in this slice's slice.json already belongs entirely to this slice, no need to
-match beats against `readmodels[]` by id/title — look for a **read-model chain**: two beats of
-`type: "READMODEL"`, with only `EVENT` beat(s) between them. That's a self-contained projection
-spec:
-
-- **Establish** — append every event from the storyline's start up through the intervening
-  event(s), in order.
-- **Because** — run the projection.
-- **should_\*** — assert against the *later* beat's `fields`/`examples`/`expectEmptyList`.
-
-Put these in their own `for_<ReadModel>/when_<storyline-title>/` folder (not `when_<behavior>/`),
-so they're never confused with the exhaustive `specifications[]` suite — a storyline is a
-narrated walkthrough, not exhaustive coverage.
-
-If the storyline's transition into this read model is instead `COMMAND → EVENT → READMODEL`, only
-the `EVENT → READMODEL` half belongs here — the `COMMAND → EVENT` half is a separate spec in
-**build-state-change** (see its Step 5a). Don't try to assert read-model state from a dispatched
-command in one spec unless the project already has an established pattern for that.
-
-Skip a beat sequence entirely — no spec, no placeholder — if it can't be isolated (e.g. a SCREEN
-beat with no traceable event). A storyline is source material for tests, not a mandate to write
-one for every beat.
-
-## Step 5 — Frontend
-
-Add `<Module>/<Feature>/<Slice>/<Component>.tsx` importing the co-located generated query proxy from
-`./` (`MyQuery.use()` snapshot, `MyQuery.useWithPaging(pageSize)` for paging, observable proxy for live
-data; or `DataTableForObservableQuery` for a table). Add a barrel `index.ts`. Register it in the
-feature's composition page; add routing in `App.tsx` if it's a new page.
-
-## Final verification — does the implementation match `slice.json`?
-
-- [ ] Every read-model field → a record property fed by a projection/reducer mapping.
-- [ ] Every source event used exists; projections map from **events**, never read models.
-- [ ] Every query in the slice is exposed as a static method; observable where the slice wants live data.
-- [ ] Every scenario → an executable spec.
-- [ ] A `storylines[]` read-model chain for this read model has a spec, or was deliberately
-      skipped (not silently ignored).
-- [ ] `dotnet build` clean; specs pass.
-
-## References
-- [references/patterns.md](references/patterns.md) — full projection/reducer/query/spec code + React.
-- [../_shared/cratis-conventions.md](../_shared/cratis-conventions.md) — the Cratis conventions.