@reventlessdev/online-shop-hybrid-ordering 1.0.0-alpha.178 → 1.0.0-alpha.180

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.180 (2026-08-03)
+
+### Features
+
+* **aws:** let a deployment hand its plugins a geocoder ([143bf41](https://github.com/ReventlessDev/reventless-core/commit/143bf4137765362ce07dd42db0f4a57057da9f13))
+* **outbound:** let an outbound slice read an aggregate, and geocode addresses with it ([867e63e](https://github.com/ReventlessDev/reventless-core/commit/867e63e774ebc8b78b2b19c78645c8a12a8d06f6))
+
+
+# 1.0.0-alpha.179 (2026-08-02)
+
+**Note:** Version bump only for package @reventlessdev/online-shop-hybrid-ordering
+
+
+
+
+
 # 1.0.0-alpha.178 (2026-08-02)
 
 **Note:** Version bump only for package @reventlessdev/online-shop-hybrid-ordering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/online-shop-hybrid-ordering",
-  "version": "1.0.0-alpha.178",
+  "version": "1.0.0-alpha.180",
   "description": "Online Shop Hybrid example — Ordering plugin (Customer aggregate + Order/CatalogProduct DCB)",
   "license": "Apache-2.0",
   "jest": {
@@ -21,18 +21,18 @@
   },
   "dependencies": {
     "sury": "^11.0.0-alpha.4",
-    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.91",
-    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.91",
+    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.93",
+    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.93",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.121",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.151",
-    "@reventlessdev/reventless-local": "3.0.0-alpha.192",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.96"
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.153",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.123",
+    "@reventlessdev/reventless-local": "3.0.0-alpha.194",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.98"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.60"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.62"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/Customer/Aggregate/Customer.res

@@ -8,12 +8,35 @@
 // already stored decodes unchanged — and the declaration buys the range checks
 // at the boundary and the marker the command form and the map view read, instead
 // of both being inferred from the field names.
+// A human enters an address and nothing else. `GeocodeCustomerAddress` — an
+// OutboundTranslationSlice subscribed to this aggregate — turns that address
+// into a point and reports the outcome back through the two `@noApi` commands
+// below.
+//
+// The rule that shapes this API: **whoever supplies a point supplies the address
+// it belongs to.** So a caller never sends a bare coordinate — `SetLocation` is
+// the slice's shape, not a client's, and stays internal. A UI corrects a row
+// through `SetAddressLocation`, which covers the pin-only fix too (same address,
+// new point).
+//
+// The two are not interchangeable even though their payloads nearly are. The
+// slice's `SetLocation` is a *report about a past address* and loses to a
+// subsequent change; `SetAddressLocation` is an *assertion about the present* and
+// wins. That is the whole reason `resolvedFrom` exists.
 @schema
 type command =
   | Register({email: string, address: string})
   | UpdateEmail({email: string})
+  // Change the address and let the geocoder find the point.
   | UpdateAddress({address: string})
-  | SetLocation({location: Reventless.GeoPoint.t})
+  // Change the address *and* say where it is — a client that already has a point
+  // (it geocoded, or a human dragged the pin). Suppresses the geocoder for this
+  // address, because there is nothing left to look up.
+  | SetAddressLocation({address: string, location: Reventless.GeoPoint.t})
+  // `resolvedFrom` is a staleness token as much as provenance: an answer for an
+  // address that has since changed is dropped rather than applied.
+  | @noApi SetLocation({location: Reventless.GeoPoint.t, resolvedFrom: string})
+  | @noApi MarkAddressUnresolvable({address: string, reason: string})
   | Deactivate
 
 @schema
@@ -21,7 +44,21 @@ type event =
   | Registered({email: string, address: string})
   | EmailUpdated({email: string})
   | AddressUpdated({address: string})
-  | LocationSet({location: Reventless.GeoPoint.t})
+  // `resolvedFrom` is the address this point was derived from — provenance, not
+  // the address of record. Keeping it separate is what makes "is the pin still
+  // current?" a decidable question instead of an assumption, and it is what the
+  // slice reads to know whether an address still needs geocoding.
+  | LocationSet({location: Reventless.GeoPoint.t, resolvedFrom: string})
+  // A client supplied both halves at once. Deliberately *not* `AddressUpdated` +
+  // `LocationSet`: the geocoding slice collects `AddressUpdated`, so emitting it
+  // here would spend a request re-geocoding an address a human just pinned by
+  // hand, then race the machine's answer against theirs. This event is not in
+  // the slice's consumed set, so the slice stands down.
+  | AddressLocated({address: string, location: Reventless.GeoPoint.t})
+  // The geocoder answered and had nothing usable. A fact rather than an absence:
+  // `location: None` already means "not looked up yet", and one state meaning
+  // two things is one nobody can act on.
+  | AddressUnresolvable({address: string, reason: string})
   | Deactivated
 
 @schema

package/src/Customer/Aggregate/Customer.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
 
 let commandSchema = S.union([
@@ -18,9 +19,20 @@ let commandSchema = S.union([
     address: s.m(S.string)
   })),
   S.schema(s => ({
-    TAG: "SetLocation",
+    TAG: "SetAddressLocation",
+    address: s.m(S.string),
     location: s.m(GeoPoint$Reventless.schema)
   })),
+  S.schema(s => ({
+    TAG: "SetLocation",
+    location: s.m(GeoPoint$Reventless.schema),
+    resolvedFrom: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "MarkAddressUnresolvable",
+    address: s.m(S.string),
+    reason: s.m(S.string)
+  })),
   S.literal("Deactivate")
 ]);
 
@@ -40,8 +52,19 @@ let eventSchema = S.union([
   })),
   S.schema(s => ({
     TAG: "LocationSet",
+    location: s.m(GeoPoint$Reventless.schema),
+    resolvedFrom: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "AddressLocated",
+    address: s.m(S.string),
     location: s.m(GeoPoint$Reventless.schema)
   })),
+  S.schema(s => ({
+    TAG: "AddressUnresolvable",
+    address: s.m(S.string),
+    reason: s.m(S.string)
+  })),
   S.literal("Deactivated")
 ]);
 
@@ -51,6 +74,11 @@ let errorSchema = S.union([
   S.literal("CustomerAlreadyDeactivated")
 ]);
 
+let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
+  "SetLocation",
+  "MarkAddressUnresolvable"
+]);
+
 function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
