@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/Runtime/AggregateRuntime_Builder_Single_Async.res

@@ -0,0 +1,285 @@
+// Async variant of AggregateRuntime_Builder_Single.
+// Uses SQS_Async (FIFO) instead of SQS_Sync — commands return CommandPending immediately.
+// Use via Platform.Aggregate.MakeAsync for high-contention aggregates where the caller
+// cannot wait for synchronous processing.
+module CommandTopicChannel = CommandTopicChannel.SQS_Async
+module EventCollectorChannel = EventCollectorChannel.DynamoDbStream
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+
+let log = ReventlessCore.Logger.fromEnv()
+
+type context = PulumiAws.Lambda.context
+type runtimeParts = Util.Lambda.runtimeParts
+
+type aggregateInfo = {
+  specModulePath: string,
+  behaviorModulePath: string,
+  eventLogTableName: Pulumi.Output.t<string>,
+}
+
+let aggregateInfos: dict<aggregateInfo> = Dict.make()
+
+// Per-flavor commandHandlerConfig override; populated by Platform.MakeWithConfig
+// from the user-supplied `commandHandlerConfig.aggregates.async` record.
+let configRef: ref<ReventlessCore.Runtime.commandHandlerConfig> = ref(
+  ({}: ReventlessCore.Runtime.commandHandlerConfig),
+)
+let setConfig = (c: ReventlessCore.Runtime.commandHandlerConfig) => configRef := c
+
+let registerAggregate = (
+  ~aggregateName,
+  ~specModulePath,
+  ~behaviorModulePath,
+  ~eventLogTableName,
+) =>
+  aggregateInfos->Dict.set(
+    aggregateName,
+    {specModulePath, behaviorModulePath, eventLogTableName},
+  )
+
+type storedSpec = {
+  aggregateName: string,
+  aggregateResource: Pulumi.Resource.t,
+  queueUrl: Pulumi.Output.t<string>,
+  queueArn: Pulumi.Output.t<string>,
+  connects: array<ReventlessCore.Runtime.connect<runtimeParts>>,
+  eventCollectorChannelSpec: option<
+    ReventlessCore.EventCollector_Adapter.channelSpec<
+      EventCollectorChannel.callbackEvent,
+      context,
+      EventCollectorChannel.channelParts,
+    >,
+  >,
+  memorySize: int,
+  timeout: int,
+}
+
+let storedSpecs: dict<storedSpec> = Dict.make()
+
+let getStoredSpec = (aggregateName, aggregateResource) =>
+  storedSpecs
+  ->Dict.get(aggregateName)
+  ->Option.getOr({
+    aggregateName,
+    aggregateResource,
+    queueUrl: ""->Pulumi.Output.make,
+    queueArn: ""->Pulumi.Output.make,
+    connects: [],
+    eventCollectorChannelSpec: None,
+    memorySize: 0,
+    timeout: 0,
+  })
+
+let forCommandGenerator: ReventlessCore.Runtime.forComponent<
+  ReventlessCore.CommandGenerator.effectEventHandler<context>,
+  runtimeParts,
+  ReventlessCore.CommandGenerator.component,
+> = (
+  ~handler as _,
+  ~connect,
+  ~memorySize=1024,
+  ~timeout=30,
+  commandGenerator,
+) => {
+  let resource = commandGenerator->ReventlessCore.Component.toPulumiResource
+  switch resource.parent {
+  | Some(aggregateResource) =>
+    let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
+    let spec = getStoredSpec(aggregateName, aggregateResource)
+    storedSpecs->Dict.set(aggregateName, {
+      ...spec,
+      connects: spec.connects->Array.concat([connect]),
+      memorySize: Math.Int.max(spec.memorySize, memorySize),
+      timeout: Math.Int.max(spec.timeout, timeout),
+    })
+  | None => ()
+  }
+}
+
+let forCommandTopic: ReventlessCore.Runtime.forComponent<
+  ReventlessCore.Runtime.effectHandler<
+    CommandTopicChannel.callbackEvent,
+    context,
+    unit,
+    string,
+  >,
+  runtimeParts,
+  ReventlessCore.CommandTopic.component<'op>,
+> = (
+  ~handler as _,
+  ~connect,
+  ~memorySize=1024,
+  ~timeout=30,
+  commandTopic,
+) => {
+  let commandTopicResource = commandTopic->ReventlessCore.Component.toPulumiResource
+  switch commandTopicResource.parent {
+  | Some(aggregateResource) =>
+    let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
+    // Extract the SQS queue from the channel parts
+    let channel = commandTopic->ReventlessCore.CommandTopic_Adapter.channel
+    let channelParts: Util.SQS.channelParts = Obj.magic(channel.parts)
+    let queue = channelParts.queue
+
+    let spec = getStoredSpec(aggregateName, aggregateResource)
+    storedSpecs->Dict.set(aggregateName, {
+      ...spec,
+      queueUrl: queue.id,
+      queueArn: queue.arn,
+      connects: spec.connects->Array.concat([connect]),
+      memorySize: Math.Int.max(spec.memorySize, memorySize),
+      timeout: Math.Int.max(spec.timeout, timeout),
+    })
+  | None =>
+    let name = commandTopicResource.name->Option.getOr("Unnamed")
+    JsError.throwWithMessage(
+      `forCommandTopic(single-async): commandTopic ${name} has no Aggregate parent`,
+    )
+  }
+}
+
+let forEventCollector: ReventlessCore.Runtime.forEventCollector<
+  ReventlessCore.Runtime.effectHandler<
+    EventCollectorChannel.callbackEvent,
+    context,
+    unit,
+    string,
+  >,
+  ReventlessCore.EventCollector.component,
+> = (
+  ~handler as _,
+  ~eventTopics,
+  ~resources,
+  ~memorySize=1024,
+  ~timeout=30,
+  eventCollector,
+) => {
+  let eventCollectorResource = eventCollector->ReventlessCore.Component.toPulumiResource
+  let channel = eventCollector->ReventlessCore.EventCollector_Adapter.channel
+  switch eventCollectorResource.parent->Option.flatMap(parent => parent.parent) {
+  | Some(aggregateResource) =>
+    let aggregateName = aggregateResource.name->Option.getOr("Unnamed")
+    let spec = getStoredSpec(aggregateName, aggregateResource)
+    storedSpecs->Dict.set(aggregateName, {
+      ...spec,
+      eventCollectorChannelSpec: Some({channel, eventTopics, resources}),
+      memorySize: Math.Int.max(spec.memorySize, memorySize),
+      timeout: Math.Int.max(spec.timeout, timeout),
+    })
+  | None =>
+    let name = eventCollectorResource.name->Option.getOr("Unnamed")
+    JsError.throwWithMessage(
+      `forEventCollector(single-async): eventCollector ${name} has no Aggregate parent`,
+    )
+  }
+}
+
+let finished = ref(false)
+
+let finish = () =>
+  if !finished.contents {
+    let specs = storedSpecs->Dict.valuesToArray
+    if specs->Array.length > 0 {
+      // See AggregateRuntime_Builder_Single.finish for the rationale behind
+      // dropping the max-of-zeros reduce in favor of `configRef`.
+      let parent = specs->Array.reduce(None, (_, {aggregateResource}) => aggregateResource.parent)
+      let cfg = configRef.contents
+      switch parent {
+      | Some(parent) =>
+        let opts = {Pulumi.ComponentResource.parent: parent}
+
+        // Build HANDLER_CONFIG as a single JSON env var.
+        // Each handler's dynamic values (table name, queue URL/ARN) are Pulumi Outputs
+        // that resolve at deploy time. Static values (module paths) are plain strings.
+        let handlerOutputs: array<Pulumi.Output.t<string>> = []
+        let packageDirs: dict<string> = Dict.make()
+
+        specs->Array.forEach(spec => {
+          switch aggregateInfos->Dict.get(spec.aggregateName) {
+          | Some(info) =>
+            let specPkg = Util_Bundle.extractPackageName(info.specModulePath)
+            let behaviorPkg = Util_Bundle.extractPackageName(info.behaviorModulePath)
+            packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+            packageDirs->Dict.set(behaviorPkg, Util_Bundle.resolvePackageRoot(behaviorPkg))
+
+            let specModule =
+              info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let behaviorModule =
+              info.behaviorModulePath->JSON.stringifyAny->Option.getOr(`""`)
+
+            let handlerJson =
+              Pulumi.Output.all3((info.eventLogTableName, spec.queueUrl, spec.queueArn))
+              ->Pulumi.Output.apply(((table, queueUrl, queueArn)) =>
+                `{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"}`
+              )
+            let _ = handlerOutputs->Array.push(handlerJson)
+          | None =>
+            log.warn(
+              ~comp="AggregateRuntime_Builder_Single_Async",
+              `no handler registered for ${spec.aggregateName}`,
+            )
+          }
+        })
+
+        let handlerConfigOutput =
+          Pulumi.Output.all(handlerOutputs)
+          ->Pulumi.Output.apply(handlers =>
+            `{"handlers":[${handlers->Array.join(",")}]}`
+          )
+
+        let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
+        envVars->Dict.set("HANDLER_CONFIG", handlerConfigOutput->Pulumi.Output.asInput)
+        // Flip AggregateEntryPoint into async mode — Route 1 (AppSync direct
+        // invoke) becomes fire-and-forget → SQS, returning CommandPending.
+        // The sync (default) builder leaves this unset.
+        envVars->Dict.set("DISPATCH_MODE", "async"->Pulumi.Input.make)
+        cfg.envVars->Option.forEach(extra =>
+          extra->Dict.forEachWithKey((value, key) => {
+            if envVars->Dict.get(key)->Option.isNone {
+              envVars->Dict.set(key, value->Pulumi.Output.make->Pulumi.Output.asInput)
+            }
+          })
+        )
+
+        // Build AssetArchive: static re-export + user packages
+        let {code, sourceCodeHash} = Util_Bundle.buildCodeArchive(
+          ~entryPointModule="@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs",
+          ~packageDirs,
+        )
+
+        cfg.sqsBatchSize->Option.forEach(CommandTopicChannel.setBatchSize)
+
+        let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
+          ~name="AllAggregatesAsyncCmdHandler",
+          ~code,
+          ~sourceCodeHash,
+          ~envVars,
+          ~memorySize=?cfg.memorySize,
+          ~timeout=?cfg.timeout,
+          ~reservedConcurrency=?cfg.reservedConcurrency,
+          ~ephemeralStorageMb=?cfg.ephemeralStorageMb,
+          ~logRetentionDays=?cfg.logRetentionDays,
+          ~opts,
+        )
+
+        specs->Array.forEach(({connects}) => {
+          connects->Array.forEach(connect => connect(~runtime))
+        })
+
+        CommandTopicChannel.clearBatchSize()
+
+        let channelSpecs =
+          specs
+          ->Array.map(({eventCollectorChannelSpec}) => eventCollectorChannelSpec)
+          ->Array.keepSome
+        let _connectResources = EventCollectorChannel.connect(
+          ~name="AllAggregatesAsync",
+          ~channelSpecs,
+          ~runtime,
+          ~opts,
+        )
+      | None => ()
+      }
+    }
+    finished := true
+  }

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

