@reventlessdev/reventless-aws 3.0.0-alpha.386 → 3.0.0-alpha.388

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -64,19 +64,19 @@ const dcbComp = (plugin) => `DcbCommandTopicRuntime(${plugin})`;
 // already-parsed `HANDLER_CONFIG` shape, with an injectable module loader.
 // In production, `buildHandler` below wraps this with the env-config + the
 // Lambda's `/var/task/node_modules` dynamic-import; integration tests inject
-// their own loader that returns pre-imported spec/behavior modules so the test
+// their own loader that returns pre-imported spec/decision modules so the test
 // can drive the real `cmdGenHandler` end-to-end against DynamoDB Local.
 export async function buildHandlersForConfig(config, opts = {}) {
   const loadModule = opts.loadModule ?? dynamicImport;
 
-  // Untyped boundary: dynamically import + id-patch the user Spec/Behavior
+  // Untyped boundary: dynamically import + id-patch the user Spec/Decision
   // modules. Their types are unknowable here — this is the one seam the typed
   // core (below) cannot own, so it stays in the shell.
   const loadedSlices = await Promise.all(
-    config.stateChangeSliceModules.map(async ({ spec, behavior }) => {
+    config.stateChangeSliceModules.map(async ({ spec, decision }) => {
       const specModule = await loadModule(spec);
-      const behaviorModule = await loadModule(behavior);
-      return { patchedSpec: patchSpecId(specModule), behaviorModule };
+      const decisionModule = await loadModule(decision);
+      return { patchedSpec: patchSpecId(specModule), decisionModule };
     })
   );
 
@@ -108,14 +108,14 @@ export async function buildHandlersForConfig(config, opts = {}) {
     publishJson: async (_name, _meta, _json) => {},
   });
 
-  loadedSlices.forEach(({ patchedSpec, behaviorModule }) => {
+  loadedSlices.forEach(({ patchedSpec, decisionModule }) => {
     // Typed core: builds the slice callback (functor), the JSON→command decode,
     // and the handleCommands invocation — all compiler-checked (was the fragile
     // positional call this file's line-146 comment warned about; see the
     // 2026-06-21 arity-drift incident referenced in the _Ops header).
     const jsonHandler = buildSliceHandler(
       patchedSpec,
-      behaviorModule,
+      decisionModule,
       scope,
       sharedDcbEventLogOps,
     );

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res

@@ -2,7 +2,7 @@
 //
 // The "typed core, thin shell" split (docs/plans/done/minimize-lambda-entrypoint-mjs-shell.md).
 // The `.mjs` shell owns the one boundary that is inherently untyped: reading
-// `HANDLER_CONFIG` and dynamically `import()`-ing user Spec/Behavior modules at
+// `HANDLER_CONFIG` and dynamically `import()`-ing user Spec/Decision modules at
 // cold start, whose types are unknowable here. Everything below is compiler-
 // checked against the *real* framework signatures, so the invariants that used
 // to live only in `.mjs` comments are now enforced by the build:
@@ -165,18 +165,18 @@ let makeStorageOps = (
 // (a labelled arg added before the positional ones shifts `stream` to
 // undefined, crashing inside `Stream.mapEffect`). Moving the functor call, the
 // JSON→command decode, and the `handleCommands` invocation here makes all three
-// compiler-checked. The loaded Spec/Behavior modules enter opaque (a clean
+// compiler-checked. The loaded Spec/Decision modules enter opaque (a clean
 // pass-through to the functor — not poked at); `dcbEventLog` enters as a
 // boundary-typed parameter (the shell still builds it).
 
 // The loaded slice's `command` type — opaque; flows from the decode straight
 // into `handleCommands`, so decode and consume share one abstract type.
 type command
-type behaviorModule
+type decisionModule
 
 @get external specCommandSchemaTyped: specModule => S.t<command> = "commandSchema"
 
-// `StateChangeSlice_Callback.Make(Spec)(Behavior)` — curried in compiled form.
+// `StateChangeSlice_Callback.Make(Spec)(Decision)` — curried in compiled form.
 type sliceCallback = {
   handleCommands: (
     ~tagKeysByEventType: dict<array<string>>=?,
@@ -195,7 +195,7 @@ type sliceCallback = {
 @module(
   "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs"
 )
-external makeSliceCallback: specModule => behaviorModule => sliceCallback = "Make"
+external makeSliceCallback: specModule => decisionModule => sliceCallback = "Make"
 
 // Builds the per-slice JSON-command handler: decode each topic item's JSON
 // command against the slice's schema (dropping undecodable ones), then dispatch
@@ -203,11 +203,11 @@ external makeSliceCallback: specModule => behaviorModule => sliceCallback = "Mak
 // `Stream.t<topicItem<JSON>> => Effect` the shell's routing map keys on.
 let buildSliceHandler = (
   spec: specModule,
-  behavior: behaviorModule,
+  decision: decisionModule,
   scope: derivedScope,
   dcbEventLog: ReventlessInfra.DcbEventLog.operations,
 ) => {
-  let callback = makeSliceCallback(spec)(behavior)
+  let callback = makeSliceCallback(spec)(decision)
   let commandSchema = spec->specCommandSchemaTyped
   (jsonStream: Stream.t<ReventlessInfra.CommandTopic.topicItem<JSON.t>, string, unit>): Effect.t<
     array<result<string, string>>,

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res.mjs

@@ -94,8 +94,8 @@ function makeStorageOps(tableName, pgConnection, scope) {
   }
 }
 
-function buildSliceHandler(spec, behavior, scope, dcbEventLog) {
-  let callback = StateChangeSlice_CallbackResMjs.Make(spec)(behavior);
+function buildSliceHandler(spec, decision, scope, dcbEventLog) {
+  let callback = StateChangeSlice_CallbackResMjs.Make(spec)(decision);
   let commandSchema = spec.commandSchema;
   return jsonStream => {
     let decodedStream = Stream.flatMap(Stream.mapEffect(jsonStream, topicItem => Effect.sync(() => {

package/src/adapter/Runtime/EventCollectorEntryPoint.mjs

@@ -1,5 +1,5 @@
 // Plugin EventCollector Lambda entry point — shared between the platform and every
-// per-plugin EventCollector Lambda. This module is plugin-agnostic: behaviour is
+// per-plugin EventCollector Lambda. This module is plugin-agnostic: behavior is
 // driven entirely by HANDLER_CONFIG.
 //
 // Thin untyped shell ("typed core, thin shell" —

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res

@@ -105,7 +105,7 @@ let makeFromCodeAsset: (
       kind; `makeFromCodeAsset` announces the provisioned Lambda to the
       `Monitoring` registry (no-op unless an extension registered a backend). */
   ~unitKind: ReventlessCore.Monitoring.unitKind,
-  /** The modelling kind of the component this Lambda runs, for resource
+  /** The modeling kind of the component this Lambda runs, for resource
       attribution (`reventless:kind`). Distinct from `~unitKind`, which grades
       the unit by what its failure means — `CommandHandler` covers aggregates,
       state-change slices and extension points alike, so it cannot identify the
@@ -251,7 +251,7 @@ let makeFromCodeAsset: (
   // ESM self-containment (Option C): every code archive built by
   // Util_Bundle.buildCodeArchive ships register-hook.mjs + layer-resolver.mjs at
   // /var/task. --import registers the resolve hook so the ESM entry point (and the
-  // user spec/behavior modules it dynamically imports) can resolve bare specifiers
+  // user spec/decision modules it dynamically imports) can resolve bare specifiers
   // — @reventlessdev/*, effect, sury from the layer, @aws-sdk/* from the runtime —
   // that ESM `import` would otherwise not find outside /var/task. Framework
   // invariant: set last so it wins over any caller-supplied value.

package/src/adapter/Runtime/RuntimeExtensionEntryPoint_Ops.res

@@ -21,7 +21,7 @@ let log = ReventlessCore.Logger.fromEnv()
 extension is registered, which is the only reason a runtime skips the seam.
 
 `modules` are npm specifiers resolvable under `/var/task/node_modules` — the
-extension packages ride in the code archive alongside the spec and behavior
+extension packages ride in the code archive alongside the spec and decision
 packages. The remaining fields are this runtime's identity, resolved at
 provisioning time from the ambient `ResourceAttribution` context.
 */
@@ -88,7 +88,7 @@ Fire every loaded extension's `onColdStart`, in the order the deploy program
 registered them, each isolated from the others (see
 `ReventlessCore.RuntimeExtension`).
 
-An unrecognised `runtimeKind` means the layer's `ComponentType` and the
+An unrecognized `runtimeKind` means the layer's `ComponentType` and the
 deploy-time one disagree — a framework version skew, not anything an extension
 can fix. Logged at ERROR and skipped rather than fired under a guessed kind: an
 extension that routes on kind would otherwise attach to the wrong runtime

package/src/adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res

@@ -27,7 +27,7 @@ type inboundSlicePaths = {
   auditTableName: Pulumi.Output.t<string>,
 }
 
-// `slicePaths`: `(specPath, behaviorPath)` per StateChangeSlice (already merged
+// `slicePaths`: `(specPath, decisionPath)` per StateChangeSlice (already merged
 // from auto- and manually-registered sources by the caller).
 let forDcbCommandTopic = (
   ~slicePaths: array<(string, string)>,
@@ -124,9 +124,9 @@ let forDcbCommandTopic = (
       envVars->Dict.set("LOG_LEVEL", level->Pulumi.Output.make->Pulumi.Output.asInput)
     )
 
-    // The slice registry: an array of {spec, behavior} objects so the entry point
+    // The slice registry: an array of {spec, decision} objects so the entry point
     // can dynamically import both modules and apply the curried StateChangeSlice_Callback.Make
-    // functor (Make(Spec)(Behavior)).
+    // functor (Make(Spec)(Decision)).
     //
     // Shipped as a `sliceModules.json` asset rather than inline in HANDLER_CONFIG.
     // Two absolute module specifiers per slice is the one term here that grows
@@ -136,10 +136,10 @@ let forDcbCommandTopic = (
     // and it fails at deploy with the registry already committed to the stack.
     let sliceModulesJson =
       slicePaths
-      ->Array.map(((specPath, behaviorPath)) => {
+      ->Array.map(((specPath, decisionPath)) => {
         let s = specPath->JSON.stringifyAny->Option.getOr(`""`)
-        let b = behaviorPath->JSON.stringifyAny->Option.getOr(`""`)
-        `{"spec":${s},"behavior":${b}}`
+        let b = decisionPath->JSON.stringifyAny->Option.getOr(`""`)
+        `{"spec":${s},"decision":${b}}`
       })
       ->Array.join(",")
 
@@ -163,7 +163,7 @@ let forDcbCommandTopic = (
     // InboundTranslationSlice modules — spec + translation paths and the resolved
     // audit table name (Pulumi-generated, so it must be resolved here). Emitted as
     // a `,"inboundTranslationSliceModules":[…]` fragment merged into HANDLER_CONFIG
-    // (absent → the entry point has no Route 0 registry, unchanged behaviour).
+    // (absent → the entry point has no Route 0 registry, unchanged behavior).
     let inboundFragment = switch inboundSlices {
     | [] => Pulumi.Output.make("")
     | slices =>
@@ -201,11 +201,11 @@ let forDcbCommandTopic = (
 
     // Build code asset
     let packageDirs: dict<string> = Dict.make()
-    slicePaths->Array.forEach(((specPath, behaviorPath)) => {
+    slicePaths->Array.forEach(((specPath, decisionPath)) => {
       let specPkg = Util_Bundle.extractPackageName(specPath)
       packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
-      let behaviorPkg = Util_Bundle.extractPackageName(behaviorPath)
-      packageDirs->Dict.set(behaviorPkg, Util_Bundle.resolvePackageRoot(behaviorPkg))
+      let decisionPkg = Util_Bundle.extractPackageName(decisionPath)
+      packageDirs->Dict.set(decisionPkg, Util_Bundle.resolvePackageRoot(decisionPkg))
     })
     // Inbound slice spec + translation packages the entry point imports for Route 0.
     inboundSlices->Array.forEach(s => {

package/src/adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res.mjs

@@ -67,7 +67,7 @@ function forDcbCommandTopic(slicePaths, inboundSlicesOpt, dcbTableName, pluginNa
   let sliceModulesJson = slicePaths.map(param => {
     let s = Stdlib_Option.getOr(JSON.stringify(param[0]), `""`);
     let b = Stdlib_Option.getOr(JSON.stringify(param[1]), `""`);
-    return `{"spec":` + s + `,"behavior":` + b + `}`;
+    return `{"spec":` + s + `,"decision":` + b + `}`;
   }).join(",");
   let pgConnectionFragment = pgSelection !== undefined ? pgSelection.connectionConfig.apply(cc => `,"pgConnection":` + JSON.stringify(PgConnection$ReventlessAws.connectionConfigToJson(pgSelection.lockStrategy, cc))) : Pulumi.output("");
   let inboundFragment = inboundSlices.length !== 0 ? Pulumi.all(inboundSlices.map(s => s.auditTableName)).apply(tableNames => {
@@ -96,8 +96,8 @@ function forDcbCommandTopic(slicePaths, inboundSlicesOpt, dcbTableName, pluginNa
   slicePaths.forEach(param => {
     let specPkg = Util_Bundle$ReventlessAws.extractPackageName(param[0]);
     packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, specPkg);
-    let behaviorPkg = Util_Bundle$ReventlessAws.extractPackageName(param[1]);
-    packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, behaviorPkg);
+    let decisionPkg = Util_Bundle$ReventlessAws.extractPackageName(param[1]);
+    packageDirs[decisionPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(undefined, decisionPkg);
   });
   inboundSlices.forEach(s => {
     let specPkg = Util_Bundle$ReventlessAws.extractPackageName(s.specPath);

package/src/adapter/StateTopic/StateTopic_AppSync.res

@@ -388,7 +388,7 @@ let finish = (~eventsApi: AppSync_EventsApi.t, ~opts: Pulumi.CustomResourceOptio
     // One EventSourceMapping per stream, all targeting the shared Lambda.
     // Retry posture: the handler throws on 5xx / network errors and logs-and-
     // continues on 4xx. `maximumRetryAttempts: 3` bounds the per-record
-    // retries so a permanently broken record (default DDB stream behaviour is
+    // retries so a permanently broken record (default DDB stream behavior is
     // -1 → forever, which would wedge the shard); `bisectBatchOnFunctionError`
     // isolates the bad record across those retries instead of redelivering
     // the whole batch each time.

package/src/capability/Capability_Messaging.res

@@ -36,7 +36,7 @@ let smsSenderKey = "messagingSmsSender"
     Blank matters because the ways to write "nothing" must not differ: a stray
     `REVENTLESS_MESSAGING_EMAIL_SENDER=` in CI, a blank line in
     `Pulumi.local.yaml`, and a key left with a space after the colon all mean the
-    stack named no sender. Honouring any of them would ask SES for an identity
+    stack named no sender. Honoring any of them would ask SES for an identity
     with a blank address — a deploy failure whose cause is whitespace, and one
     that reaches AWS before anything here explains it.
 
@@ -69,7 +69,7 @@ Which transport this stack asked for. SES is the default, so a deployment that
 says nothing gets the real one — the safe direction is that mail works, and a
 stack opting out of sending says so explicitly.
 
-An unrecognised value is refused rather than defaulted. Falling back to SES on a
+An unrecognized value is refused rather than defaulted. Falling back to SES on a
 typo would provision a real identity for a stack that asked to only log, which
 is the one mistake this key exists to prevent.
 */

package/src/components/Aggregate_Builder_Micro.res

@@ -11,7 +11,7 @@ module type MappingsConfig = {
 
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Reventless.Behavior.T with module Spec := Spec,
+  Decision: Reventless.Decision.T with module Spec := Spec,
   EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
   MappingsConfig: MappingsConfig,
 ): (
@@ -21,7 +21,7 @@ module Make = (
 ) => {
   module Inner = ReventlessCore.Aggregate_Builder.Make(
     Spec,
-    Behavior,
+    Decision,
     EventMappings,
     RuntimeEnvironment,
     CommandGeneratorResolvers,
@@ -49,7 +49,7 @@ module Make = (
     AggregateRuntimeBuilder.registerAggregate(
       ~aggregateName=Spec.name,
       ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
-      ~behaviorModulePath=Util_Bundle.getModuleSpecifier(Behavior.moduleUrl),
+      ~decisionModulePath=Util_Bundle.getModuleSpecifier(Decision.moduleUrl),
       ~eventLogTableName,
       ~mappingsModulePath=?MappingsConfig.mappingsModulePath,
     )

package/src/components/Aggregate_Builder_Micro.res.mjs

@@ -12,8 +12,8 @@ import * as EventTopicPublisher_DynamoDbStream$ReventlessAws from "../adapter/Ev
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (EventMappings => (MappingsConfig => {
-    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+  return Decision => (EventMappings => (MappingsConfig => {
+    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
       mappings: EventMappings.mappings,
       counter: EventMappings.counter
     })({
@@ -48,7 +48,7 @@ function Make(Spec) {
       let eventLogOutputs = Inner.outputs(aggregate).eventLog;
       let tableResource = eventLogOutputs.resources[0];
       let eventLogTableName = tableResource.name;
-      AggregateRuntime_Builder_Micro$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Behavior.moduleUrl), eventLogTableName, MappingsConfig.mappingsModulePath);
+      AggregateRuntime_Builder_Micro$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Decision.moduleUrl), eventLogTableName, MappingsConfig.mappingsModulePath);
       return aggregate;
     };
     let finish = () => AggregateRuntime_Builder_Micro$ReventlessAws.finish();

package/src/components/Aggregate_Builder_NoResolver.res

@@ -11,7 +11,7 @@ module AggregateRuntimeBuilder = AggregateRuntime_Builder_Single
 
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Reventless.Behavior.T with module Spec := Spec,
+  Decision: Reventless.Decision.T with module Spec := Spec,
   EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
 ): (
   ReventlessInfra.Aggregate.T
@@ -20,7 +20,7 @@ module Make = (
 ) => {
   module Inner = ReventlessCore.Aggregate_Builder.Make(
     Spec,
-    Behavior,
+    Decision,
     EventMappings,
     RuntimeEnvironment,
     CommandGeneratorResolvers,
@@ -48,7 +48,7 @@ module Make = (
     AggregateRuntimeBuilder.registerAggregate(
       ~aggregateName=Spec.name,
       ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
-      ~behaviorModulePath=Util_Bundle.getModuleSpecifier(Behavior.moduleUrl),
+      ~decisionModulePath=Util_Bundle.getModuleSpecifier(Decision.moduleUrl),
       ~eventLogTableName,
     )
 

package/src/components/Aggregate_Builder_NoResolver.res.mjs

@@ -12,8 +12,8 @@ import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/
 import * as CommandGeneratorResolvers_AppSync_NoOp$ReventlessAws from "../adapter/CommandGenerator/CommandGeneratorResolvers_AppSync_NoOp.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (EventMappings => {
-    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+  return Decision => (EventMappings => {
+    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
       mappings: EventMappings.mappings,
       counter: EventMappings.counter
     })({
@@ -48,7 +48,7 @@ function Make(Spec) {
       let eventLogOutputs = Inner.outputs(aggregate).eventLog;
       let tableResource = eventLogOutputs.resources[0];
       let eventLogTableName = tableResource.name;
-      AggregateRuntime_Builder_Single$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Behavior.moduleUrl), eventLogTableName);
+      AggregateRuntime_Builder_Single$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Decision.moduleUrl), eventLogTableName);
       return aggregate;
     };
     let finish = () => AggregateRuntime_Builder_Single$ReventlessAws.finish();

package/src/components/Aggregate_Builder_PerAggregate.res

@@ -7,7 +7,7 @@ module AggregateRuntimeBuilder = AggregateRuntime_Builder_PerAggregate
 
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Reventless.Behavior.T with module Spec := Spec,
+  Decision: Reventless.Decision.T with module Spec := Spec,
   EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
 ): (
   ReventlessInfra.Aggregate.T
@@ -16,7 +16,7 @@ module Make = (
 ) => {
   module Inner = ReventlessCore.Aggregate_Builder.Make(
     Spec,
-    Behavior,
+    Decision,
     EventMappings,
     RuntimeEnvironment,
     CommandGeneratorResolvers,
@@ -44,7 +44,7 @@ module Make = (
     AggregateRuntimeBuilder.registerAggregate(
       ~aggregateName=Spec.name,
       ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
-      ~behaviorModulePath=Util_Bundle.getModuleSpecifier(Behavior.moduleUrl),
+      ~decisionModulePath=Util_Bundle.getModuleSpecifier(Decision.moduleUrl),
       ~eventLogTableName,
     )
 

package/src/components/Aggregate_Builder_PerAggregate.res.mjs

@@ -12,8 +12,8 @@ import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/
 import * as AggregateRuntime_Builder_PerAggregate$ReventlessAws from "../adapter/Runtime/AggregateRuntime_Builder_PerAggregate.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (EventMappings => {
-    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+  return Decision => (EventMappings => {
+    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
       mappings: EventMappings.mappings,
       counter: EventMappings.counter
     })({
@@ -48,7 +48,7 @@ function Make(Spec) {
       let eventLogOutputs = Inner.outputs(aggregate).eventLog;
       let tableResource = eventLogOutputs.resources[0];
       let eventLogTableName = tableResource.name;
-      AggregateRuntime_Builder_PerAggregate$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Behavior.moduleUrl), eventLogTableName);
+      AggregateRuntime_Builder_PerAggregate$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Decision.moduleUrl), eventLogTableName);
       return aggregate;
     };
     let finish = () => AggregateRuntime_Builder_PerAggregate$ReventlessAws.finish();

package/src/components/Aggregate_Builder_Single.res

@@ -7,7 +7,7 @@ module AggregateRuntimeBuilder = AggregateRuntime_Builder_Single
 
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Reventless.Behavior.T with module Spec := Spec,
+  Decision: Reventless.Decision.T with module Spec := Spec,
   EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
 ): (
   ReventlessInfra.Aggregate.T
@@ -16,7 +16,7 @@ module Make = (
 ) => {
   module Inner = ReventlessCore.Aggregate_Builder.Make(
     Spec,
-    Behavior,
+    Decision,
     EventMappings,
     RuntimeEnvironment,
     CommandGeneratorResolvers,
@@ -53,7 +53,7 @@ module Make = (
     AggregateRuntimeBuilder.registerAggregate(
       ~aggregateName=Spec.name,
       ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
-      ~behaviorModulePath=Util_Bundle.getModuleSpecifier(Behavior.moduleUrl),
+      ~decisionModulePath=Util_Bundle.getModuleSpecifier(Decision.moduleUrl),
       ~eventLogTableName,
     )
 

package/src/components/Aggregate_Builder_Single.res.mjs

@@ -14,8 +14,8 @@ import * as EventTopicPublisher_DynamoDbStream$ReventlessAws from "../adapter/Ev
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (EventMappings => {
-    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+  return Decision => (EventMappings => {
+    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
       mappings: EventMappings.mappings,
       counter: EventMappings.counter
     })({
@@ -54,7 +54,7 @@ function Make(Spec) {
         let eventLogOutputs = Inner.outputs(aggregate).eventLog;
         eventLogTableName = eventLogOutputs.resources[0].name;
       }
-      AggregateRuntime_Builder_Single$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Behavior.moduleUrl), eventLogTableName);
+      AggregateRuntime_Builder_Single$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Decision.moduleUrl), eventLogTableName);
       return aggregate;
     };
     let finish = () => AggregateRuntime_Builder_Single$ReventlessAws.finish();

package/src/components/Aggregate_Builder_Single_Async.res

@@ -7,7 +7,7 @@ module AggregateRuntimeBuilder = AggregateRuntime_Builder_Single_Async
 
 module Make = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Reventless.Behavior.T with module Spec := Spec,
+  Decision: Reventless.Decision.T with module Spec := Spec,
   EventMappings: ReventlessInfra.EventMapper.Mappings with module Target := Spec,
 ): (
   ReventlessInfra.Aggregate.T
@@ -16,7 +16,7 @@ module Make = (
 ) => {
   module Inner = ReventlessCore.Aggregate_Builder.Make(
     Spec,
-    Behavior,
+    Decision,
     EventMappings,
     RuntimeEnvironment,
     CommandGeneratorResolvers,
@@ -53,7 +53,7 @@ module Make = (
     AggregateRuntimeBuilder.registerAggregate(
       ~aggregateName=Spec.name,
       ~specModulePath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
-      ~behaviorModulePath=Util_Bundle.getModuleSpecifier(Behavior.moduleUrl),
+      ~decisionModulePath=Util_Bundle.getModuleSpecifier(Decision.moduleUrl),
       ~eventLogTableName,
     )
 

package/src/components/Aggregate_Builder_Single_Async.res.mjs

@@ -14,8 +14,8 @@ import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../adapter/
 import * as AggregateRuntime_Builder_Single_Async$ReventlessAws from "../adapter/Runtime/AggregateRuntime_Builder_Single_Async.res.mjs";
 
 function Make(Spec) {
-  return Behavior => (EventMappings => {
-    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Behavior)({
+  return Decision => (EventMappings => {
+    let Inner = Aggregate_Builder$ReventlessCore.Make(Spec)(Decision)({
       mappings: EventMappings.mappings,
       counter: EventMappings.counter
     })({
@@ -54,7 +54,7 @@ function Make(Spec) {
         let eventLogOutputs = Inner.outputs(aggregate).eventLog;
         eventLogTableName = eventLogOutputs.resources[0].name;
       }
-      AggregateRuntime_Builder_Single_Async$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Behavior.moduleUrl), eventLogTableName);
+      AggregateRuntime_Builder_Single_Async$ReventlessAws.registerAggregate(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Decision.moduleUrl), eventLogTableName);
       return aggregate;
     };
     let finish = () => AggregateRuntime_Builder_Single_Async$ReventlessAws.finish();

package/src/components/Api/AppSync_Adapter.res

@@ -197,13 +197,13 @@ let rec waitForMergeSuccess = async (
 // the opposite of what the spec says. AppSync has no anonymous mode to emit
 // instead (`authenticationType` is API_KEY | AWS_IAM | AMAZON_COGNITO_USER_POOLS
 // | OPENID_CONNECT, and this adapter provisions Cognito primary with AWS_IAM
-// additional), so there is no directive that means "no auth". The old behaviour
+// additional), so there is no directive that means "no auth". The old behavior
 // deployed green, passed `assertGateable`, worked on the local platform — whose
-// resolvers call `Authorization.isAllowed` and honour the rule — and refused
+// resolvers call `Authorization.isAllowed` and honor the rule — and refused
 // anonymous callers only on AWS. It failed CLOSED, which is why nothing
 // surfaced it.
 //
-// Refusing follows `Auth_LoginIdentifier`'s rule for an unrecognised spelling:
+// Refusing follows `Auth_LoginIdentifier`'s rule for an unrecognized spelling:
 // a silent contradiction of the source is worse than a stopped deploy, because
 // only one of the two is discoverable. AppSync mutations have no runtime
 // authorization check to fall back on — the only `Authorization.isAllowed` call

package/src/components/Api/AppSync_SdlDecorate.res

@@ -71,7 +71,7 @@ let injectAwsSubscribe = (
 // Cognito group gate. `@aws_cognito_user_pools(cognito_groups: [...])` — NOT the
 // single-mode `@aws_auth(cognito_groups: [...])`.
 //
-// `@aws_auth` is honoured only on an API whose sole authorization mode is
+// `@aws_auth` is honored only on an API whose sole authorization mode is
 // AMAZON_COGNITO_USER_POOLS. This adapter always configures AWS_IAM as an
 // additional provider (see AppSync_Adapter's api args — the server-to-server
 // lambdas need it), so every API we provision is multi-auth and the service
@@ -323,7 +323,7 @@ let stampTypeDualAuth = (decl: string): string =>
 //
 // Two conditions, and the second is the one that matters:
 //
-//   1. A root field or object type carrying NO directive AppSync honours here
+//   1. A root field or object type carrying NO directive AppSync honors here
 //      is reachable by any authenticated Cognito caller under `ALLOW`.
 //   2. ANY `@aws_auth` at all. It is the single-mode form, silently ignored on
 //      a multi-auth API — so its presence means something believes it is gated
@@ -332,7 +332,7 @@ let stampTypeDualAuth = (decl: string): string =>
 // Condition 2 is why this is not merely "does it have a directive?". The
 // original outage had `@aws_auth(cognito_groups: ["Admin"])` present on all 18
 // admin fields for its entire life; a presence check would have passed it every
-// single time. Only a check that knows WHICH directive the service honours
+// single time. Only a check that knows WHICH directive the service honors
 // would have failed that deploy.
 let enforcedDirectives = ["@aws_cognito_user_pools", "@aws_iam"]
 

package/src/components/SideEffectHandler_PerSideEffectHandler.res

@@ -13,7 +13,7 @@
 //     in that registry, so it took the builder's `None` arm, logged
 //     "no bundled info registered", and created nothing — silently.
 //
-// Matching signatures are not matching behaviour. The registry a builder reads is
+// Matching signatures are not matching behavior. The registry a builder reads is
 // the part that has to line up: side-effect handlers need `sideEffectInfos` and
 // `SideEffectEntryPoint.mjs`, which is what `SideEffectHandler_Single` registers into.
 //

package/src/components/StateChangeSlice_Builder.res

@@ -2,15 +2,15 @@
 
 module Make = (
   Spec: Reventless.StateChangeSlice.Spec,
-  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+  Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec,
 ): (ReventlessCore.StateChangeSlice.T with module Spec = Spec) => {
   PluginRuntime_Builder.registerStateChangeSliceSpec(
     ~specPath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
-    ~behaviorPath=Util_Bundle.getModuleSpecifier(Behavior.moduleUrl),
+    ~decisionPath=Util_Bundle.getModuleSpecifier(Decision.moduleUrl),
   )
-  module Inner = ReventlessCore.StateChangeSlice_Builder.Make(Spec, Behavior)
+  module Inner = ReventlessCore.StateChangeSlice_Builder.Make(Spec, Decision)
   module Spec = Spec
-  module Behavior = Behavior
+  module Decision = Decision
   let isAsync = Inner.isAsync
   type component = Inner.component
   let make = Inner.make

package/src/components/StateChangeSlice_Builder.res.mjs

@@ -5,12 +5,12 @@ import * as PluginRuntime_Builder$ReventlessAws from "../plugin/runtime/PluginRu
 import * as StateChangeSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Builder.res.mjs";
 
 function Make(Spec) {
-  return Behavior => {
-    PluginRuntime_Builder$ReventlessAws.registerStateChangeSliceSpec(Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Behavior.moduleUrl));
-    let Inner = StateChangeSlice_Builder$ReventlessCore.Make(Spec)(Behavior);
+  return Decision => {
+    PluginRuntime_Builder$ReventlessAws.registerStateChangeSliceSpec(Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Decision.moduleUrl));
+    let Inner = StateChangeSlice_Builder$ReventlessCore.Make(Spec)(Decision);
     return {
       Spec: Spec,
-      Behavior: Behavior,
+      Decision: Decision,
       isAsync: Inner.isAsync,
       make: Inner.make
     };

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -93,7 +93,7 @@ let messagingProvisioned = () => messagingProvisionedRef.contents
 
 type sliceModulePaths = {
   specPath: string,
-  behaviorPath: string,
+  decisionPath: string,
 }
 
 type dcbConfig = {
@@ -110,8 +110,8 @@ let dcbConfigRef: ref<dcbConfig> = ref({
 
 let registeredSliceModulePaths: array<sliceModulePaths> = []
 
-let registerStateChangeSliceSpec = (~specPath: string, ~behaviorPath: string) => {
-  let _ = registeredSliceModulePaths->Array.push({specPath, behaviorPath})
+let registerStateChangeSliceSpec = (~specPath: string, ~decisionPath: string) => {
+  let _ = registeredSliceModulePaths->Array.push({specPath, decisionPath})
 }
 
 // InboundTranslationSlice registration for the shared DCB command Lambda. Unlike
@@ -933,7 +933,7 @@ module Make = (
     let slicePaths =
       registeredSliceModulePaths
       ->Array.concat(dcbConfig.stateChangeSliceModulePaths)
-      ->Array.map(({specPath, behaviorPath}) => (specPath, behaviorPath))
+      ->Array.map(({specPath, decisionPath}) => (specPath, decisionPath))
     // Drop registrations that never received their module paths (a bare
     // audit-table registration with no matching spec functor — shouldn't happen,
     // but keeps a half-registered slice out of HANDLER_CONFIG).