@reventlessdev/reventless-spec 3.0.0-alpha.169 → 3.0.0-alpha.170

package/src/semantic/Color.res

@@ -1,15 +1,15 @@
 /**
-Marks a `string` field as a colour, written as a hex triplet.
+Marks a `string` field as a color, written as a hex triplet.
 
 ## Why hex only
 
 A field carrying this semantic is rendered as a swatch by setting the value as a
-CSS `background`. CSS accepts far more than a colour there — `url(…)`, gradients,
-`var(…)` — so "any CSS colour" would make a colour field a way to write arbitrary
+CSS `background`. CSS accepts far more than a color there — `url(…)`, gradients,
+`var(…)` — so "any CSS colour" would make a color field a way to write arbitrary
 CSS into a log that cannot be edited afterwards. Hex is the form that is a
-colour and nothing else, and it is what a colour picker emits anyway.
+color and nothing else, and it is what a color picker emits anyway.
 
-Named colours (`rebeccapurple`) and functional forms (`rgb(…)`, `oklch(…)`) are
+Named colors (`rebeccapurple`) and functional forms (`rgb(…)`, `oklch(…)`) are
 rejected for the same reason, not because they are worse notation.
 
 ## The grammar
@@ -26,7 +26,7 @@ full triplet, and the triplet with alpha. Case is not significant.
     })
 ```
 */
-/** The colour's representation. Transparent `string`; see `Email.t`. */
+/** The color's representation. Transparent `string`; see `Email.t`. */
 type t = string
 
 external unsafe: string => t = "%identity"
@@ -34,7 +34,7 @@ external toString: t => string = "%identity"
 
 let hex = /^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/
 
-/** Validate a raw string as a hex colour, saying why when it is not one. */
+/** Validate a raw string as a hex color, saying why when it is not one. */
 let fromString = (raw: string): result<t, string> =>
   if hex->RegExp.test(raw) {
     Ok(raw)
@@ -46,5 +46,5 @@ let fromString = (raw: string): result<t, string> =>
     )
   }
 
-/** The sury schema for a colour field. Use with `@s.matches(Reventless.Color.schema)`. */
+/** The sury schema for a color field. Use with `@s.matches(Reventless.Color.schema)`. */
 let schema: S.t<t> = S.string->Semantic.refined(~id=Semantic.Id.color, ~check=fromString)

package/src/semantic/IdentityProvider.res

@@ -38,7 +38,7 @@ surface. Collapsing them either loses accounts to a transient blip or retries
 forever against a password policy.
 */
 type failure =
-  /** The contact is already a principal. A modelled answer, not an exception —
+  /** The contact is already a principal. A modeled answer, not an exception —
         which is what a silent idempotent sign-up throws away. */
   | Conflict
   /** The provider is down or unreachable. The domain fact stands; retry. */

package/src/semantic/Messaging.res