@@ -0,0 +1,212 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+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 Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
+import * as CommandTopicChannel_SQS_Async$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Async.res.mjs";
+import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let aggregateInfos = {};
+
+let configRef = {
+  contents: {}
+};
+
+function setConfig(c) {
+  configRef.contents = c;
+}
+
+function registerAggregate(aggregateName, specModulePath, behaviorModulePath, eventLogTableName) {
+  aggregateInfos[aggregateName] = {
+    specModulePath: specModulePath,
+    behaviorModulePath: behaviorModulePath,
+    eventLogTableName: eventLogTableName
+  };
+}
+
+let storedSpecs = {};
+
+function getStoredSpec(aggregateName, aggregateResource) {
+  return Stdlib_Option.getOr(storedSpecs[aggregateName], {
+    aggregateName: aggregateName,
+    aggregateResource: aggregateResource,
+    queueUrl: Pulumi.output(""),
+    queueArn: Pulumi.output(""),
+    connects: [],
+    eventCollectorChannelSpec: undefined,
+    memorySize: 0,
+    timeout: 0
+  });
+}
+
+function forCommandGenerator(param, connect, memorySizeOpt, timeoutOpt, commandGenerator) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let resource = Component$ReventlessCore.toPulumiResource(commandGenerator);
+  let aggregateResource = resource.__parentResource;
+  if (aggregateResource === undefined) {
+    return;
+  }
+  let aggregateName = Stdlib_Option.getOr(aggregateResource.__name, "Unnamed");
+  let spec = getStoredSpec(aggregateName, aggregateResource);
+  storedSpecs[aggregateName] = {
+    aggregateName: spec.aggregateName,
+    aggregateResource: spec.aggregateResource,
+    queueUrl: spec.queueUrl,
+    queueArn: spec.queueArn,
+    connects: spec.connects.concat([connect]),
+    eventCollectorChannelSpec: spec.eventCollectorChannelSpec,
+    memorySize: Math.max(spec.memorySize, memorySize),
+    timeout: Math.max(spec.timeout, timeout)
+  };
+}
+
+function forCommandTopic(param, connect, memorySizeOpt, timeoutOpt, commandTopic) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let commandTopicResource = Component$ReventlessCore.toPulumiResource(commandTopic);
+  let aggregateResource = commandTopicResource.__parentResource;
+  if (aggregateResource !== undefined) {
+    let aggregateName = Stdlib_Option.getOr(aggregateResource.__name, "Unnamed");
+    let channel = commandTopic.channel;
+    let channelParts = channel.parts;
+    let queue = channelParts.queue;
+    let spec = getStoredSpec(aggregateName, aggregateResource);
+    storedSpecs[aggregateName] = {
+      aggregateName: spec.aggregateName,
+      aggregateResource: spec.aggregateResource,
+      queueUrl: queue.id,
+      queueArn: queue.arn,
+      connects: spec.connects.concat([connect]),
+      eventCollectorChannelSpec: spec.eventCollectorChannelSpec,
+      memorySize: Math.max(spec.memorySize, memorySize),
+      timeout: Math.max(spec.timeout, timeout)
+    };
+    return;
+  }
+  let name = Stdlib_Option.getOr(commandTopicResource.__name, "Unnamed");
+  Stdlib_JsError.throwWithMessage(`forCommandTopic(single-async): commandTopic ` + name + ` has no Aggregate parent`);
+}
+
+function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeoutOpt, eventCollector) {
+  let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+  let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+  let eventCollectorResource = Component$ReventlessCore.toPulumiResource(eventCollector);
+  let channel = eventCollector.channel;
+  let aggregateResource = Stdlib_Option.flatMap(eventCollectorResource.__parentResource, parent => parent.__parentResource);
+  if (aggregateResource !== undefined) {
+    let aggregateName = Stdlib_Option.getOr(aggregateResource.__name, "Unnamed");
+    let spec = getStoredSpec(aggregateName, aggregateResource);
+    storedSpecs[aggregateName] = {
+      aggregateName: spec.aggregateName,
+      aggregateResource: spec.aggregateResource,
+      queueUrl: spec.queueUrl,
+      queueArn: spec.queueArn,
+      connects: spec.connects,
+      eventCollectorChannelSpec: {
+        channel: channel,
+        eventTopics: eventTopics,
+        resources: resources
+      },
+      memorySize: Math.max(spec.memorySize, memorySize),
+      timeout: Math.max(spec.timeout, timeout)
+    };
+    return;
+  }
+  let name = Stdlib_Option.getOr(eventCollectorResource.__name, "Unnamed");
+  Stdlib_JsError.throwWithMessage(`forEventCollector(single-async): eventCollector ` + name + ` has no Aggregate parent`);
+}
+
+let finished = {
+  contents: false
+};
+
+function finish() {
+  if (finished.contents) {
+    return;
+  }
+  let specs = Object.values(storedSpecs);
+  if (specs.length !== 0) {
+    let parent = Stdlib_Array.reduce(specs, undefined, (param, param$1) => param$1.aggregateResource.__parentResource);
+    let cfg = configRef.contents;
+    if (parent !== undefined) {
+      let opts_parent = parent;
+      let opts = {
+        parent: opts_parent
+      };
+      let handlerOutputs = [];
+      let packageDirs = {};
+      specs.forEach(spec => {
+        let info = aggregateInfos[spec.aggregateName];
+        if (info === undefined) {
+          return log.warn("AggregateRuntime_Builder_Single_Async", undefined, `no handler registered for ` + spec.aggregateName);
+        }
+        let specPkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
+        let behaviorPkg = Util_Bundle$ReventlessAws.extractPackageName(info.behaviorModulePath);
+        packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+        packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
+        let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+        let behaviorModule = Stdlib_Option.getOr(JSON.stringify(info.behaviorModulePath), `""`);
+        let handlerJson = Pulumi.all([
+          info.eventLogTableName,
+          spec.queueUrl,
+          spec.queueArn
+        ]).apply(param => `{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"}`);
+        handlerOutputs.push(handlerJson);
+      });
+      let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
+      let envVars = {};
+      envVars["HANDLER_CONFIG"] = handlerConfigOutput;
+      envVars["DISPATCH_MODE"] = "async";
+      Stdlib_Option.forEach(cfg.envVars, extra => Stdlib_Dict.forEachWithKey(extra, (value, key) => {
+        if (Stdlib_Option.isNone(envVars[key])) {
+          envVars[key] = Pulumi.output(value);
+          return;
+        }
+      }));
+      let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs", packageDirs, undefined);
+      Stdlib_Option.forEach(cfg.sqsBatchSize, CommandTopicChannel_SQS_Async$ReventlessAws.setBatchSize);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAggregatesAsyncCmdHandler", match.code, match.sourceCodeHash, envVars, cfg.memorySize, cfg.timeout, cfg.reservedConcurrency, cfg.ephemeralStorageMb, cfg.logRetentionDays, undefined, opts);
+      specs.forEach(param => {
+        param.connects.forEach(connect => connect(runtime));
+      });
+      CommandTopicChannel_SQS_Async$ReventlessAws.clearBatchSize();
+      let channelSpecs = Stdlib_Array.keepSome(specs.map(param => param.eventCollectorChannelSpec));
+      EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllAggregatesAsync", channelSpecs, runtime, opts);
+    }
+  }
+  finished.contents = true;
+}
+
+let CommandTopicChannel;
+
+let EventCollectorChannel;
+
+let RuntimeEnvironment;
+
+export {
+  CommandTopicChannel,
+  EventCollectorChannel,
+  RuntimeEnvironment,
+  log,
+  aggregateInfos,
+  configRef,
+  setConfig,
+  registerAggregate,
+  storedSpecs,
+  getStoredSpec,
+  forCommandGenerator,
+  forCommandTopic,
+  forEventCollector,
+  finished,
+  finish,
+}
+/* log Not a pure module */

