@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
+import * as ScheduleOps$ReventlessCore from "../../util/ScheduleOps.res.mjs";
+import * as CommandTopic$ReventlessCore from "../CommandTopic/CommandTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as SideEffectHandler$ReventlessCore from "./SideEffectHandler.res.mjs";
+import * as SideEffectHandler_Callback$ReventlessCore from "./SideEffectHandler_Callback.res.mjs";
+
+function Make(RuntimeEnvironment) {
+  return EventCollectorChannel => (SpecificEventCollector => (EventCollectorRuntimeBuilder => {
+    let make = (name, sideEffects, allEventTopics, allCommandTopics, targets, queryEngine, scheduler, resourceNaming, memorySizeOpt, timeoutOpt, opts) => {
+      let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 2048;
+      let timeout = timeoutOpt !== undefined ? timeoutOpt : 180;
+      return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(SideEffectHandler$ReventlessCore.componentType), name, (extra, extra$1) => {
+        let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+        let opts = {
+          parent: opts_parent
+        };
+        let aggregateNames = Belt_SetString.fromArray(sideEffects.map(SideEffect => SideEffect.Source.name));
+        let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, aggregateNames);
+        let eventCollector = SpecificEventCollector.make(extra$1, eventTopics, opts);
+        let Callback = SideEffectHandler_Callback$ReventlessCore.Make({
+          sideEffects: sideEffects,
+          queryEngine: queryEngine
+        });
+        let handler = SpecificEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+        allCommandTopics.apply(allCommandTopics => {
+          let commandTopics = Stdlib_Option.getOr(Stdlib_Option.map(targets, targets => Object.values(CommandTopic$ReventlessCore.filter(allCommandTopics, new Set(targets)))), []);
+          let resources = commandTopics.flatMap(commandTopic => commandTopic.resources);
+          EventCollectorRuntimeBuilder.forEventCollector(handler, eventTopics, resources, memorySize, timeout, eventCollector);
+        });
+        Component$ReventlessCore.setOperations(extra, Pulumi.all([
+          Component$ReventlessCore.operations(eventCollector),
+          Adapter$ReventlessCore.resourcesToResolvedOutput(Component$ReventlessCore.outputs(eventCollector).resources)
+        ]).apply(param => {
+          let eventCollectorResources = param[1];
+          return {
+            enqueueEvent: param[0].enqueueEvent,
+            createSchedule: ScheduleOps$ReventlessCore.create(scheduler, eventCollectorResources, resourceNaming),
+            deleteSchedule: ScheduleOps$ReventlessCore.$$delete(scheduler, eventCollectorResources, resourceNaming)
+          };
+        }));
+        return Component$ReventlessCore.setOutputs(extra, {
+          name: extra$1,
+          eventCollector: Component$ReventlessCore.outputs(eventCollector)
+        });
+      }, opts);
+    };
+    return {
+      make: make
+    };
+  }));
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/SideEffectHandler/SideEffectHandler_Callback.res