@@ -64,9 +92,9 @@ let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Customer/Aggrega
 export {
   name,
   Id,
-  commandSchema,
   eventSchema,
   errorSchema,
+  commandSchema$1 as commandSchema,
   moduleUrl,
   commandAuthorization,
 }

package/src/Customer/Aggregate/Customer_Behavior.res

@@ -3,21 +3,47 @@
 
 @@reventless.behavior
 
+// `location` and `locationResolvedFrom` are separate fields rather than one,
+// because there are three states and a lone `option` can only express two: no
+// attempt yet, a point found, and an address *tried and found wanting* (which
+// has a resolved-from but no point). The read model surfaces the same three.
+//
+// The invariant they maintain: `locationResolvedFrom` is either `None` or equal
+// to `address`. Every arm below preserves it, and it is what makes "is this pin
+// still current?" a decidable question rather than an assumption.
 @schema
 type state =
   | NotCreated
-  | Active({email: string, address: string})
+  | Active({
+      email: string,
+      address: string,
+      location: option<Reventless.GeoPoint.t>,
+      locationResolvedFrom: option<string>,
+    })
   | Deactivated
 
 let initialState = NotCreated
 
 let evolve = (state, event) =>
   switch (state, event) {
-  | (NotCreated, Registered({email, address})) => Active({email, address})
-  | (Active(_), Registered({email, address})) => Active({email, address})
+  | (NotCreated, Registered({email, address})) =>
+    Active({email, address, location: None, locationResolvedFrom: None})
+  | (Active(s), Registered({email, address})) => Active({...s, email, address})
   | (Active(s), EmailUpdated({email})) => Active({...s, email})
-  | (Active(s), AddressUpdated({address})) => Active({...s, address})
-  | (Active(_), LocationSet(_)) => state
+  // A new address invalidates whatever was known about the old one — dropping
+  // both is what puts the row back in front of the geocoding slice.
+  | (Active(s), AddressUpdated({address})) =>
+    Active({...s, address, location: None, locationResolvedFrom: None})
+  | (Active(s), LocationSet({location, resolvedFrom})) =>
+    Active({...s, location: Some(location), locationResolvedFrom: Some(resolvedFrom)})
+  // Both halves at once, from a client. `locationResolvedFrom` is the address
+  // itself: the caller supplied the pair, so there is nothing left to resolve.
+  | (Active(s), AddressLocated({address, location})) =>
+    Active({...s, address, location: Some(location), locationResolvedFrom: Some(address)})
+  // Tried, and no usable answer. Recording the address keeps the slice from
+  // handing it back for another round.
+  | (Active(s), AddressUnresolvable({address})) =>
+    Active({...s, location: None, locationResolvedFrom: Some(address)})
   | (Active(_), Customer.Deactivated) => Deactivated
   | (Deactivated, _) => state
   | (NotCreated, _) => state
@@ -28,18 +54,55 @@ let decide = (state, command) =>
   | (NotCreated, Register({email, address})) => Ok([Registered({email, address})])
   | (NotCreated, UpdateEmail(_)) => Error(CustomerNotFound)
   | (NotCreated, UpdateAddress(_)) => Error(CustomerNotFound)
+  | (NotCreated, SetAddressLocation(_)) => Error(CustomerNotFound)
+  | (NotCreated, SetLocation(_)) => Error(CustomerNotFound)
+  | (NotCreated, MarkAddressUnresolvable(_)) => Error(CustomerNotFound)
   | (NotCreated, Deactivate) => Error(CustomerNotFound)
+
   | (Active(_), Register(_)) => Error(CustomerAlreadyRegistered)
   | (Active(s), UpdateEmail({email})) if email == s.email => Ok([])
   | (Active(_), UpdateEmail({email})) => Ok([EmailUpdated({email: email})])
   | (Active(s), UpdateAddress({address})) if address == s.address => Ok([])
   | (Active(_), UpdateAddress({address})) => Ok([AddressUpdated({address: address})])
-  | (Active(_), SetLocation({location})) => Ok([LocationSet({location: location})])
+
+  // Client-supplied pair. Idempotent only when *both* halves already match —
+  // same address with a different point is a pin correction, and swallowing it
+  // would lose the one edit a human came here to make.
+  | (Active(s), SetAddressLocation({address, location}))
+    if address == s.address && s.location == Some(location) => Ok([])
+  | (Active(_), SetAddressLocation({address, location})) =>
+    Ok([AddressLocated({address, location})])
+
+  // Stale: the slice is reporting on an address this customer has since moved
+  // off. Applying it would pin the row's new address at the old one's point,
+  // with nothing to say the two disagree.
+  | (Active(s), SetLocation({resolvedFrom})) if resolvedFrom != s.address => Ok([])
+  // Redelivery. Commands arrive at-least-once and the slice re-publishes on
+  // every heartbeat sweep until its TODO row clears, so without this an
+  // unchanged answer appends a duplicate event on every pass.
+  | (Active(s), SetLocation({location, resolvedFrom}))
+    if s.location == Some(location) && s.locationResolvedFrom == Some(resolvedFrom) => Ok([])
+  | (Active(_), SetLocation({location, resolvedFrom})) =>
+    Ok([LocationSet({location, resolvedFrom})])
+
+  // Same two guards, for the verdict: stale reports are dropped, and a repeated
+  // verdict on the same address is a no-op.
+  | (Active(s), MarkAddressUnresolvable({address})) if address != s.address => Ok([])
+  | (Active(s), MarkAddressUnresolvable({address})) if s.locationResolvedFrom == Some(address) =>
+    Ok([])
+  | (Active(_), MarkAddressUnresolvable({address, reason})) =>
+    Ok([AddressUnresolvable({address, reason})])
+
   | (Active(_), Deactivate) => Ok([Customer.Deactivated])
-  | (NotCreated, SetLocation(_)) => Error(CustomerNotFound)
+
   | (Deactivated, Register(_)) => Error(CustomerAlreadyDeactivated)
   | (Deactivated, UpdateEmail(_)) => Error(CustomerAlreadyDeactivated)
   | (Deactivated, UpdateAddress(_)) => Error(CustomerAlreadyDeactivated)
-  | (Deactivated, SetLocation(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated, SetAddressLocation(_)) => Error(CustomerAlreadyDeactivated)
+  // A deactivated customer has no location work owing — swallow rather than
+  // error, so an in-flight geocode landing after deactivation does not park a
+  // TODO row in Failed forever.
+  | (Deactivated, SetLocation(_)) => Ok([])
+  | (Deactivated, MarkAddressUnresolvable(_)) => Ok([])
   | (Deactivated, Deactivate) => Ok([]) // idempotent
   }

package/src/Customer/Aggregate/Customer_Behavior.res.mjs

@@ -1,13 +1,17 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
 
 let stateSchema = S.union([
   S.literal("NotCreated"),
   S.schema(s => ({
     TAG: "Active",
     email: s.m(S.string),
-    address: s.m(S.string)
+    address: s.m(S.string),
+    location: s.m(S.option(GeoPoint$Reventless.schema)),
+    locationResolvedFrom: s.m(S.option(S.string))
   })),
   S.literal("Deactivated")
 ]);
@@ -18,7 +22,9 @@ function evolve(state, event) {
       return {
         TAG: "Active",
         email: event.email,
-        address: event.address
+        address: event.address,
+        location: undefined,
+        locationResolvedFrom: undefined
       };
     } else {
       return state;
@@ -32,22 +38,51 @@ function evolve(state, event) {
       return {
         TAG: "Active",
         email: event.email,
-        address: event.address
+        address: event.address,
+        location: state.location,
+        locationResolvedFrom: state.locationResolvedFrom
       };
     case "EmailUpdated" :
       return {
         TAG: "Active",
         email: event.email,
-        address: state.address
+        address: state.address,
+        location: state.location,
+        locationResolvedFrom: state.locationResolvedFrom
       };
     case "AddressUpdated" :
       return {
         TAG: "Active",
         email: state.email,
-        address: event.address
+        address: event.address,
+        location: undefined,
+        locationResolvedFrom: undefined
       };
     case "LocationSet" :
-      return state;
+      return {
+        TAG: "Active",
+        email: state.email,
+        address: state.address,
+        location: event.location,
+        locationResolvedFrom: event.resolvedFrom
+      };
+    case "AddressLocated" :
+      let address = event.address;
+      return {
+        TAG: "Active",
+        email: state.email,
+        address: address,
+        location: event.location,
+        locationResolvedFrom: address
+      };
+    case "AddressUnresolvable" :
+      return {
+        TAG: "Active",
+        email: state.email,
+        address: state.address,
+        location: undefined,
+        locationResolvedFrom: event.address
+      };
   }
 }
 
@@ -69,70 +104,136 @@ function decide(state, command) {
             }]
         };
       }