package/src/adapter/Runtime/AutomationSliceEntryPoint.mjs

@@ -0,0 +1,124 @@
+// AutomationSlice Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports Spec modules,
+// supports both AutomationSlice and OutboundTranslationSlice callbacks.
+// Decodes events, runs phase1/phase2, then syncs to QueryDb.
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Chunk from "effect/Chunk";
+import { parseJsonOrThrow } from "sury/src/S.res.mjs";
+import { makeTableRef, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import { save as qdbSave } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import { Make as automationSliceCallbackMake } from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+import { Make as outboundTranslationSliceCallbackMake } from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+
+const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
+
+// Set at handler entry; read by runEffect to tag logs with the Lambda request id.
+let _currentRequestId = "unknown";
+
+function runEffect(correlationId, effect) {
+  let e = effect
+    // Promote correlationId/requestId/plugin to top-level JSON log fields —
+    // decoded by EffectLogger.install() from Effect log annotations. Harmless
+    // no-op if the unified logger isn't installed.
+    .pipe(Effect.annotateLogs("correlationId", correlationId || "unknown"))
+    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
+  if (pluginName) e = e.pipe(Effect.annotateLogs("plugin", pluginName));
+  return e
+    .pipe(Effect.provideService(requestContextTag, { correlationId: correlationId || "unknown" }))
+    .pipe(Effect.runPromise);
+}
+
+function groupBySource(records) {
+  const dict = {};
+  records.forEach(record => {
+    const arn = record.eventSourceARN;
+    const existing = dict[arn] || [];
+    dict[arn] = existing.concat([record]);
+  });
+  return dict;
+}
+
+function buildHandler(specModule, callbackMake, queryDbTableName, dcbQueueUrl) {
+  const callback = callbackMake(specModule);
+  const publishJsons = sqsPublishJsons(makeQueueRef(dcbQueueUrl), "SQS_FIFO");
+  const table = makeTableRef(queryDbTableName);
+  const rawSave = qdbSave(table);
+
+  const syncToQueryDb = async () => {
+    const items = Object.entries(callback.todoItems.contents);
+    await Promise.all(items.map(async entry => await rawSave(entry[0], entry[1], "Overwrite", undefined)));
+  };
+
+  const eventSchema = specModule.consumedEventSchema;
+
+  const jsonEventsHandler = stream => Effect.flatMap(
+    Stream.runCollect(
+      Stream.flatMap(
+        Stream.mapEffect(stream, json => Effect.sync(() => {
+          try {
+            const eventJson = json.event != null ? json.event : json;
+            return [parseJsonOrThrow(eventJson, eventSchema)];
+          } catch (exn) {
+            log.error("failed to decode event", { comp: "AutomationSliceRuntime", detail: exn && exn.message ? exn.message : String(exn) });
+            return [];
+          }
+        })),
+        events => Stream.fromIterable(events)
+      )
+    ),
+    chunk => Effect.promise(async () => {
+      const eventsArr = Chunk.toReadonlyArray(chunk);
+      callback.phase1(eventsArr);
+      await callback.phase2(publishJsons);
+      return await syncToQueryDb();
+    })
+  );
+
+  return (event, context) => handleStreamEvent(jsonEventsHandler, event, context);
+}
+
+async function buildAllHandlers() {
+  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
+  const config = JSON.parse(configStr);
+  const handlers = {};
+  await Promise.all(config.handlers.map(async h => {
+    const specModule = await dynamicImport(h.specModule);
+    const callbackMake = h.callbackType === "outbound"
+      ? prim => outboundTranslationSliceCallbackMake(prim)
+      : prim => automationSliceCallbackMake(prim);
+    const handler = buildHandler(specModule, callbackMake, h.queryDbTableName, h.dcbQueueUrl);
+    // Multiple slices can share one source stream (e.g. several automation
+    // slices reacting to the same DcbEventLog). Accumulate all handlers per
+    // source ARN; a plain assignment collapses them to one (Promise.all race),
+    // silently dropping the rest.
+    (handlers[h.sourceUrn] ||= []).push(handler);
+  }));
+  return handlers;
+}
+
+const initPromise = buildAllHandlers();
+
+export async function handler(event, context) {
+  _currentRequestId = context?.awsRequestId || "unknown";
+  const handlers = await initPromise;
+  const records = event.Records || [];
+  const grouped = groupBySource(records);
+
+  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
+    const streamHandlers = handlers[arn];
+    if (streamHandlers !== undefined && streamHandlers.length > 0) {
+      log.debug("found " + streamHandlers.length + " handler(s) for " + arn, { comp: "AutomationSliceRuntime" });
+      await Promise.all(streamHandlers.map(h =>
+        runEffect(undefined, h({ Records: subRecords }, context))
+      ));
+    } else {
+      log.warn("no handler found: " + arn, { comp: "AutomationSliceRuntime" });
+    }
+  }));
+  return "";
+}