@reventlessdev/reventless-core 3.0.0-alpha.300 → 3.0.0-alpha.301

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.301 (2026-10-21)
+
+* feat!: the write-side logic module is called the decision, and a codemod moves an app over ([cb573ff](https://github.com/ReventlessDev/reventless-core/commit/cb573ff5b928c7d7f3e75988dfaa65066f8c95eb))
+
+### BREAKING CHANGES
+
+* <Spec>_Behavior.res, @@reventless.behavior,
+Reventless.Behavior.T, StateChangeSlice.Behavior, Behavior_GWT and
+thenRefused no longer exist. Run `npx reventless-rename-to-decision` at an
+app's root, then rebuild; comments are not rewritten. The PPX must be the
+matching release.
+
+
+
 # 3.0.0-alpha.300 (2026-10-19)
 
 **Note:** Version bump only for package @reventlessdev/reventless-core

package/README.md

@@ -10,7 +10,7 @@
 The **provider-agnostic core** of [Reventless](https://docs.reventless.dev) — a
 spec-driven, event-sourced CQRS framework written in [ReScript](https://rescript-lang.org).
 This package is the runtime you model your domain against: the type-safe building blocks
-for commands, events, projections, and the behaviors that evolve state — with **no** cloud
+for commands, events, projections, and the decisions that evolve state — with **no** cloud
 or storage dependency. The provider-specific adapters live in separate packages
 (see [Where it fits](#where-it-fits)).
 
@@ -19,8 +19,8 @@ or storage dependency. The provider-specific adapters live in separate packages
 ReScript modules, consumed by adding the package to your `rescript.json` `dependencies`:
 
 - **`Message`** — command / event message contracts and their service interface.
-- **`Behavior`** — the write-side behavior spec: event-sourced state transitions
-  (`evolve(state, event) => state`).
+- **`Decision`** — the write side's decision module type (the decider pattern):
+  event-sourced state transitions (`evolve(state, event) => state`) and `decide`.
 - **`Projection`** / **`ProjectionMapper`** — read models projected from event streams.
 - **`Mapper`** / **`Mapper1toN`** / **`MapperNto1`** — cross-component event translation
   (encode/decode between a source and a target contract).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.300",
+  "version": "3.0.0-alpha.301",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.22",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.23",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.23",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.24",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.198",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.197",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.41",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.169",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.23"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.42",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.170"
   },
   "devDependencies": {
     "rescript": "12.3.1",

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

@@ -1,4 +1,4 @@
-include Reventless.Behavior
+include Reventless.Decision
 
 module type Spec = {
   @schema

package/src/Message.res

@@ -308,7 +308,7 @@ let metaKeys = [
 
   `StoredEvent` is the logical shape (nested `meta:meta`). The on-disk shape is
   a flat top-level dict so DynamoDB GSIs can project individual meta attributes
-  (the §1.2/§3.2 behaviour today, preserved here). These two helpers are the
+  (the §1.2/§3.2 behavior today, preserved here). These two helpers are the
   single bridge between the two — used by both EventLog (aggregate) and
   DcbEventLog (DCB) storage paths.
 */

package/src/ResourceAttribution.res

@@ -7,11 +7,11 @@ drifting into private spellings of the same fact.
 
 The three facts are deliberately independent:
 
-- `ComponentType.t` — the *modelling* kind (Aggregate, StateViewSlice, …): what
+- `ComponentType.t` — the *modeling* kind (Aggregate, StateViewSlice, …): what
   the element IS in the domain model.
-- `Role.t` — the *deployment piece* (EventLog, QueryDb, Runtime, …): what job
-  this particular resource does for that element. One component owns several
-  pieces, so kind alone can't identify a resource.
+- `Role.t` — the *deployment role* (EventLog, QueryDb, Runtime, …): what job
+  this particular resource does for that element. One component owns resources in
+  several roles, so kind alone can't identify a resource.
 - `Scope.t` — the level the resource is attributed to: an individual component,
   a plugin's shared substrate, or platform substrate.
 
@@ -40,8 +40,8 @@ module Scope = {
 }
 
 /**
-The deployment piece a resource implements. `Other(string)` is the escape hatch
-for support pieces and future roles (same pattern as `Monitoring.unitKind`).
+The deployment role a resource plays. `Other(string)` is the escape hatch
+for support roles and future ones (same pattern as `Monitoring.unitKind`).
 */
 module Role = {
   type t =
@@ -105,11 +105,11 @@ module Role = {
 /**
 The model component a provisioned resource belongs to.
 
-Piece builders (EventLog, QueryDb, CommandTopic, EventTopic, EventCollector) are
+Role builders (EventLog, QueryDb, CommandTopic, EventTopic, EventCollector) are
 shared building blocks applied as functors by many different component kinds — a
 QueryDb is instantiated by ReadModel, StateViewSlice, AutomationSlice, both
 translation slices and Counter. The adapter that provisions the physical resource
-sits at the bottom of that chain and would otherwise only know its own piece, so
+sits at the bottom of that chain and would otherwise only know its own role, so
 `kind` would collapse onto `role` and the owning component would be unrecoverable.
 The owning builder passes this record down instead.
 

package/src/adapter/Auth/Auth_ActiveRole.res

@@ -69,7 +69,7 @@ boundary — and a table copied into two test suites is exactly the drift it exi
 to prevent.
 
 `expected` is the group set the minted token must carry. `None` means the request
-must be **refused** rather than honoured, ignored, or reduced to the empty set —
+must be **refused** rather than honored, ignored, or reduced to the empty set —
 the distinction §3 turns on. A path with no client to refuse (the trigger, reading
 stored state) resolves `None` by minting `membership` and marking
 [staleRoleClaim]; a path answering a live request refuses it.

package/src/adapter/Auth/Auth_RefusalVocabulary.res

@@ -120,7 +120,7 @@ Classify a refusal without knowing which adapter produced it.
 
 Pass what the response actually carried: its status, the `errorType` of a GraphQL
 error if there was one, and `extensions.code` if there was one. Returns `None`
-when the response is not a refusal this contract recognises — which includes a
+when the response is not a refusal this contract recognizes — which includes a
 successful response, so a caller must not read `None` as "allowed".
 
 Ordering matters and is the point of the function. The transport status is

package/src/adapter/EventLogProvisioning/EventLogProvisioning.res

@@ -1,6 +1,6 @@
 /**
 Deploy-time hook: every event log announces itself as it is provisioned, so an
-extension can attach behaviour to it inside the program that owns it.
+extension can attach behavior to it inside the program that owns it.
 
 No-op by default. Zero behavioral change unless an extension registers a backend
 via `use` before the platform/plugin build. The seam fires once per log at

package/src/adapter/RuntimeExtension/RuntimeExtension.res

@@ -8,7 +8,7 @@ No-op by default. Zero behavioral change unless an extension registers one via
 no code runs.
 
 `Monitoring` and `EventLogProvisioning` are the deploy-time half of this shape —
-they let an extension attach behaviour to *what gets provisioned*. This is the
+they let an extension attach behavior to *what gets provisioned*. This is the
 runtime half: *what runs inside it*. Without it,
 `CommandGenerator_Callback.registerCommandInterceptor`,
 `QueryDb_Callback.registerQueryInterceptor` and the two
@@ -34,7 +34,7 @@ to internals would make it a second, informal handler API — and the four hooks
 exists to reach already receive their own per-request payloads
 (`commandInterceptor` gets `~componentName` / `~tag` / `~args` on every call).
 
-`~runtimeKind` is the modelling kind of the component the runtime runs — the same
+`~runtimeKind` is the modeling kind of the component the runtime runs — the same
 `ComponentType.t` every AWS runtime builder already passes to
 `RuntimeEnvironment_Lambda.makeFromCodeAsset`, so there is no third taxonomy to
 keep in step with `Monitoring.unitKind` and `ResourceAttribution.Role`.
@@ -67,7 +67,7 @@ runtime handles its first request.
 seam reachable in a *deployed* runtime: registering a first-class module only
 populates the deploy program's process, and the Lambda is a different one, so the
 framework bundles the module's package into the code archive and names the module
-in the runtime's config for the entry shell to import. Spec and behavior modules
+in the runtime's config for the entry shell to import. Spec and decision modules
 are carried into runtimes the same way. The convention matches
 `@@reventless.spec`'s injected `let moduleUrl`, so a ReScript extension can lift
 it from there.

package/src/admin/Platform_BakedManifest.res

@@ -57,7 +57,7 @@ let describe = (e: error): string =>
 // gives. Unlike the other two, what it selects is not filtered here — there is
 // nothing in a `pluginStructure` to filter, because the pages do not exist until
 // a shell builds them. It travels to the shell instead, which is the only place
-// that can honour it.
+// that can honor it.
 type selection = {
   plugin: string,
   views: option<array<string>>,

package/src/admin/Platform_PluginStructuresApi.res

@@ -43,7 +43,7 @@ let sdlTypes: array<string> = [
   // reason the capability above is: a plugin built against a newer framework,
   // naming a posture this schema has never heard of, still decodes.
   //
-  // It records ORIGIN, never behaviour — a grafted file is the host's to edit
+  // It records ORIGIN, never behavior — a grafted file is the host's to edit
   // afterwards — so a reader must not paint a declared graft as a verified one.
   `type Platform_TraitDeclaration {\n  trait: String!\n  version: String!\n  posture: String!\n  component: String!\n}`,
   // `extensionPoints` / `requiredStores` / `requiredStoreDeclarations` /

package/src/admin/UiFragmentRegistry/StateChange/{UiFragmentRegistry_Behavior.res → UiFragmentRegistry_Decision.res}

@@ -1,4 +1,4 @@
-@@reventless.behavior
+@@reventless.decision
 
 open Reventless.Plugin
 

package/src/admin/UiFragmentRegistry/StateChange/{UiFragmentRegistry_Behavior.res.mjs → UiFragmentRegistry_Decision.res.mjs}

@@ -68,7 +68,7 @@ let Spec;
 
 let initialState;
 
-let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChange/UiFragmentRegistry_Behavior.res.mjs";
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChange/UiFragmentRegistry_Decision.res.mjs";
 
 export {
   Spec,

package/src/components/Aggregate/Aggregate_Builder.res

@@ -1,6 +1,6 @@
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Behavior.T with module Spec := Spec,
+  Decision: Decision.T with module Spec := Spec,
   EventMappings: EventMapper.Mappings with module Target := Spec,
   RuntimeEnvironment: Runtime.Environment,
   CommandGeneratorResolvers: CommandGenerator_Adapter.Resolvers
@@ -87,7 +87,7 @@ module Make = (
     ->Pulumi.Output.apply(eventLogOps => {
       module AggregateCallback = Aggregate_Callback.Make(
         Spec,
-        Behavior,
+        Decision,
         {
           module Spec = Spec
           module EventLog = SpecificEventLog

package/src/components/Aggregate/Aggregate_Builder.res.mjs

@@ -16,7 +16,7 @@ import * as CommandGenerator_Builder$ReventlessCore from "../CommandGenerator/Co
 import * as CommandGenerator_Callback$ReventlessCore from "../CommandGenerator/CommandGenerator_Callback.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (EventMappings => (RuntimeEnvironment => (CommandGeneratorResolvers => (CommandTopicChannel => (EventLogStorage => (EventTopicPublisher => (EventCollectorChannel => (AggregateRuntimeBuilder => (HooksConfig => {
+  return Decision => (EventMappings => (RuntimeEnvironment => (CommandGeneratorResolvers => (CommandTopicChannel => (EventLogStorage => (EventTopicPublisher => (EventCollectorChannel => (AggregateRuntimeBuilder => (HooksConfig => {
     let SpecificEventLog = EventLog_Builder$ReventlessCore.Make(Spec)(EventLogStorage)(EventTopicPublisher);
     let SpecificCommandTopic = CommandTopic_Builder$ReventlessCore.Make({
       Id: Spec.Id,
@@ -36,7 +36,7 @@ function Make(Spec) {
         name: Spec.name
       }, opts);
       return Component$ReventlessCore.operations(eventLog).apply(eventLogOps => {
-        let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Behavior)({
+        let AggregateCallback = Aggregate_Callback$ReventlessCore.Make(Spec)(Decision)({
           Spec: Spec,
           EventLog: SpecificEventLog,
           eventLog: eventLogOps

package/src/components/Aggregate/Aggregate_Callback.res

@@ -16,7 +16,7 @@ module type T = {
 
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Behavior.T with module Spec := Spec,
+  Decision: Decision.T with module Spec := Spec,
   Ops: Ops with module Spec = Spec,
 ): (T with module Spec = Spec) => {
   module Spec = Spec
@@ -82,9 +82,9 @@ module Make = (
     | CmdRefused(CommandTopic_Helpers.ownershipRefusal)
 
   // Folds a single command into the running accumulator: (currentState, perCommandOutcomes).
-  // A domain rejection from Behavior.decide is recorded as `CmdRejected` (no state change,
+  // A domain rejection from Decision.decide is recorded as `CmdRejected` (no state change,
   // surviving commands in the batch continue); a successful decide records `CmdOk(events)`
-  // and advances state via `Behavior.evolve`.
+  // and advances state via `Decision.evolve`.
   //
   // `~seq` is the replayed sequence number the batch decides from, carried in so
   // the line below can name the state rather than serialise it.
@@ -94,7 +94,7 @@ module Make = (
   let processCommand = (~seq: int) =>
     (
       (state, owners, outcomes): (
-        Behavior.state,
+        Decision.state,
         array<string>,
         array<(string, cmdOutcome, Message.meta)>,
       ),
@@ -131,9 +131,9 @@ module Make = (
         )->Effect.runSync
         (state, owners, Array.concat(outcomes, [(reference, CmdRefused(refused), meta)]))
       | None =>
-        switch Behavior.decide(state, command'.command) {
+        switch Decision.decide(state, command'.command) {
         | Ok(generatedEvents) =>
-          let newState = generatedEvents->Array.reduce(state, Behavior.evolve)
+          let newState = generatedEvents->Array.reduce(state, Decision.evolve)
           (
             newState,
             generatedEvents->Array.reduce(owners, recordEventOwners),
@@ -179,7 +179,7 @@ module Make = (
   // the fixed capacity (a per-aggregate knob is a future refinement — see
   // docs/plans/done/aggregate-snapshotting.md).
   let replayCacheCapacity = 100
-  let replayCache: Lru.t<string, (Behavior.state, int, array<string>)> = Lru.make(
+  let replayCache: Lru.t<string, (Decision.state, int, array<string>)> = Lru.make(
     ~capacity=replayCacheCapacity,
   )
 
@@ -195,8 +195,8 @@ module Make = (
   // Off for an owner-marked aggregate: a snapshot holds the state alone, so a
   // replay seeded from one would never see the event that recorded the owner,
   // and the ownership check would pass every caller.
-  let snapshotConfig = actsOnOwned ? None : Behavior.snapshot
-  if actsOnOwned && Behavior.snapshot->Option.isSome {
+  let snapshotConfig = actsOnOwned ? None : Decision.snapshot
+  if actsOnOwned && Decision.snapshot->Option.isSome {
     EffectLogger.logWarn(
       ~comp,
       "snapshots disabled: this aggregate records an @owner, which a snapshot does not carry",
@@ -223,7 +223,7 @@ module Make = (
   // State ⇄ JSON via the configured stateSchema. Both swallow sury failures to
   // `None` — an unserializable state just skips the snapshot write, and an
   // undecodable snapshot falls back to full replay; neither can fail a command.
-  let encodeState = (state: Behavior.state): option<JSON.t> =>
+  let encodeState = (state: Decision.state): option<JSON.t> =>
     switch snapshotConfig {
     | Some({stateSchema}) =>
       switch state->Reventless.Util_Sury.toJson(stateSchema) {
@@ -233,7 +233,7 @@ module Make = (
     | None => None
     }
 
-  let decodeState = (json: JSON.t): option<Behavior.state> =>
+  let decodeState = (json: JSON.t): option<Decision.state> =>
     switch snapshotConfig {
     | Some({stateSchema}) =>
       switch json->Reventless.Util_Sury.fromJson(stateSchema) {
@@ -250,7 +250,7 @@ module Make = (
   let coldReadState = id => {
     let idStr = id->Spec.Id.toString
     let seedEffect = switch snapshotConfig {
-    | None => Effect.succeed((Behavior.initialState, 0))
+    | None => Effect.succeed((Decision.initialState, 0))
     | Some(_) =>
       Effect.promise(() => Ops.eventLog.latestSnapshot(id))->Effect.map(snapResult =>
         switch snapResult {
@@ -262,28 +262,28 @@ module Make = (
               ~comp,
               `snapshot ignored (undecodable): id=${idStr}, seq=${snap.seqNr->Int.toString} — full replay`,
             )->Effect.runSync
-            (Behavior.initialState, 0)
+            (Decision.initialState, 0)
           }
         | Ok(Some(snap)) =>
           EffectLogger.logWarn(
             ~comp,
             `snapshot ignored (schema drift): id=${idStr}, seq=${snap.EventLog.seqNr->Int.toString} — full replay`,
           )->Effect.runSync
-          (Behavior.initialState, 0)
-        | Ok(None) => (Behavior.initialState, 0)
+          (Decision.initialState, 0)
+        | Ok(None) => (Decision.initialState, 0)
         | Error(msg) =>
           EffectLogger.logWarn(
             ~comp,
             `snapshot read failed (ignored): id=${idStr}: ${msg} — full replay`,
           )->Effect.runSync
-          (Behavior.initialState, 0)
+          (Decision.initialState, 0)
         }
       )
     }
     seedEffect->Effect.flatMap(((seedState, seedSeq)) =>
       Ops.eventLog.replayStream(id, ~fromSeq=seedSeq)
       ->Stream.runFold((seedState, seedSeq, []), ((st, n, owners), ev) => (
-        Behavior.evolve(st, ev),
+        Decision.evolve(st, ev),
         n + 1,
         owners->recordEventOwners(ev),
       ))

package/src/components/Aggregate/Aggregate_Callback.res.mjs

@@ -20,7 +20,7 @@ import * as SchemaWalker$ReventlessCore from "../../plugin/component/SchemaWalke
 import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (Ops => {
+  return Decision => (Ops => {
     let comp = `Aggregate(` + Spec.name + `)`;
     let groupTopicItemsByIdStream = stream => Effect.map(Stream.runFold(stream, {}, (dict, item) => {
       let id = Spec.Id.toString(item.command.id);
@@ -73,10 +73,10 @@ function Make(Spec) {
             ]])
         ];
       }
-      let generatedEvents = Behavior.decide(state, command$p.command);
+      let generatedEvents = Decision.decide(state, command$p.command);
       if (generatedEvents.TAG === "Ok") {
         let generatedEvents$1 = generatedEvents._0;
-        let newState = Stdlib_Array.reduce(generatedEvents$1, state, Behavior.evolve);
+        let newState = Stdlib_Array.reduce(generatedEvents$1, state, Decision.evolve);
         return [
           newState,
           Stdlib_Array.reduce(generatedEvents$1, owners, recordEventOwners),
@@ -112,8 +112,8 @@ function Make(Spec) {
     });
     let replayCache = Lru$ReventlessCore.make(100);
     let resetCache = () => Lru$ReventlessCore.clear(replayCache);
-    let snapshotConfig = actsOnOwned ? undefined : Behavior.snapshot;
-    if (actsOnOwned && Stdlib_Option.isSome(Behavior.snapshot)) {
+    let snapshotConfig = actsOnOwned ? undefined : Decision.snapshot;
+    if (actsOnOwned && Stdlib_Option.isSome(Decision.snapshot)) {
       Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, "snapshots disabled: this aggregate records an @owner, which a snapshot does not carry"));
     }
     let stateSchemaHash = snapshotConfig !== undefined ? HashObject(Object.fromEntries([[
@@ -153,7 +153,7 @@ function Make(Spec) {
             let snap = snapResult._0;
             if (snap === undefined) {
               return [
-                Behavior.initialState,
+                Decision.initialState,
                 0
               ];
             }
@@ -167,24 +167,24 @@ function Make(Spec) {
               } else {
                 Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `snapshot ignored (undecodable): id=` + idStr + `, seq=` + snap.seqNr.toString() + ` — full replay`));
                 return [
-                  Behavior.initialState,
+                  Decision.initialState,
                   0
                 ];
               }
             }
             Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `snapshot ignored (schema drift): id=` + idStr + `, seq=` + snap.seqNr.toString() + ` — full replay`));
             return [
-              Behavior.initialState,
+              Decision.initialState,
               0
             ];
           }
           Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `snapshot read failed (ignored): id=` + idStr + `: ` + snapResult._0 + ` — full replay`));
           return [
-            Behavior.initialState,
+            Decision.initialState,
             0
           ];
         }) : Effect.succeed([
-          Behavior.initialState,
+          Decision.initialState,
           0
         ]);
       return Effect.flatMap(seedEffect, param => {
@@ -194,7 +194,7 @@ function Make(Spec) {
           seedSeq,
           []
         ], (param, ev) => [
-          Behavior.evolve(param[0], ev),
+          Decision.evolve(param[0], ev),
           param[1] + 1 | 0,
           recordEventOwners(param[2], ev)
         ]), param => {

package/src/components/Api/ApiNoApiHelpers.res

@@ -5,7 +5,7 @@ let isNoApi = (commandSchema: S.t<unknown>): bool =>
 
 // Variants excluded by a mark on the member itself. This is the half that
 // survives a spread: splicing copies members, not the metadata of the union they
-// came from, so a command a trait marked internal is only still recognisable here.
+// came from, so a command a trait marked internal is only still recognizable here.
 let excludedByMembers = (commandSchema: S.t<unknown>): array<string> =>
   switch commandSchema {
   | AnyOf({anyOf}) =>

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -96,7 +96,7 @@ let rec fromSchemaType = (
   // names come from the schema — see `Reventless.TaggedUnion` — so the same union
   // is the same type wherever it appears, which is what lets AppSync merge each
   // source API's copy back into one, and what lets the write path stamp a
-  // `__typename` the SDL will recognise.
+  // `__typename` the SDL will recognize.
   | TaggedUnion(name, arms) =>
     if asInput {
       // GraphQL has no input unions. A command that wants one takes its arms as

package/src/components/Api/SchemaType.res

@@ -421,7 +421,7 @@ let trailShape = (
     let shape = ArrayOf(ObjectRef(entryName, fields))
     // Walking the entries by shape skips the semantic dispatch `fromSury` does,
     // so the marker is re-applied here. Without it the trail reaches a consumer
-    // as an unremarkable array of objects, and recognising it would come down to
+    // as an unremarkable array of objects, and recognizing it would come down to
     // the field's name.
     switch Reventless.Semantic.get(schema) {
     | Some(sem) => Semantic(sem, shape)

package/src/components/CommandTopic/CommandTopic_Helpers.res

@@ -12,7 +12,7 @@ during inline `publishJsonsAndWait` execution and read by `runInlineAndCollect`
 type acceptedResult = {entityId?: string, eventCount: int}
 
 /**
-Carries an encoded domain rejection from `Behavior.decide` back to a synchronous producer.
+Carries an encoded domain rejection from `Decision.decide` back to a synchronous producer.
 `errorCode` is the variant tag of `Spec.errorSchema` (e.g. `"AlreadyExists"`); `errorDetail`
 is the JSON-stringified error payload (or empty string for payload-less variants).
 */
@@ -21,7 +21,7 @@ type rejectedResult = {errorCode: string, errorDetail: string}
 /**
 Why a command was refused.
 
-`DomainRejection` is `Behavior.decide` returning `Error` — the model declining the command,
+`DomainRejection` is `Decision.decide` returning `Error` — the model declining the command,
 which is the model working. `InfrastructureFailure` is the decision never landing: an event-log
 append that failed outright or exhausted its conflict retries. Both arrive on `reportRejected`,
 so without this a consumer would read a broken event log as a business rejection.
@@ -92,7 +92,7 @@ let fireCommandOutcome = (~component: string, ~reference: string, outcome: obser
 let acceptedResultChannel: ref<option<(string, acceptedResult) => unit>> = ref(None)
 
 // Sibling side-channel for domain rejections — populated by callbacks when
-// `Behavior.decide` returns `Error`. Read by runInlineAndCollect to build
+// `Decision.decide` returns `Error`. Read by runInlineAndCollect to build
 // `Rejected` outcomes that carry the real error code and detail.
 let rejectedResultChannel: ref<option<(string, rejectedResult) => unit>> = ref(None)
 
@@ -234,7 +234,7 @@ let runInlineAndCollect = async (
   rejectedResultChannel.contents = None
   jsons->Array.mapWithIndex((cmdJson, i) => {
     let msgId = cmdJson.meta.msgId
-    // Domain rejection from Behavior.decide takes precedence over both Accepted
+    // Domain rejection from Decision.decide takes precedence over both Accepted
     // and the synthesized "Conflict" — it carries the most informative error.
     switch rejectedResults->Dict.get(msgId) {
     | Some({errorCode, errorDetail}) =>

package/src/components/EventLog/EventLog_Operations.res

@@ -17,8 +17,8 @@ module type T = {
 
 // Retry schedule for transient storage errors.
 // Exponential backoff: 100ms, ~200ms, ~400ms, ~800ms, ~1600ms — max 5 retries.
-// Only retries on recognised transient error messages; permanent errors propagate immediately.
-// Retry only recognised transient storage failures — never a Conflict (a retry
+// Only retries on recognized transient error messages; permanent errors propagate immediately.
+// Retry only recognized transient storage failures — never a Conflict (a retry
 // of the same append would just conflict again; the OCC retry happens a layer up
 // via replay+re-decide).
 let isTransient = (e: EventLog.appendError) =>

package/src/components/StateChangeSlice/StateChangeSlice.res

@@ -17,7 +17,7 @@ let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
 
 module type T = {
   module Spec: Reventless.StateChangeSlice.Spec
-  module Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec
+  module Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec
   /** `true` when built with `Platform.StateChangeSlice.MakeAsync` — uses FIFO channel, returns `CommandPending`. */
   let isAsync: bool
   type component = Component.t<t, outputs, operations>

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res

@@ -2,13 +2,13 @@ let log = Logger.fromEnv()
 
 module Make = (
   Spec: Reventless.StateChangeSlice.Spec,
-  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+  Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec,
 ): StateChangeSlice.T => {
   module Spec = Spec
-  module Behavior = Behavior
+  module Decision = Decision
   let isAsync = false
   type component = StateChangeSlice.component
-  module Callback = StateChangeSlice_Callback.Make(Spec, Behavior)
+  module Callback = StateChangeSlice_Callback.Make(Spec, Decision)
 
   let makeJsonHandler = (
     ~tagKeysByEventType,

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res.mjs

@@ -16,8 +16,8 @@ import * as StateChangeSlice_Callback$ReventlessCore from "./StateChangeSlice_Ca
 let log = Logger$ReventlessCore.fromEnv();
 
 function Make(Spec) {
-  return Behavior => {
-    let Callback = StateChangeSlice_Callback$ReventlessCore.Make(Spec)(Behavior);
+  return Decision => {
+    let Callback = StateChangeSlice_Callback$ReventlessCore.Make(Spec)(Decision);
     let makeJsonHandler = (tagKeysByEventType, crossPartitionTagKeys, partitionTag, dcbEventLogOps) => (stream => {
       let decodedStream = Stream.flatMap(Stream.mapEffect(stream, param => {
         let reference = param.reference;
@@ -67,7 +67,7 @@ function Make(Spec) {
     };
     return {
       Spec: Spec,
-      Behavior: Behavior,
+      Decision: Decision,
       isAsync: false,
       make: make
     };