-    } else if (typeof command !== "object") {
+    }
+    if (typeof command !== "object") {
       return {
         TAG: "Ok",
         _0: []
       };
-    } else {
-      return {
-        TAG: "Error",
-        _0: "CustomerAlreadyDeactivated"
-      };
     }
-  }
-  if (typeof command !== "object") {
-    return {
-      TAG: "Ok",
-      _0: ["Deactivated"]
-    };
-  }
-  switch (command.TAG) {
-    case "Register" :
-      return {
-        TAG: "Error",
-        _0: "CustomerAlreadyRegistered"
-      };
-    case "UpdateEmail" :
-      let email = command.email;
-      if (email === state.email) {
-        return {
-          TAG: "Ok",
-          _0: []
-        };
-      } else {
-        return {
-          TAG: "Ok",
-          _0: [{
-              TAG: "EmailUpdated",
-              email: email
-            }]
-        };
-      }
-    case "UpdateAddress" :
-      let address = command.address;
-      if (address === state.address) {
+    switch (command.TAG) {
+      case "SetLocation" :
+      case "MarkAddressUnresolvable" :
         return {
           TAG: "Ok",
           _0: []
         };
-      } else {
+      default:
         return {
-          TAG: "Ok",
-          _0: [{
-              TAG: "AddressUpdated",
-              address: address
-            }]
+          TAG: "Error",
+          _0: "CustomerAlreadyDeactivated"
         };
-      }
-    case "SetLocation" :
+    }
+  } else {
+    if (typeof command !== "object") {
       return {
         TAG: "Ok",
-        _0: [{
-            TAG: "LocationSet",
-            location: command.location
-          }]
+        _0: ["Deactivated"]
       };
+    }
+    switch (command.TAG) {
+      case "Register" :
+        return {
+          TAG: "Error",
+          _0: "CustomerAlreadyRegistered"
+        };
+      case "UpdateEmail" :
+        let email = command.email;
+        if (email === state.email) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "EmailUpdated",
+                email: email
+              }]
+          };
+        }
+      case "UpdateAddress" :
+        let address = command.address;
+        if (address === state.address) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "AddressUpdated",
+                address: address
+              }]
+          };
+        }
+      case "SetAddressLocation" :
+        let location = command.location;
+        let address$1 = command.address;
+        if (address$1 === state.address && Primitive_object.equal(state.location, location)) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "AddressLocated",
+                address: address$1,
+                location: location
+              }]
+          };
+        }
+      case "SetLocation" :
+        let resolvedFrom = command.resolvedFrom;
+        if (resolvedFrom !== state.address) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        }
+        let location$1 = command.location;
+        if (Primitive_object.equal(state.location, location$1) && Primitive_object.equal(state.locationResolvedFrom, resolvedFrom)) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "LocationSet",
+                location: location$1,
+                resolvedFrom: resolvedFrom
+              }]
+          };
+        }
+      case "MarkAddressUnresolvable" :
+        let address$2 = command.address;
+        if (address$2 !== state.address) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else if (Primitive_object.equal(state.locationResolvedFrom, address$2)) {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "AddressUnresolvable",
+                address: address$2,
+                reason: command.reason
+              }]
+          };
+        }
+    }
   }
 }
 