@@ -142,7 +142,7 @@ type message = {subject?: string, body: string}
 
 /** The provider accepted the message. `ref` is its own id for it — what a
     support conversation about a missing message is conducted with, and the only
-    thing a caller can record that the provider will recognise. */
+    thing a caller can record that the provider will recognize. */
 type receipt = {ref: string}
 
 /**
@@ -203,7 +203,7 @@ type send = (~recipient: recipient, ~message: message) => promise<result<receipt
 The capability as a slice receives it: what can be attempted, and how.
 
 `channels` is here because a recipient cannot be offered a choice the deployment
-cannot honour. A platform provisions email only, or email and SMS; a preference
+cannot honor. A platform provisions email only, or email and SMS; a preference
 centre that listed all three would collect a subscription every send then answers
 `UnsupportedChannel` for. Published rather than inferred from a failed send,
 because discovering a channel by failing on it costs a real message.

package/src/types/{Behavior.res → Decision.res}

@@ -1,11 +1,15 @@
-// Behavior module type for aggregate business logic.
-// Lives in reventless-spec so application domain code can define behaviors
+// Decision module type for an aggregate's write-side logic.
+// Lives in reventless-spec so application domain code can define decisions
 // without importing the reventless implementation package.
 
 /**
-Module type that application code must implement to define aggregate business logic.
+Module type that application code must implement to define an aggregate's
+write-side logic: whether a command goes through, and what it emits.
 
-A `Behavior.T` module contains the `Spec` (command / event / error types), the
+It implements the *decider* pattern: `initialState`, `evolve` and `decide`.
+The file is `<Entity>_Decision.res`, annotated `@@reventless.decision`.
+
+A `Decision.T` module contains the `Spec` (command / event / error types), the
 aggregate `state`, and two pure functions plus an initial state value:
 
 - `initialState` — the starting state before any events (represents "not yet created")
@@ -14,7 +18,7 @@ aggregate `state`, and two pure functions plus an initial state value:
 
 @example
 ```rescript
-// CategoryBehavior.res
+// Category_Decision.res
 module Spec = Category
 
 @schema
@@ -73,7 +77,7 @@ module type T = {
   let decide: (state, Spec.command) => result<array<Spec.event>, Spec.error>
 
   /** Persisted-snapshot configuration (docs/plans/done/aggregate-snapshotting.md).
-      `None` — the default, auto-injected by `@@reventless.behavior` — keeps
+      `None` — the default, auto-injected by `@@reventless.decision` — keeps
       full replay; `Some({interval, stateSchema})` writes a keep-one snapshot
       every `interval` events and seeds cold replays from the latest one.
       Enable with `@@reventless.snapshots(<interval>)` (requires

package/src/types/Message.res

@@ -76,7 +76,7 @@ type meta = {
 /**
 Context passed into command handlers, carrying the aggregate ID and envelope metadata.
 
-Passed as the second argument to `Behavior.T.create` and `Behavior.T.execute`
+Passed as the second argument to `Decision.T.create` and `Decision.T.execute`
 so business logic can read the caller identity or propagate correlation IDs.
 */
 @schema

package/src/types/OwnerScope.res

@@ -21,8 +21,8 @@ absent. Every read here goes through a nullable cast for that reason; deleting
 one restores a silent failure rather than a type error.
 */
 /** Whether a JS value is a primitive string — `Cognito` and `InMemory` compile to
-    bare strings while `Custom(_)` compiles to an object, so this is how a modelled
-    provider is told from an unmodelled one that arrived as raw JSON. */
+    bare strings while `Custom(_)` compiles to an object, so this is how a modeled
+    provider is told from an unmodeled one that arrived as raw JSON. */
 let isJsString: 'a => bool = %raw(`v => typeof v === "string"`)
 
 external asNullableString: string => Nullable.t<string> = "%identity"
@@ -213,8 +213,8 @@ let classify = (identity: Identity.t, ~elevated: array<string>): t => {
 
   switch providerName {
   | Some(name) if systemProviders->Array.includes(name) => System
-  // A modelled string provider, or `Custom(_)` (an object, so `providerName` is
-  // None) — either way a caller claiming to be a person. Unmodelled strings fall
+  // A modeled string provider, or `Custom(_)` (an object, so `providerName` is
+  // None) — either way a caller claiming to be a person. Unmodeled strings fall
   // through to the refusal below.
   | Some("Cognito") | Some("InMemory") | None =>
     switch identity.userId->asNullableString->Nullable.toOption {
@@ -415,7 +415,7 @@ type retiredDecision =
 /**
 Combine a view's declared retirement flag with the caller behind the request.
 
-`~asked` is the caller's `includeRetired` request, honoured only where the
+`~asked` is the caller's `includeRetired` request, honored only where the
 caller was going to see those rows anyway. Reading it before classifying would
 make the argument the decision rather than a request.
 

package/src/types/Trait.res

@@ -19,7 +19,7 @@
 // annotation — an attribute's fields would all be strings the compiler never
 // checks, which is the failure this program exists to remove.
 //
-// **A declaration is a claim about origin, never about behaviour.** After a graft
+// **A declaration is a claim about origin, never about behavior.** After a graft
 // the developer owns the files and may edit them freely. So this says "grafted
 // from trait X", and it does NOT say "still behaves like trait X" — the thing that
 // answers the second question is the trait's conformance suite, which runs in the