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

package/src/components/Aggregate.res

@@ -2,7 +2,7 @@
 Module type for an aggregate's identity and schema specification.
 
 Every aggregate defines a `Spec` module satisfying this type. The `Spec` is
-used by `Platform.Aggregate.Make` and by `Behavior.T` to fix the aggregate's
+used by `Platform.Aggregate.Make` and by `Decision.T` to fix the aggregate's
 command, event, and error types.
 
 @example

package/src/components/CapabilityManifest.res

@@ -76,7 +76,7 @@ let fromStructure = (structure: Plugin.pluginStructure): t => {
   let capabilityKeys =
     needs->Array.map(d => d.capability)->Belt.Set.String.fromArray->Belt.Set.String.toArray
   let capabilities = capabilityKeys->Array.filterMap(key =>
-    // An unrecognised capability is dropped rather than passed through: the
+    // An unrecognized capability is dropped rather than passed through: the
     // generator downstream renders a real `Platform.capability` arm, and a name
     // this build cannot map has no arm to render.
     CapabilityNeed.fromString(key)->Option.map(need => {

package/src/components/ComponentKind.res

@@ -4,7 +4,7 @@
 // (`generator/Discovery`) and the external tooling that classifies files by
 // folder (`reventless-gwt`'s `ComponentMeta`) both derive from this, so the two
 // can't drift — previously the generator accepted plural/short folder names that
-// the gwt discovery silently didn't recognise.
+// the gwt discovery silently didn't recognize.
 
 type t =
   | StateChangeSlice
@@ -99,7 +99,7 @@ let bodySuffixes = [
   "_Projections",
   "_Projection",
   "_Mappings",
-  "_Behavior",
+  "_Decision",
   "_Automation",
   "_Translation",
 ]

package/src/components/ComponentKind.res.mjs

@@ -112,7 +112,7 @@ let bodySuffixes = [
   "_Projections",
   "_Projection",
   "_Mappings",
-  "_Behavior",
+  "_Decision",
   "_Automation",
   "_Translation"
 ];

package/src/components/DcbScopeInference.res

@@ -46,10 +46,10 @@ The four rules (over the representation):
     and this module stays schema-agnostic by taking the name alone.
 
     `byTag` marks the exception: an identity the *name* does not declare, which an
-    adapter recognised from an explicit `@partitionTag`. A domain's own identifier
+    adapter recognized from an explicit `@partitionTag`. A domain's own identifier
     is often not suffixed — `sku`, `isbn`, `vin` — and without this the annotation
     naming one would be extracted as a hint and then dropped, because `seedOf`
-    only honours a hint already among the produced keys. So the escape hatch would
+    only honors a hint already among the produced keys. So the escape hatch would
     have worked for every field except the ones that need it.
 
     It is carried rather than folded in because removing the annotation removes

package/src/components/DcbTag.res

@@ -100,7 +100,7 @@ let dcbPartitionTagId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(
 Internal sury metadata ID marking a tag field as *cross-partition* — readable
 across every partition that carries it (a secondary-tag read), not just the
 partition it is the partition key of. Opt-in; absence = the default
-partition-scoped behaviour. The scope is a property of the tag *key* and must
+partition-scoped behavior. The scope is a property of the tag *key* and must
 agree across every event type that carries it (the fence-scope half depends on
 it). See `docs/analysis/dcb-consistency-check-issues.md` Issue 13.
 */
@@ -497,7 +497,7 @@ tag the catalog's own events write. A key derived from `lineItems` would name a
 tag no producer has ever written, and the decision read would come back empty —
 the identical symptom to extracting no tags at all, from a different cause. An
 author who wants another key still writes `DcbTag.stringForKey` on the nested
-field, which `resolveTagKey` honours here as it does at the top level.
+field, which `resolveTagKey` honors here as it does at the top level.
 */
 let nestedRecordTags = (fieldSchema: S.t<unknown>, jsonValue: JSON.t): array<tag> =>
   switch nestedRecordProperties(fieldSchema) {
@@ -655,7 +655,7 @@ let extractVariantNames = (schema: S.t<'a>): array<string> => {
       // intentionally excluded here: DCB event-type lookups can't WHERE-clause
       // on bare-string events, so Plugin_Structure.consumedEventTypes and
       // related graph fields would otherwise claim cross-component edges the
-      // runtime can't honour. Callers that need every constructor (e.g.
+      // runtime can't honor. Callers that need every constructor (e.g.
       // mapping-mode `acceptedTags` filters that match a JSON envelope's
       // `event` TAG against the Delegate's full constructor set) should call
       // [`extractAllVariantNames`] instead.
@@ -729,7 +729,7 @@ let isVariantPayloadBearing = (schema: S.t<'a>, name: string): bool => {
 Extracts tags from a flat JSON object, expanding array values into per-element tags.
 
 For scalar tagged fields, behaves identically to `extractTagsFromProperties`.
-For array tagged fields, produces one tag per element. Tag keys honour an optional
+For array tagged fields, produces one tag per element. Tag keys honor an optional
 `DcbTag.stringForKey(~key=...)` override on the (inner) schema; otherwise the field
 name is used.
 
@@ -1123,7 +1123,7 @@ let idFieldsOfProperties = (properties: dict<S.t<unknown>>): array<DcbScopeInfer
   let isIdName = (name: string) => name->String.endsWith("Ids") || name->String.endsWith("Id")
   // An explicit `@partitionTag` declares an identity the naming convention cannot
   // express — a domain's own identifier is often unsuffixed (`sku`, `isbn`).
-  // Without this the hint is extracted and then ignored, since `seedOf` honours
+  // Without this the hint is extracted and then ignored, since `seedOf` honors
   // only a hint already among the produced keys, so the escape hatch would work
   // for every field except the ones that need it. Flagged, not folded in: taking
   // the annotation away takes the identity with it, which is what the redundancy

package/src/components/OutboundTranslationSlice.res

@@ -76,14 +76,14 @@ module type Spec = {
   /**
   Event sources this slice subscribes to, by topic key.
 
-  `[]` — the default and the historical behaviour — means this plugin's own DCB
+  `[]` — the default and the historical behavior — means this plugin's own DCB
   event log. Naming sources explicitly subscribes to them instead: an Aggregate's
   `Spec.name`, or a DCB source name (conventionally `"<pluginName>DcbEventLog"`),
   matching the keys `AutomationSlice` mappings already use.
 
   This exists because an outbound slice is the framework's one component for
   *calling an external service and feeding the answer back*, and that job is not
-  specific to DCB-modelled entities. An Aggregate whose events should trigger an
+  specific to DCB-modeled entities. An Aggregate whose events should trigger an
   outbound call had no route to one while this list was hard-wired.
 
   Unlike `AutomationSlice`, the sources are a flat list rather than per-source

package/src/components/Plugin.res

@@ -451,7 +451,7 @@ whole structure.
 while it walks the components, because it is the only party that knows which one
 carried the declaration. Nothing in this record is a string a developer typed.
 
-It records ORIGIN, not behaviour — a grafted file is the host's to edit
+It records ORIGIN, not behavior — a grafted file is the host's to edit
 afterwards. What answers "does it still behave like the trait" is the trait's own
 conformance suite, which runs in the consumer's build and is not this field.
 */
@@ -499,7 +499,7 @@ type pluginStructure = {
       component. Absent → None, read as []. The only signal a graft leaves that
       survives into a deployed plugin — every other one (the dependency, the
       variant spread, the rules alias, the conformance binding) is source-side.
-      A claim about origin, never about behaviour: see `Trait`. */
+      A claim about origin, never about behavior: see `Trait`. */
   traitDeclarations: option<array<traitDeclaration>>,
 }
 

package/src/components/Sensitive.res

@@ -9,7 +9,7 @@ facts about one field.
 It is declared where the field is declared, and read by anything that composes
 text somebody will read. That is the whole reason it lives here rather than
 beside whichever consumer happens to need it first: a marking that exists in one
-consumer is a marking the rest of the system cannot honour, and the domain model
+consumer is a marking the rest of the system cannot honor, and the domain model
 is the only place that knows which values are sensitive.
 
 ## Absent means "not stated", not "safe"

package/src/components/Snapshot.res

@@ -1,15 +1,15 @@
 // Per-aggregate persisted-snapshot configuration
 // (docs/plans/done/aggregate-snapshotting.md).
 //
-// Snapshotting is opt-in and lives on the Behavior module (where `state` is
-// defined): `Behavior.T.snapshot = None` (the default, auto-injected by
-// `@@reventless.behavior`) keeps full replay; `Some(config)` makes the
+// Snapshotting is opt-in and lives on the Decision module (where `state` is
+// defined): `Decision.T.snapshot = None` (the default, auto-injected by
+// `@@reventless.decision`) keeps full replay; `Some(config)` makes the
 // aggregate write a keep-one snapshot every `interval` events and seed cold
 // replays from the latest one. Snapshots are a read optimization only — the
 // OCC append remains the sole consistency primitive, and a missing, corrupt,
 // or schema-drifted snapshot degrades to full replay.
 //
-// Enable via the file-level attribute on a behavior file:
+// Enable via the file-level attribute on a decision file:
 //
 //   @@reventless.snapshots(100)
 //
@@ -20,7 +20,7 @@
 type config<'state> = {
   /** Write a snapshot after every N appended events. Required — no default. */
   interval: int,
-  /** Sury schema for the behavior's state — serializes the persisted snapshot
+  /** Sury schema for the decision's state — serializes the persisted snapshot
       and (hashed) gates staleness across state-shape changes. */
   stateSchema: S.t<'state>,
 }

package/src/components/StateChangeSlice.res

@@ -9,7 +9,7 @@ on no concurrent changes to the same entities.
 Plan 02 splits the merged spec into two module types:
 
 - `Spec` — types, identity, schemas. The structural contract.
-- `Behavior` — `state`, `initialState`, `evolve`, `decide`. The state machine.
+- `Decision` — `state`, `initialState`, `evolve`, `decide`. The state machine.
 
 @example
 ```rescript
@@ -43,7 +43,7 @@ let decide = (state, command) => switch command {
 */
 /**
 The lean Spec for a StateChangeSlice — types and schemas. State and
-state-evolution functions live in the sibling `Behavior` module type. A slice has
+state-evolution functions live in the sibling `Decision` module type. A slice has
 no identity of its own: it decides about the one its partition field carries.
 */
 module type Spec = {
@@ -119,12 +119,13 @@ module type Spec = {
 }
 
 /**
-The Behavior — pure state machine that decides commands and folds events.
+The Decision — pure state machine that decides commands and folds events, in
+the shape of the decider pattern. Its file is `<Slice>_Decision.res`.
 
 `module Spec: Spec` shares the lean Spec's types so `evolve` references
 `Spec.consumedEvent`, `decide` references `Spec.command`/`Spec.event`/`Spec.error`.
 */
-module type Behavior = {
+module type Decision = {
   module Spec: Spec
 
   /**
@@ -148,6 +149,6 @@ module type Behavior = {
   */
   let decide: (state, Spec.command) => result<array<Spec.event>, Spec.error>
 
-  /** File URL of this Behavior module (`import.meta.url`). */
+  /** File URL of this Decision module (`import.meta.url`). */
   let moduleUrl: string
 }

package/src/components/TaggedUnion.res

@@ -19,7 +19,7 @@ the declaration by `named` — the ppx does it for a variant a state record uses
 and a framework type carrying a union does it beside its `Semantic.mark`.
 
 A union with no name is not emitted as one. It falls through to the IR's
-`Unknown`, which is a `String` in the SDL — the behaviour that predates this
+`Unknown`, which is a `String` in the SDL — the behavior that predates this
 module — except that it is now reported at deploy time instead of silently.
 */
 let unionNameId: S.Metadata.Id.t<string> = S.Metadata.Id.make(

package/src/generator/Codegen.res

@@ -67,13 +67,13 @@ let renderAutomationSlices = (stems: array<string>): array<string> =>
   )
 
 let renderAggregates = (aggregates: array<Pairing.aggregateDef>): array<string> =>
-  aggregates->Array.flatMap(({spec, behavior, eventMappings, isAsync}) => {
+  aggregates->Array.flatMap(({spec, decision, eventMappings, isAsync}) => {
     let em = eventMappings->Option.getOr("ReventlessInfra.NoEventMappings.Make(" ++ spec ++ ")")
     let factory = isAsync ? "MakeAsync" : "Make"
     [
       "  module " ++ spec ++ "Aggregate = Platform.Aggregate." ++ factory ++ "(",
       "    " ++ spec ++ ",",
-      "    " ++ behavior ++ ",",
+      "    " ++ decision ++ ",",
       "    " ++ em ++ ",",
       "  )",
     ]
@@ -159,7 +159,7 @@ let renderExtensions = (extensions: array<string>): array<string> =>
     "  module " ++ stem ++ " = Platform.Extension.Make(" ++ stem ++ ".Mapping)"
   )
 
-// AWS-specific renderers were removed in favour of the canonical ones — the
+// AWS-specific renderers were removed in favor of the canonical ones — the
 // AWS Plugin.res now emits `open <Namespace>` so bare stems resolve, and the
 // AWS Platform.{Aggregate,ReadModel}.Make functors delegate to the
 // `*_Builder_Single` strategy under the hood (see reventless-aws/src/Platform.res).
@@ -630,7 +630,7 @@ let renderComposition = (
   // Header
   lines->Array.push("// AUTO-GENERATED — do not edit. Run `npm run generate` to update.")
   // Federation override URL — empty/unset means Auto UI renders every fragment.
-  // Read once at module init; same env var is honoured by the AWS wrapper.
+  // Read once at module init; same env var is honored by the AWS wrapper.
   lines->Array.push("")
   lines->Array.push(
     "@val external uiBundleUrl: option<string> = \"process.env." ++
@@ -877,7 +877,7 @@ let render = (
   validateSliceTargets(~resolved)
   // Chapter map, keyed by each component's spec stem (= its `Spec.name` for every
   // graph-node kind, which is how `Plugin_Structure` looks the chapter up). Filtered
-  // to the actual component stems so body files (`_Behavior`, `_Projections`, …) —
+  // to the actual component stems so body files (`_Decision`, `_Projections`, …) —
   // which `Discovery` also surfaces and which share their component's chapter — don't
   // leak noise entries into the generated call. Tasks / extensions / extension points
   // carry no chapter field, so they are excluded too.

package/src/generator/Codegen.res.mjs

@@ -42,7 +42,7 @@ function renderAggregates(aggregates) {
     return [
       "  module " + spec + "Aggregate = Platform.Aggregate." + factory + "(",
       "    " + spec + ",",
-      "    " + param.behavior + ",",
+      "    " + param.decision + ",",
       "    " + em + ",",
       "  )"
     ];

package/src/generator/Discovery.res

@@ -28,7 +28,7 @@ type discoveredFile = {
 let folderToComponentType = ComponentKind.folderToKind
 
 // The intra-plugin grouping band ("chapter") a file belongs to, derived from its
-// path relative to `src/`: the first directory segment that is not a recognised
+// path relative to `src/`: the first directory segment that is not a recognized
 // kind-folder. `src/<Chapter>/<Kind>/<Component>.res` → `Some("<Chapter>")`; a file
 // directly under a kind-folder (`src/<Kind>/<Component>.res`) or at the src root →
 // `None`. Uses the single-source `ComponentKind.isKindFolder`, so a chapter read
@@ -52,7 +52,7 @@ let chapterOf = (relPath: string): option<string> => {
 // Deduplicated (stem → chapter) pairs across the discovered files, sorted by stem
 // for deterministic codegen. Only files that carry a chapter are included; stems are
 // unique within a plugin (validated), so keying by stem cannot collide. Body files
-// (`_Behavior`, `_Projections`, …) share their component's chapter but are never
+// (`_Decision`, `_Projections`, …) share their component's chapter but are never
 // looked up by `Spec.name`, so their presence is harmless.
 let chaptersByStem = (discovered: array<discoveredFile>): array<(string, string)> => {
   let byStem: Dict.t<string> = Dict.make()
@@ -116,7 +116,7 @@ let isSkipped = (stem: string): bool =>
   // `_EventMappings` and `_Mappings` files in per-entity Aggregate/ folders
   // are picked up by the dedicated [Pairing.findEventMappings] walker;
   // treating them as Aggregate specs would hunt for a non-existent
-  // `_EventMappingsBehavior` / `_MappingsBehavior`.
+  // `_EventMappings_Decision` / `_Mappings_Decision`.
   stem->String.endsWith("_EventMappings") ||
   stem->String.endsWith("_Mappings")
 

package/src/generator/Pairing.res

@@ -1,10 +1,10 @@
 // Applies pairing rules to discovered files.
-// - Aggregates: pairs Foo + FooBehavior; finds Foo_EventMappings if present
+// - Aggregates: pairs Foo + Foo_Decision; finds Foo_EventMappings if present
 // - ReadModels: pairs FooReadModel + FooProjections; extracts mapping module names from projections file
 // - Slices (Plan 02): pair X + X_<Kind> where Kind is the implementation
 //   suffix matching the slice's folder. The slice arrays carry only spec
 //   stems; the corresponding impl stem is `<stem>_<implSuffix>`.
-//     * StateChangeSlice / StateViewSlice  → Behavior / Projection
+//     * StateChangeSlice / StateViewSlice  → Decision / Projection
 //     * AutomationSlice                    → Automation
 //     * In/OutboundTranslationSlice        → Translation
 // - ExtensionPoints: groups by epGroup, counts mappings, selects Make variant
@@ -12,7 +12,7 @@
 // Implementation-file suffix per slice kind. Used to filter impl files out
 // of the slice arrays (they're paired with their spec stems via this
 // suffix at codegen time) and to compute the impl module reference.
-let implSuffixForStateChange = "_Behavior"
+let implSuffixForStateChange = "_Decision"
 let implSuffixForStateView = "_Projection"
 let implSuffixForAutomation = "_Automation"
 let implSuffixForTranslation = "_Translation"
@@ -27,7 +27,7 @@ let isImplStem = (stem: string): bool =>
   stem->String.endsWith(implSuffixForTranslation) ||
   stem->String.endsWith(mappingsSuffixForAutomation)
 
-type aggregateDef = {spec: string, behavior: string, eventMappings: option<string>, isAsync: bool}
+type aggregateDef = {spec: string, decision: string, eventMappings: option<string>, isAsync: bool}
 // readModelDef pairs a ReadModel spec with its sibling `_Projections.res`
 // file. Codegen emits `Platform.ReadModel.Make(<spec>, <projections>)` and
 // expects the projections file to declare `let mappings` via
@@ -252,7 +252,37 @@ let groupExtensionPoints = (epFiles: array<Discovery.discoveredFile>): array<ext
   extensionPoints
 }
 
+// The logic file's former name. One beside its spec is refused rather than
+// read as a component of its own.
+let retiredSuffix = "_Behavior"
+
+let retiredBehaviorFile = (discovered: array<Discovery.discoveredFile>): option<
+  Discovery.discoveredFile,
+> => {
+  let stems = discovered->Array.map(({stem}) => stem)
+  discovered->Array.find(({stem}) =>
+    stem->String.endsWith(retiredSuffix) ||
+      (stem->String.endsWith("Behavior") &&
+        stems->Array.includes(stem->String.slice(~start=0, ~end=String.length(stem) - 8)))
+  )
+}
+
+let refuseBehaviorFiles = (discovered: array<Discovery.discoveredFile>) =>
+  switch retiredBehaviorFile(discovered) {
+  | None => ()
+  | Some({stem, relPath}) =>
+    let spec =
+      stem->String.endsWith(retiredSuffix)
+        ? stem->String.slice(~start=0, ~end=String.length(stem) - 9)
+        : stem->String.slice(~start=0, ~end=String.length(stem) - 8)
+    JsError.throwWithMessage(
+      `Generator: ${relPath} uses the former name. The logic file is now ` ++
+      `${spec}_Decision.res, annotated @@reventless.decision: rename it ` ++ `(or run reventless-rename-to-decision).`,
+    )
+  }
+
 let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): resolved => {
+  refuseBehaviorFiles(discovered)
   let eventMappings = findEventMappings(~srcDir)
 
   let stateChangeSlices = []
@@ -270,7 +300,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
   let stateChangeSliceRelPaths: Dict.t<string> = Dict.make()
   // Shared by StateViewSlice and StateViewSliceStream (stems are unique).
   let stateViewSliceRelPaths: Dict.t<string> = Dict.make()
-  let aggregateBehaviors: array<string> = []
+  let aggregateDecisions: array<string> = []
   let readModelStems: array<string> = []
   // Stream-enabled read model spec stems (the `ReadModelStream/` folder).
   let readModelStreamStems: array<string> = []
@@ -282,7 +312,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
   let extensions = []
 
   // Classify discovered files by component type. For the five slice
-  // families, impl files (X_Behavior / X_Projection / X_Automation /
+  // families, impl files (X_Decision / X_Projection / X_Automation /
   // X_Translation) are filtered out: they're paired with their spec stems
   // at codegen time via the `_<ImplKind>` suffix convention.
   discovered->Array.forEach(({stem, componentType, epGroup, relPath}) => {
@@ -318,8 +348,8 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
         outboundTranslationSliceRelPaths->Dict.set(stem, relPath)
       }
     | Aggregate =>
-      if stem->String.endsWith("Behavior") {
-        aggregateBehaviors->Array.push(stem)
+      if stem->String.endsWith("Decision") {
+        aggregateDecisions->Array.push(stem)
       } else {
         aggregateSpecs->Array.push(stem)
         aggregateSpecRelPaths->Dict.set(stem, relPath)
@@ -343,30 +373,29 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
   })
 
   // ── Aggregate pairing ──────────────────────────────────────────────────────
-  // Tries the post-Phase-3.1 `<Spec>_Behavior` form first, then falls back
-  // to the legacy `<Spec>Behavior` (no underscore).
+  // Tries `<Spec>_Decision` first, then `<Spec>Decision` (no underscore).
   let aggregates =
     aggregateSpecs
     ->sortedStems
     ->Array.filterMap(spec => {
-      let underscored = spec ++ "_Behavior"
-      let bare = spec ++ "Behavior"
-      let behaviorStem = if aggregateBehaviors->Array.includes(underscored) {
+      let underscored = spec ++ "_Decision"
+      let bare = spec ++ "Decision"
+      let decisionStem = if aggregateDecisions->Array.includes(underscored) {
         Some(underscored)
-      } else if aggregateBehaviors->Array.includes(bare) {
+      } else if aggregateDecisions->Array.includes(bare) {
         Some(bare)
       } else {
         None
       }
-      switch behaviorStem {
-      | Some(behavior) =>
+      switch decisionStem {
+      | Some(decision) =>
         let isAsync = switch Dict.get(aggregateSpecRelPaths, spec) {
         | None => false
         | Some(relPath) => hasAsyncAttribute(NodePath.join([srcDir, relPath]))
         }
         Some({
           spec,
-          behavior,
+          decision,
           eventMappings: Dict.get(eventMappings, spec),
           isAsync,
         })
@@ -386,7 +415,7 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
   // ── ReadModel pairing ──────────────────────────────────────────────────────
   // Pairs spec `<Plural>` with impl `<Plural>_Projections.res`. The legacy
   // unpaired forms (`<Plural>ReadModel.res` / `<Plural>Projections.res`) are
-  // no longer recognised — see PR3-5 of the close-ppx-gaps-and-unify-naming
+  // no longer recognized — see PR3-5 of the close-ppx-gaps-and-unify-naming
   // plan for the migration; downstream codebases should rename to the
   // underscored form.
   let pairReadModel = (~stream: bool, rm: string): option<readModelDef> => {

package/src/generator/Pairing.res.mjs

@@ -4,9 +4,10 @@ import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Generator_Node$Reventless from "./Generator_Node.res.mjs";
 
-let implSuffixForStateChange = "_Behavior";
+let implSuffixForStateChange = "_Decision";
 
 let implSuffixForStateView = "_Projection";
 
@@ -197,7 +198,34 @@ function groupExtensionPoints(epFiles) {
   return extensionPoints;
 }
 
+let retiredSuffix = "_Behavior";
+
+function retiredBehaviorFile(discovered) {
+  let stems = discovered.map(param => param.stem);
+  return discovered.find(param => {
+    let stem = param.stem;
+    if (stem.endsWith(retiredSuffix)) {
+      return true;
+    } else if (stem.endsWith("Behavior")) {
+      return stems.includes(stem.slice(0, stem.length - 8 | 0));
+    } else {
+      return false;
+    }
+  });
+}
+
+function refuseBehaviorFiles(discovered) {
+  let match = retiredBehaviorFile(discovered);
+  if (match === undefined) {
+    return;
+  }
+  let stem = match.stem;
+  let spec = stem.endsWith(retiredSuffix) ? stem.slice(0, stem.length - 9 | 0) : stem.slice(0, stem.length - 8 | 0);
+  Stdlib_JsError.throwWithMessage(`Generator: ` + match.relPath + ` uses the former name. The logic file is now ` + (spec + `_Decision.res, annotated @@reventless.decision: rename it `) + `(or run reventless-rename-to-decision).`);
+}
+
 function resolve(discovered, srcDir) {
+  refuseBehaviorFiles(discovered);
   let eventMappings = findEventMappings(srcDir);
   let stateChangeSlices = [];
   let stateViewSlices = [];
@@ -212,7 +240,7 @@ function resolve(discovered, srcDir) {
   let aggregateSpecRelPaths = {};
   let stateChangeSliceRelPaths = {};
   let stateViewSliceRelPaths = {};
-  let aggregateBehaviors = [];
+  let aggregateDecisions = [];
   let readModelStems = [];
   let readModelStreamStems = [];
   let projectionsByRelPath = {};
@@ -273,8 +301,8 @@ function resolve(discovered, srcDir) {
           return;
         }
       case "Aggregate" :
-        if (stem.endsWith("Behavior")) {
-          aggregateBehaviors.push(stem);
+        if (stem.endsWith("Decision")) {
+          aggregateDecisions.push(stem);
         } else {
           aggregateSpecs.push(stem);
           aggregateSpecRelPaths[stem] = relPath;
@@ -311,17 +339,17 @@ function resolve(discovered, srcDir) {
     }
   });
   let aggregates = Stdlib_Array.filterMap(sortedStems(aggregateSpecs), spec => {
-    let underscored = spec + "_Behavior";
-    let bare = spec + "Behavior";
-    let behaviorStem = aggregateBehaviors.includes(underscored) ? underscored : (
-        aggregateBehaviors.includes(bare) ? bare : undefined
+    let underscored = spec + "_Decision";
+    let bare = spec + "Decision";
+    let decisionStem = aggregateDecisions.includes(underscored) ? underscored : (
+        aggregateDecisions.includes(bare) ? bare : undefined
       );
-    if (behaviorStem !== undefined) {
+    if (decisionStem !== undefined) {
       let relPath = aggregateSpecRelPaths[spec];
       let isAsync = relPath !== undefined ? hasFileAttribute(Nodepath.join(srcDir, relPath), "@@reventless.async") : false;
       return {
         spec: spec,
-        behavior: behaviorStem,
+        decision: decisionStem,
         eventMappings: eventMappings[spec],
         isAsync: isAsync
       };
@@ -410,6 +438,9 @@ export {
   hasSystemCallableAttribute,
   effectiveSpecName,
   groupExtensionPoints,
+  retiredSuffix,
+  retiredBehaviorFile,
+  refuseBehaviorFiles,
   resolve,
 }
 /* node:fs Not a pure module */

package/src/lifecycle/CheckLifecycleModel.res

@@ -3,7 +3,7 @@ The lifecycle model each example's own scenarios describe, and what it says abou
 the edges each command declares beside them.
 
 `Moves([Placed], Shipped)` is authored, and until now nothing compared it to
-behaviour. The compiler resolves the state constructors and the platform checks
+behavior. The compiler resolves the state constructors and the platform checks
 they belong to the linked view — both much weaker properties than agreement: a
 command can declare `Moves([Deactivated], Active)` while its `decide` accepts an
 active row, or emit an event the view folds into something else, and every static
@@ -694,7 +694,7 @@ let observe = (
 
   scenarios->Array.filterMap(s =>
     switch s.whenElements->Array.get(0) {
-    // `thenRefused`: the caller did not own the row, which says nothing about
+    // `thenForbidden`: the caller did not own the row, which says nothing about
     // the states the command is legal in.
     | Some(_) if s.thenKind == "forbidden" => None
     | Some(command) if s.whenKind == "command" =>
@@ -935,7 +935,7 @@ let compare = (
     // effect somewhere agrees with that rather than narrowing it — the corpus
     // covers the states somebody wrote a scenario for, and silence about the
     // rest is not refusal. What DOES refute the claim is a state the command was
-    // exercised in and **refused**: that is the switch and the behaviour
+    // exercised in and **refused**: that is the switch and the behavior
     // disagreeing about the same row.
     //
     // 🚨 **Refused, not merely inert.** `Unrestricted` claims the command is

package/src/semantic/Capabilities.res

@@ -41,9 +41,9 @@ type t = {
 /**
 The capability set of a platform that provisions nothing.
 
-Every capability here answers `Unavailable`, which is a *modelled* outcome:
+Every capability here answers `Unavailable`, which is a *modeled* outcome:
 `translate` maps it to `Error`, the item is retried and the sweep surfaces it.
-That is the behaviour wanted for a deployment that simply has no geocoder — the
+That is the behavior wanted for a deployment that simply has no geocoder — the
 work stays queued and visible rather than being written off as a verdict on the
 address, which is what `NoMatch` would mean.
 

package/src/semantic/CapabilityNeed.res

@@ -47,7 +47,7 @@ let toString = (need: t): string =>
 
 /** The inverse, for readers of a persisted structure or a committed manifest.
     `None` for a capability this build does not know — a newer plugin's need is
-    reported as unrecognised, never silently dropped into a known arm. */
+    reported as unrecognized, never silently dropped into a known arm. */
 let fromString = (name: string): option<t> =>
   switch name {
   | "Geocoding" => Some(Geocoding)
@@ -65,13 +65,13 @@ Declared capability needs a platform does not provision.
 
 `declared` is `pluginStructure.requiredCapabilities` as persisted: `(capability,
 component)` pairs whose capability is a string, because a structure is replayed
-from an event log. A name this build does not recognise is **skipped** — it
+from an event log. A name this build does not recognize is **skipped** — it
 belongs to a newer framework, and refusing a deploy over a capability this code
 cannot evaluate would be a guess dressed as a check.
 
 Only what was declared. A plugin that declares nothing is unaffected: an
 unprovisioned capability it never named degrades exactly as it always has, which
-is the modelled outcome for a deployment that simply does not have one.
+is the modeled outcome for a deployment that simply does not have one.
 */
 let unmet = (~declared: array<(string, string)>, ~provisioned: array<t>): array<unmet> =>
   declared->Array.filterMap(((capability, component)) =>