package/src/Customer/OutboundTranslationSlice/GeocodeCustomerAddress.res

@@ -0,0 +1,40 @@
+// GeocodeCustomerAddress OutboundTranslationSlice.
+//
+// A human enters an address and nothing else. This slice turns that address into
+// a point by asking Amazon Location, and reports the outcome back to the Customer
+// aggregate — `SetLocation` when it is sure, `MarkAddressUnresolvable` when it is
+// not. Neither command is callable from the API; see `Customer.res`.
+//
+// This is the *unattended* path. A client that can geocode for itself would send
+// the point with the command and never reach here — `collect` is where that
+// future arm goes, and it is the only place this slice would need to change.
+
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | Registered({email: string, address: string})
+  | AddressUpdated({address: string})
+
+@schema
+type outboundItem = {customerId: string, address: string}
+
+@schema
+type inboundCommand =
+  | SetLocation({location: Reventless.GeoPoint.t, resolvedFrom: string})
+  | MarkAddressUnresolvable({address: string, reason: string})
+
+// Retries here are for a geocoder that is *down*, not for one that has answered.
+// An address the service has no match for is resolved by publishing
+// `MarkAddressUnresolvable`, not by trying again three times.
+let maxRetries = 3
+let heartbeatInterval = 60
+let targetName = Some("Customer")
+
+// The Customer aggregate, by its Spec.name — the capability that made this slice
+// possible at all. Before it, an outbound slice could only read its plugin's DCB
+// event log, and a customer's lifecycle is an aggregate.
+let sourceNames = ["Customer"]
+
+// Drawn as an external box outside the Ordering plugin in the Event Graph.
+let externalSystem = Some("AwsLocation")