@@ -0,0 +1,116 @@
+module type Spec = {
+  let sideEffects: array<module(Reventless.SideEffect.T)>
+  let queryEngine: Reventless.QueryEngine.operations
+}
+
+module type T = {
+  let handleJsonEvents: EventCollector.jsonEventsHandler
+}
+
+module Make = (Spec: Spec): T => {
+  // Pair each registered SideEffect with the variant TAGs declared by its
+  // Source.eventSchema. Used to pre-filter incoming envelopes — sibling
+  // variants on the same source that the SideEffect does not declare are
+  // silently skipped instead of producing decode-failure noise.
+  let sideEffectsWithTags =
+    Spec.sideEffects->Array.map((module(SideEffect: Reventless.SideEffect.T)) => (
+      module(SideEffect: Reventless.SideEffect.T),
+      Reventless.DcbTag.extractAllVariantNames(SideEffect.Source.eventSchema),
+    ))
+
+  // Matches an incoming event JSON to a registered SideEffect module by comparing
+  // the event's meta.service against each SideEffect.Source.name.
+  let findSideEffect = (sideEffectsWithTags, eventJson') =>
+    eventJson'
+    ->JSON.Decode.object
+    ->Option.flatMap(eventObj' => {
+      let metaJson = eventObj'->Dict.get("meta")
+      switch metaJson->Option.map(meta => meta->S.parseJsonOrThrow(Message.metaSchema)) {
+      | Some(eventMeta) =>
+        let entry =
+          sideEffectsWithTags->Array.find(((module(SideEffect: Reventless.SideEffect.T), _)) =>
+            SideEffect.Source.name == eventMeta.service
+          )
+        switch entry {
+        | None => None
+        | Some((sideEffect, acceptedTags)) =>
+          // Pre-filter by TAG: skip silently when the variant is not declared.
+          let tag =
+            eventObj'
+            ->Dict.get("event")
+            ->Option.map(Message.variantNameOfJson)
+            ->Option.getOr("unknown")
+          if !(acceptedTags->Array.includes(tag)) {
+            None
+          } else {
+            Some((eventObj', eventMeta, sideEffect))
+          }
+        }
+      | exception err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(~comp="SideEffects", `map: Couldn't decode meta: ${errMsg}`)->Effect.runSync
+        None
+      | _ =>
+        EffectLogger.logError(~comp="SideEffects", "map: Invalid JSON object")->Effect.runSync
+        None
+      }
+    })
+
+  // EventCollector handler — for each event, finds the matching SideEffect module,
+  // decodes the event id+payload, and calls SideEffect.execute.
+  // Decode and execution errors are logged and swallowed (side effects are fire-and-forget).
+  let handleJsonEvents: EventCollector.jsonEventsHandler = stream =>
+    stream
+    ->Stream.mapEffect(eventJson' =>
+      switch sideEffectsWithTags->findSideEffect(eventJson') {
+      | Some((eventObj, eventMeta, sideEffect)) =>
+        module SideEffect = unpack(sideEffect)
+        let sourceName = SideEffect.Source.name
+        EffectLogger.logInfo(
+          ~comp="SideEffectHandler",
+          `eventsHandler: handling event from source ${sourceName}: ${LogFormat.event'JsonToLogMessage(
+              eventJson',
+            )}`,
+        )->Effect.zipRight(
+          Effect.trySync(
+            ~catch=err => {
+              let errMsg = Util.Error.messageFromUnknown(err, "unknown")
+              `SideEffectHandler.eventHandler: Couldn't decode event: ${eventJson'->JSON.stringify} ${errMsg}`
+            },
+            () => {
+              let idDecoded =
+                eventObj
+                ->Dict.get("id")
+                ->Option.map(id => id->Message.decode(SideEffect.Source.Id.schema))
+              let eventDecoded =
+                eventObj
+                ->Dict.get("event")
+                ->Option.map(json => json->Message.decode(SideEffect.Source.eventSchema))
+              (idDecoded, eventDecoded)
+            },
+          )
+          ->Effect.flatMap(decoded =>
+            switch decoded {
+            | (Some(eventId), Some(event)) =>
+              Effect.tryPromise(
+                ~catch=err => {
+                  let errMsg = Util.Error.messageFromUnknown(err, "unknown")
+                  `SideEffect: Error while processing: ${errMsg}`
+                },
+                () => SideEffect.execute(eventId, eventMeta, event, Spec.queryEngine),
+              )->Effect.catchAll(errMsg => EffectLogger.logError(~comp="SideEffectHandler", errMsg))
+            | _ =>
+              EffectLogger.logError(
+                ~comp="SideEffectHandler",
+                `eventHandler: Invalid event ${eventJson'->JSON.stringify}`,
+              )
+            }
+          )
+          ->Effect.catchAll(errMsg => EffectLogger.logError(~comp="SideEffectHandler", errMsg))
+        )
+      | None => Effect.succeed()
+      }
+    )
+    ->Stream.runDrain
+}

package/src/components/SideEffectHandler/SideEffectHandler_Callback.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+function Make(Spec) {
+  let sideEffectsWithTags = Spec.sideEffects.map(SideEffect => [
+    SideEffect,
+    DcbTag$Reventless.extractAllVariantNames(SideEffect.Source.eventSchema)
+  ]);
+  let findSideEffect = (sideEffectsWithTags, eventJson$p) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(eventJson$p), eventObj$p => {
+    let metaJson = eventObj$p["meta"];
+    let eventMeta;
+    try {
+      eventMeta = Stdlib_Option.map(metaJson, meta => S.parseJsonOrThrow(meta, Message$ReventlessCore.metaSchema));
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+      Effect$1.runSync(EffectLogger$ReventlessCore.logError("SideEffects", undefined, `map: Couldn't decode meta: ` + errMsg));
+      return;
+    }
+    if (eventMeta !== undefined) {
+      let entry = sideEffectsWithTags.find(param => param[0].Source.name === eventMeta.service);
+      if (entry === undefined) {
+        return;
+      }
+      let tag = Stdlib_Option.getOr(Stdlib_Option.map(eventObj$p["event"], Message$ReventlessCore.variantNameOfJson), "unknown");
+      if (entry[1].includes(tag)) {
+        return [
+          eventObj$p,
+          eventMeta,
+          entry[0]
+        ];
+      } else {
+        return;
+      }
+    }
+    Effect$1.runSync(EffectLogger$ReventlessCore.logError("SideEffects", undefined, "map: Invalid JSON object"));
+  });
+  let handleJsonEvents = stream => Stream.runDrain(Stream.mapEffect(stream, eventJson$p => {
+    let match = findSideEffect(sideEffectsWithTags, eventJson$p);
+    if (match === undefined) {
+      return Effect$1.succeed();
+    }
+    let sideEffect = match[2];
+    let eventMeta = match[1];
+    let eventObj = match[0];
+    let sourceName = sideEffect.Source.name;
+    return Effect$1.zipRight(EffectLogger$ReventlessCore.logInfo("SideEffectHandler", undefined, `eventsHandler: handling event from source ` + sourceName + `: ` + LogFormat$ReventlessCore.event$pJsonToLogMessage(eventJson$p)), Effect$1.catchAll(Effect$1.flatMap(Effect.trySync(err => {
+      let errMsg = Util_Error$ReventlessCore.messageFromUnknown(err, "unknown");
+      return `SideEffectHandler.eventHandler: Couldn't decode event: ` + JSON.stringify(eventJson$p) + ` ` + errMsg;
+    }, () => {
+      let idDecoded = Stdlib_Option.map(eventObj["id"], id => Message$ReventlessCore.decode(id, sideEffect.Source.Id.schema));
+      let eventDecoded = Stdlib_Option.map(eventObj["event"], json => Message$ReventlessCore.decode(json, sideEffect.Source.eventSchema));
+      return [
+        idDecoded,
+        eventDecoded
+      ];
+    }), decoded => {
+      let eventId = decoded[0];
+      if (eventId !== undefined) {
+        let event = decoded[1];
+        if (event !== undefined) {
+          let event$1 = Primitive_option.valFromOption(event);
+          let eventId$1 = Primitive_option.valFromOption(eventId);
+          return Effect$1.catchAll(Effect.tryPromise(err => {
+            let errMsg = Util_Error$ReventlessCore.messageFromUnknown(err, "unknown");
+            return `SideEffect: Error while processing: ` + errMsg;
+          }, () => sideEffect.execute(eventId$1, eventMeta, event$1, Spec.queryEngine)), errMsg => EffectLogger$ReventlessCore.logError("SideEffectHandler", undefined, errMsg));
+        }
+      }
+      return EffectLogger$ReventlessCore.logError("SideEffectHandler", undefined, `eventHandler: Invalid event ` + JSON.stringify(eventJson$p));
+    }), errMsg => EffectLogger$ReventlessCore.logError("SideEffectHandler", undefined, errMsg)));
+  }));
+  return {
+    handleJsonEvents: handleJsonEvents
+  };
+}
+
+export {
+  Make,
+}
+/* S Not a pure module */

package/src/components/StateChangeSlice/StateChangeSlice.res

@@ -0,0 +1,38 @@
+let componentType = ComponentType.StateChangeSlice
+
+type t = ReventlessInfra.StateChangeSlice.t
+type outputs = ReventlessInfra.StateChangeSlice.outputs
+type operations = ReventlessInfra.StateChangeSlice.operations
+type component = Component.t<t, outputs, operations>
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.StateChangeSlice.resolvedOutputs> =>
+  outputs.resources
+  ->Adapter.resourcesToInterop
+  ->Pulumi.Output.apply(resources => {
+    let resolved: ReventlessInterop.StateChangeSlice.resolvedOutputs = {resources: resources}
+    resolved
+  })
+
+module type T = {
+  module Spec: Reventless.StateChangeSlice.Spec
+  module Behavior: Reventless.StateChangeSlice.Behavior 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>
+
+  let make: (
+    ~dcbEventLog: DcbEventLog.component,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    /** Produced event-log type→tag-key map, used to drop vacuous (type, tag)
+        clause combinations when building the decision-model query. */
+    ~tagKeysByEventType: Dict.t<array<string>>=?,
+    /** Tag keys declared `@crossPartition` across the produced event schemas.
+        A cross-partition scalar command tag fans out into its own single-tag
+        clause (instead of an AND-ed composite) so the decision read is a real
+        secondary-tag read. */
+    ~crossPartitionTagKeys: array<string>=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

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

@@ -0,0 +1,17 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  return Adapter$ReventlessCore.resourcesToInterop(outputs.resources).apply(resources => ({
+    resources: resources
+  }));
+}
+
+let componentType = "StateChangeSlice";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* Adapter-ReventlessCore Not a pure module */

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res

@@ -0,0 +1,91 @@
+let log = Logger.fromEnv()
+
+module Make = (
+  Spec: Reventless.StateChangeSlice.Spec,
+  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+): StateChangeSlice.T => {
+  module Spec = Spec
+  module Behavior = Behavior
+  let isAsync = false
+  type component = StateChangeSlice.component
+  module Callback = StateChangeSlice_Callback.Make(Spec, Behavior)
+
+  let makeJsonHandler = (~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLogOps: DcbEventLog.operations) => {
+    let handler: CommandTopic.jsonCommandsHandler = stream => {
+      let decodedStream =
+        stream
+        ->Stream.mapEffect(({ReventlessInfra.CommandTopic.reference: reference, command: json}) =>
+          Effect.sync(() =>
+            switch json->Message.decodeCommand'(Reventless.Id.String.schema, Spec.commandSchema) {
+            | command' => Some({ReventlessInfra.CommandTopic.reference, command: command'})
+            | exception err =>
+              let commandStr = json->JSON.stringify
+              log.error(
+                ~comp=`StateChangeSlice(${Spec.name})`,
+                ~data=err->JSON.stringifyAny->Option.getOr("")->JSON.Encode.string,
+                `Couldn't decode command ${commandStr}`,
+              )
+              None
+            }
+          )
+        )
+        ->Stream.flatMap(opt =>
+          switch opt {
+          | Some(v) => Stream.fromIterable([v])
+          | None => Stream.empty
+          }
+        )
+      Callback.handleCommands(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLogOps, decodedStream)
+    }
+    handler
+  }
+
+  let construct = (
+    ~dcbEventLog: DcbEventLog.component,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~tagKeysByEventType,
+    ~crossPartitionTagKeys,
+    self,
+    _name,
+  ) => {
+    let commandSchema: S.t<unknown> = Spec.commandSchema->S.castToUnknown
+    let commandTypeNames = CommandTopic.extractTypeNamesFromSchema(commandSchema)
+
+    let _ =
+      dcbEventLog
+      ->Component.operations
+      ->Pulumi.Output.apply(dcbEventLogOps => {
+        let jsonHandler = makeJsonHandler(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLogOps)
+        CommandTopic.registerHandler(
+          ~schema=commandSchema,
+          ~handler=jsonHandler,
+          ~typeNames=commandTypeNames,
+        )
+      })
+
+    self->Component.setOperations(
+      publishJsons->Pulumi.Output.apply(publishJsons => {
+        let ops: StateChangeSlice.operations = {publishJsons: publishJsons}
+        ops
+      }),
+    )
+    let outputs: StateChangeSlice.outputs = {
+      resources: (dcbEventLog->Component.outputs).resources,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (
+    ~dcbEventLog,
+    ~publishJsons,
+    ~tagKeysByEventType=Dict.make(),
+    ~crossPartitionTagKeys=[],
+    ~opts=?,
+  ): StateChangeSlice.component =>
+    Component.make(
+      ~componentType=StateChangeSlice.componentType->ComponentType.toString,
+      ~name=Spec.name,
+      ~construct=construct(~dcbEventLog, ~publishJsons, ~tagKeysByEventType, ~crossPartitionTagKeys, ...),
+      ~opts,
+    )
+}

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

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as CommandTopic$ReventlessCore from "../CommandTopic/CommandTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as StateChangeSlice$ReventlessCore from "./StateChangeSlice.res.mjs";
+import * as StateChangeSlice_Callback$ReventlessCore from "./StateChangeSlice_Callback.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function Make(Spec) {
+  return Behavior => {
+    let Callback = StateChangeSlice_Callback$ReventlessCore.Make(Spec)(Behavior);
+    let makeJsonHandler = (tagKeysByEventType, crossPartitionTagKeys, dcbEventLogOps) => (stream => {
+      let decodedStream = Stream.flatMap(Stream.mapEffect(stream, param => {
+        let reference = param.reference;
+        let json = param.command;
+        return Effect.sync(() => {
+          let command$p;
+          try {
+            command$p = Message$ReventlessCore.decodeCommand$p(json, Id$Reventless.$$String.schema, Spec.commandSchema);
+          } catch (raw_err) {
+            let err = Primitive_exceptions.internalToException(raw_err);
+            let commandStr = JSON.stringify(json);
+            log.error(`StateChangeSlice(` + Spec.name + `)`, Stdlib_Option.getOr(JSON.stringify(err), ""), `Couldn't decode command ` + commandStr);
+            return;
+          }
+          return {
+            command: command$p,
+            reference: reference
+          };
+        });
+      }), opt => {
+        if (opt !== undefined) {
+          return Stream.fromIterable([opt]);
+        } else {
+          return Stream.empty;
+        }
+      });
+      return Callback.handleCommands(tagKeysByEventType, crossPartitionTagKeys, dcbEventLogOps, decodedStream);
+    });
+    let make = (dcbEventLog, publishJsons, tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, opts) => {
+      let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
+      let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+      return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(StateChangeSlice$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
+        let commandSchema = Spec.commandSchema;
+        let commandTypeNames = CommandTopic$ReventlessCore.extractTypeNamesFromSchema(commandSchema);
+        Component$ReventlessCore.operations(dcbEventLog).apply(dcbEventLogOps => {
+          let jsonHandler = makeJsonHandler(tagKeysByEventType, crossPartitionTagKeys, dcbEventLogOps);
+          CommandTopic$ReventlessCore.registerHandler(commandSchema, jsonHandler, commandTypeNames);
+        });
+        Component$ReventlessCore.setOperations(extra, publishJsons.apply(publishJsons => ({
+          publishJsons: publishJsons
+        })));
+        let outputs = {
+          resources: Component$ReventlessCore.outputs(dcbEventLog).resources
+        };
+        return Component$ReventlessCore.setOutputs(extra, outputs);
+      }, opts);
+    };
+    return {
+      Spec: Spec,
+      Behavior: Behavior,
+      isAsync: false,
+      make: make
+    };
+  };
+}
+
+export {
+  log,
+  Make,
+}
+/* log Not a pure module */