package/src/Customer/OutboundTranslationSlice/GeocodeCustomerAddress.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as GeoPoint$Reventless from "@reventlessdev/reventless-spec/src/semantic/GeoPoint.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "Registered",
+    email: s.m(S.string),
+    address: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "AddressUpdated",
+    address: s.m(S.string)
+  }))
+]);
+
+let outboundItemSchema = S.schema(s => ({
+  customerId: s.m(S.string),
+  address: s.m(S.string)
+}));
+
+let inboundCommandSchema = S.union([
+  S.schema(s => ({
+    TAG: "SetLocation",
+    location: s.m(GeoPoint$Reventless.schema),
+    resolvedFrom: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "MarkAddressUnresolvable",
+    address: s.m(S.string),
+    reason: s.m(S.string)
+  }))
+]);
+
+let sourceNames = ["Customer"];
+
+let name = "GeocodeCustomerAddress";
+
+let Id;
+
+let maxRetries = 3;
+
+let heartbeatInterval = 60;
+
+let targetName = "Customer";
+
+let externalSystem = "AwsLocation";
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Customer/OutboundTranslationSlice/GeocodeCustomerAddress.res.mjs";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  outboundItemSchema,
+  inboundCommandSchema,
+  maxRetries,
+  heartbeatInterval,
+  targetName,
+  sourceNames,
+  externalSystem,
+  moduleUrl,
+}
+/* consumedEventSchema Not a pure module */