@reventlessdev/reventless-aws 3.0.0-alpha.232 → 3.0.0-alpha.233

package/src/adapter/Runtime/AutomationSliceEntryPoint.mjs

@@ -1,138 +1,54 @@
-// 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.
+// AutomationSlice / OutboundTranslationSlice Lambda entry point.
+// At cold start: reads HANDLER_CONFIG, dynamically imports each slice's spec +
+// body modules, applies the curried callback functor, and routes stream events
+// by source URN.
+//
+// Thin untyped shell ("typed core, thin shell" —
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md): this file owns ONLY the
+// inherently-untyped seam — the dynamic `import()` of the spec + body modules
+// named in HANDLER_CONFIG and the curried functor applications consuming them
+// (AutomationSlice_Callback.Make(Spec)(Automation) /
+// OutboundTranslationSlice_Callback.Make(Spec)(Translation)). Everything else
+// (HANDLER_CONFIG parsing, the phase-1/phase-2 pipelines, the TODO-list
+// QueryDb sync, the routed dispatch boundary) lives type-checked in
+// AutomationSliceEntryPoint_Ops.res / StreamRoutedEntryPoint_Ops.res.
 
-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,
-  runEffect,
-  setRequestId,
-  extractMetaField,
-  extractSentTimestamp,
-  extractRetryCount,
-} from "./HandlerFactoryHelpers.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";
+import * as StreamOps from "./StreamRoutedEntryPoint_Ops.res.mjs";
+import * as Ops from "./AutomationSliceEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
-// Same comp the slice's own callback logs under (AutomationSlice_Callback /
-// OutboundTranslationSlice_Callback), so a filter catches both the framework's
-// lines and the application handler's.
-const sliceComp = (callbackType, sliceName) =>
-  callbackType === "outbound"
-    ? `OutboundTranslationSlice(${sliceName})`
-    : `AutomationSlice(${sliceName})`;
-
-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. Each keeps its own comp — that is what
-    // separates co-hosted slices in the log stream.
-    (handlers[h.sourceUrn] ||= []).push({
-      handler,
-      comp: sliceComp(h.callbackType, specModule.name),
-    });
-  }));
-  return handlers;
-}
-
-const initPromise = buildAllHandlers();
+  const entries = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "");
 
-export async function handler(event, context) {
-  setRequestId(context?.awsRequestId);
-  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" });
-      const correlationId = extractMetaField(subRecords, "correlationId");
-      const causationId = extractMetaField(subRecords, "causationId");
-      const timestamp = extractSentTimestamp(subRecords);
-      const retryCount = extractRetryCount(subRecords);
-      await Promise.all(streamHandlers.map(({ handler: h, comp }) =>
-        runEffect(h({ Records: subRecords }, context), {
-          correlationId,
-          causationId,
-          comp,
-          timestamp,
-          retryCount,
-        })
-      ));
-    } else {
-      log.warn("no handler found: " + arn, { comp: "AutomationSliceRuntime" });
+  await Promise.all(entries.map(async (entry) => {
+    if (!entry.bodyModule) {
+      Ops.warnMissingBodyModule(entry);
+      return;
     }
+    const [specModule, bodyModule] = await Promise.all([
+      dynamicImport(entry.specModule),
+      dynamicImport(entry.bodyModule),
+    ]);
+    const registered = entry.callbackType === "outbound"
+      ? Ops.makeOutboundRegisteredHandler(
+          entry,
+          specModule.name,
+          specModule.consumedEventSchema,
+          outboundTranslationSliceCallbackMake(specModule)(bodyModule)
+        )
+      : Ops.makeAutomationRegisteredHandler(
+          entry,
+          specModule.name,
+          automationSliceCallbackMake(specModule)(bodyModule)
+        );
+    StreamOps.addToRegistry(handlers, entry.sourceUrn, registered);
   }));
-  return "";
+
+  return handlers;
 }
+
+export const handler = StreamOps.makeRoutedHandler("AutomationSliceRuntime", buildAllHandlers());

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -0,0 +1,246 @@
+// Typed cold-start core for the AutomationSlice / OutboundTranslationSlice
+// Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// AutomationSliceEntryPoint.mjs keeps only the inherently-untyped seam — the
+// dynamic `import()` of the spec + body modules named in HANDLER_CONFIG and
+// the curried callback-functor applications consuming them
+// (AutomationSlice_Callback.Make(Spec)(Automation) /
+// OutboundTranslationSlice_Callback.Make(Spec)(Translation)). HANDLER_CONFIG
+// parsing, the two phase-1/phase-2 pipelines, the TODO-list QueryDb sync, and
+// handler registration live here, fully type-checked; the routed dispatch
+// boundary is shared with the ReadModel / StateViewSlice entry points in
+// StreamRoutedEntryPoint_Ops.
+//
+// This conversion also REPAIRS the wiring: the former `.mjs` predated the
+// mixed-source callback rework — it applied the (now curried) functor to the
+// spec module alone, read `todoItems.contents` (no longer a ref), and passed
+// schema-decoded events to `phase1` (the automation callback now takes raw
+// envelope JSONs plus a context). Any event through that Lambda threw at
+// `callback.phase1`. The `bodyModule` and `context` HANDLER_CONFIG fields
+// exist for this wiring (AutomationSliceRuntime_Builder_Single).
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+type handlerEntry = {
+  specModule: string,
+  bodyModule: string,
+  callbackType: string,
+  queryDbTableName: string,
+  dcbQueueUrl: string,
+  sourceUrn: string,
+  context: option<Reventless.AutomationSlice.context>,
+}
+
+let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
+  obj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
+
+let decodeContext = (json: JSON.t): option<Reventless.AutomationSlice.context> =>
+  json
+  ->JSON.Decode.object
+  ->Option.map(c => {
+    Reventless.AutomationSlice.environment: c->strOf("environment")->Option.getOr("unknown"),
+    platformName: c->strOf("platformName")->Option.getOr("unknown"),
+    pluginName: c->strOf("pluginName")->Option.getOr("unknown"),
+    sliceName: c->strOf("sliceName")->Option.getOr("unknown"),
+  })
+
+let decodeEntry = (json: JSON.t): option<handlerEntry> =>
+  json
+  ->JSON.Decode.object
+  ->Option.map(h => {
+    specModule: h->strOf("specModule")->Option.getOr(""),
+    bodyModule: h->strOf("bodyModule")->Option.getOr(""),
+    callbackType: h->strOf("callbackType")->Option.getOr("automation"),
+    queryDbTableName: h->strOf("queryDbTableName")->Option.getOr(""),
+    dcbQueueUrl: h->strOf("dcbQueueUrl")->Option.getOr(""),
+    sourceUrn: h->strOf("sourceUrn")->Option.getOr(""),
+    context: h->Dict.get("context")->Option.flatMap(decodeContext),
+  })
+
+let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
+  rawJson == ""
+    ? []
+    : rawJson
+      ->JSON.parseOrThrow
+      ->JSON.Decode.object
+      ->Option.flatMap(obj => obj->Dict.get("handlers"))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.getOr([])
+      ->Array.filterMap(decodeEntry)
+
+// A pre-`bodyModule` config entry cannot rebuild the callback (the spec module
+// alone lacks the mappings/process). Warn and skip rather than crash the whole
+// Lambda — co-hosted slices with complete entries still run.
+let warnMissingBodyModule = (entry: handlerEntry) =>
+  StreamRoutedEntryPoint_Ops.logWarn(
+    `handler entry for spec '${entry.specModule}' carries no bodyModule (stale HANDLER_CONFIG?); skipping`,
+    {comp: "AutomationSliceRuntime"},
+  )
+
+// Fallback for automation entries from a config without `context` — sliceName
+// is the only field the runtime can still recover.
+let defaultContext = (sliceName: string): Reventless.AutomationSlice.context => {
+  environment: processEnv->Dict.get("Environment")->Option.getOr("unknown"),
+  platformName: "unknown",
+  pluginName: "unknown",
+  sliceName,
+}
+
+// ── Shared plumbing ─────────────────────────────────────────────────────────
+
+let makePublishJsons = (queueUrl: string): ReventlessCore.CommandTopic.publishJsons => {
+  let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+  queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO)
+}
+
+// Overwrite-sync the in-memory TODO list into the slice's view table. Rows are
+// serialized through the callback's row schema — the same JSON shape the
+// deploy-time QueryDb writes.
+let makeSyncTodoItems = (
+  ~queryDbTableName: string,
+  ~todoItems: dict<'row>,
+  ~rowSchema: S.t<'row>,
+): (unit => promise<unit>) => {
+  let table: Util_DynamoDb_Runtime.resolvedTable = {
+    id: "",
+    name: queryDbTableName,
+    arn: "",
+    hashKey: "id",
+  }
+  let save = QueryDbStorage_DynamoDb_Runtime.save(table)
+  async () => {
+    let _ =
+      await todoItems
+      ->Dict.toArray
+      ->Array.map(((id, row)) =>
+        save(id, row->S.reverseConvertToJsonOrThrow(rowSchema), ReventlessCore.QueryDb.Overwrite, None)
+      )
+      ->Promise.all
+  }
+}
+
+// ── Phase-1/phase-2 pipelines ───────────────────────────────────────────────
+// Both run: collect the batch → phase 1 → sync (so consumers observe Pending
+// rows even if phase 2 fails) → phase 2 → sync. Unlike the in-process builders
+// (which DETACH phase 2 to avoid a local-bus self-deadlock), the Lambda AWAITS
+// it: SQS decouples the downstream fan-out, and a detached promise would
+// freeze with the runtime between invocations.
+
+// The callback shapes the shell's functor applications produce
+// (AutomationSlice_Callback.T / OutboundTranslationSlice_Callback.T), typed at
+// the seam.
+type automationCallback = {
+  todoItems: dict<ReventlessCore.AutomationSlice_Callback.todoRow>,
+  phase1: (array<JSON.t>, Reventless.AutomationSlice.context) => unit,
+  phase2: ReventlessCore.CommandTopic.publishJsons => promise<unit>,
+}
+type outboundCallback<'event> = {
+  todoItems: dict<ReventlessCore.OutboundTranslationSlice_Callback.todoRow>,
+  phase1: array<'event> => unit,
+  phase2: ReventlessCore.CommandTopic.publishJsons => promise<unit>,
+}
+
+// Automation: phase 1 takes the RAW envelope JSONs — the callback routes by
+// `meta.service` and unwraps `{id, meta, event}` itself — plus the context.
+let makeAutomationJsonEventsHandler = (
+  ~context: Reventless.AutomationSlice.context,
+  ~callback: automationCallback,
+  ~publishJsons: ReventlessCore.CommandTopic.publishJsons,
+  ~syncTodoItems: unit => promise<unit>,
+): ReventlessCore.EventCollector.jsonEventsHandler =>
+  stream =>
+    stream
+    ->Stream.runCollect
+    ->Effect.flatMap(jsons =>
+      Effect.promise(async () => {
+        callback.phase1(jsons, context)
+        await syncTodoItems()
+        await callback.phase2(publishJsons)
+        await syncTodoItems()
+      })
+    )
+
+// Outbound: phase 1 takes DECODED consumed events. Mirrors the in-process
+// builder's decode — the tolerant DcbDecode on the inner `event` payload, so
+// event types the slice does not consume are dropped silently instead of
+// logging an error per event.
+let makeOutboundJsonEventsHandler = (
+  ~consumedEventSchema: S.t<'event>,
+  ~callback: outboundCallback<'event>,
+  ~publishJsons: ReventlessCore.CommandTopic.publishJsons,
+  ~syncTodoItems: unit => promise<unit>,
+): ReventlessCore.EventCollector.jsonEventsHandler => {
+  let decoder = Reventless.DcbDecode.makeDecoder(consumedEventSchema)
+  stream =>
+    stream
+    ->Stream.mapEffect(json =>
+      Effect.sync(() => {
+        let rawEvent =
+          json
+          ->JSON.Decode.object
+          ->Option.flatMap(d => d->Dict.get("event"))
+          ->Option.getOr(json)
+        let (eventType, dataDict) = rawEvent->ReventlessCore.Message.splitMessage
+        switch decoder.decode(~eventType, ~data=dataDict) {
+        | Some(event) => [event]
+        | None => []
+        }
+      })
+    )
+    ->Stream.flatMap(events => Stream.fromIterable(events))
+    ->Stream.runCollect
+    ->Effect.flatMap(events =>
+      Effect.promise(async () => {
+        callback.phase1(events)
+        await syncTodoItems()
+        await callback.phase2(publishJsons)
+        await syncTodoItems()
+      })
+    )
+}
+
+// ── Handler assembly (called by the shell per HANDLER_CONFIG entry) ─────────
+// Comp matches what the slice's own callback logs under, so a filter catches
+// both the framework's lines and the application handler's.
+
+let makeAutomationRegisteredHandler = (
+  entry: handlerEntry,
+  ~sliceName: string,
+  ~callback: automationCallback,
+): StreamRoutedEntryPoint_Ops.registeredHandler => {
+  handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
+    makeAutomationJsonEventsHandler(
+      ~context=entry.context->Option.getOr(defaultContext(sliceName)),
+      ~callback,
+      ~publishJsons=makePublishJsons(entry.dcbQueueUrl),
+      ~syncTodoItems=makeSyncTodoItems(
+        ~queryDbTableName=entry.queryDbTableName,
+        ~todoItems=callback.todoItems,
+        ~rowSchema=ReventlessCore.AutomationSlice_Callback.todoRowSchema,
+      ),
+    ),
+  ),
+  comp: `AutomationSlice(${sliceName})`,
+}
+
+let makeOutboundRegisteredHandler = (
+  entry: handlerEntry,
+  ~sliceName: string,
+  ~consumedEventSchema: S.t<'event>,
+  ~callback: outboundCallback<'event>,
+): StreamRoutedEntryPoint_Ops.registeredHandler => {
+  handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
+    makeOutboundJsonEventsHandler(
+      ~consumedEventSchema,
+      ~callback,
+      ~publishJsons=makePublishJsons(entry.dcbQueueUrl),
+      ~syncTodoItems=makeSyncTodoItems(
+        ~queryDbTableName=entry.queryDbTableName,
+        ~todoItems=callback.todoItems,
+        ~rowSchema=ReventlessCore.OutboundTranslationSlice_Callback.todoRowSchema,
+      ),
+    ),
+  ),
+  comp: `OutboundTranslationSlice(${sliceName})`,
+}

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

@@ -0,0 +1,145 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.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 Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+
+function strOf(obj, key) {
+  return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+}
+
+function decodeContext(json) {
+  return Stdlib_Option.map(Stdlib_JSON.Decode.object(json), c => ({
+    environment: Stdlib_Option.getOr(strOf(c, "environment"), "unknown"),
+    platformName: Stdlib_Option.getOr(strOf(c, "platformName"), "unknown"),
+    pluginName: Stdlib_Option.getOr(strOf(c, "pluginName"), "unknown"),
+    sliceName: Stdlib_Option.getOr(strOf(c, "sliceName"), "unknown")
+  }));
+}
+
+function decodeEntry(json) {
+  return Stdlib_Option.map(Stdlib_JSON.Decode.object(json), h => ({
+    specModule: Stdlib_Option.getOr(strOf(h, "specModule"), ""),
+    bodyModule: Stdlib_Option.getOr(strOf(h, "bodyModule"), ""),
+    callbackType: Stdlib_Option.getOr(strOf(h, "callbackType"), "automation"),
+    queryDbTableName: Stdlib_Option.getOr(strOf(h, "queryDbTableName"), ""),
+    dcbQueueUrl: Stdlib_Option.getOr(strOf(h, "dcbQueueUrl"), ""),
+    sourceUrn: Stdlib_Option.getOr(strOf(h, "sourceUrn"), ""),
+    context: Stdlib_Option.flatMap(h["context"], decodeContext)
+  }));
+}
+
+function parseHandlerConfig(rawJson) {
+  if (rawJson === "") {
+    return [];
+  } else {
+    return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(rawJson)), obj => obj["handlers"]), Stdlib_JSON.Decode.array), []), decodeEntry);
+  }
+}
+
+function warnMissingBodyModule(entry) {
+  StreamRoutedEntryPoint_Ops$ReventlessAws.logWarn(`handler entry for spec '` + entry.specModule + `' carries no bodyModule (stale HANDLER_CONFIG?); skipping`, {
+    comp: "AutomationSliceRuntime"
+  });
+}
+
+function defaultContext(sliceName) {
+  return {
+    environment: Stdlib_Option.getOr(process.env["Environment"], "unknown"),
+    platformName: "unknown",
+    pluginName: "unknown",
+    sliceName: sliceName
+  };
+}
+
+function makePublishJsons(queueUrl) {
+  let queue = {
+    id: queueUrl,
+    name: queueUrl,
+    arn: ""
+  };
+  return CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
+}
+
+function makeSyncTodoItems(queryDbTableName, todoItems, rowSchema) {
+  let table = {
+    id: "",
+    name: queryDbTableName,
+    arn: "",
+    hashKey: "id"
+  };
+  let save = QueryDbStorage_DynamoDb_Runtime$ReventlessAws.save(table);
+  return async () => {
+    await Promise.all(Object.entries(todoItems).map(param => save(param[0], S.reverseConvertToJsonOrThrow(param[1], rowSchema), "Overwrite", undefined)));
+  };
+}
+
+function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems) {
+  return stream => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.promise(async () => {
+    callback.phase1(jsons, context);
+    await syncTodoItems();
+    await callback.phase2(publishJsons);
+    return await syncTodoItems();
+  }));
+}
+
+function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems) {
+  let decoder = DcbDecode$Reventless.makeDecoder(consumedEventSchema);
+  return stream => Effect.flatMap(Stream.runCollect(Stream$1.flatMap(Stream$1.mapEffect(stream, json => Effect.sync(() => {
+    let rawEvent = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["event"]), json);
+    let match = Message$ReventlessCore.splitMessage(rawEvent);
+    let event = decoder.decode(match[0], match[1]);
+    if (event !== undefined) {
+      return [Primitive_option.valFromOption(event)];
+    } else {
+      return [];
+    }
+  })), events => Stream$1.fromIterable(events))), events => Effect.promise(async () => {
+    callback.phase1(events);
+    await syncTodoItems();
+    await callback.phase2(publishJsons);
+    return await syncTodoItems();
+  }));
+}
+
+function makeAutomationRegisteredHandler(entry, sliceName, callback) {
+  return {
+    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeAutomationJsonEventsHandler(Stdlib_Option.getOr(entry.context, defaultContext(sliceName)), callback, makePublishJsons(entry.dcbQueueUrl), makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, AutomationSlice_Callback$ReventlessCore.todoRowSchema))),
+    comp: `AutomationSlice(` + sliceName + `)`
+  };
+}
+
+function makeOutboundRegisteredHandler(entry, sliceName, consumedEventSchema, callback) {
+  return {
+    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeOutboundJsonEventsHandler(consumedEventSchema, callback, makePublishJsons(entry.dcbQueueUrl), makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema))),
+    comp: `OutboundTranslationSlice(` + sliceName + `)`
+  };
+}
+
+export {
+  strOf,
+  decodeContext,
+  decodeEntry,
+  parseHandlerConfig,
+  warnMissingBodyModule,
+  defaultContext,
+  makePublishJsons,
+  makeSyncTodoItems,
+  makeAutomationJsonEventsHandler,
+  makeOutboundJsonEventsHandler,
+  makeAutomationRegisteredHandler,
+  makeOutboundRegisteredHandler,
+}
+/* S Not a pure module */

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -8,8 +8,17 @@ type runtimeParts = Util.Lambda.runtimeParts
 
 type sliceInfo = {
   specModulePath: string,
+  // The slice's body module (`<Slice>_Automation.res` / `<Slice>_Translation.res`)
+  // — the second argument of the curried callback functor
+  // (AutomationSlice_Callback.Make(Spec)(Automation)). The entry point must
+  // import it alongside the spec; a spec module alone cannot rebuild the
+  // callback.
+  bodyModulePath: string,
   callbackType: string,
   queryDbTableName: Pulumi.Output.t<string>,
+  // Threaded to phase 1 collect/resolve on the automation path (mirrors the
+  // in-process builder's `~context`); outbound slices take no context.
+  context: option<Reventless.AutomationSlice.context>,
 }
 
 let bundledInfos: dict<sliceInfo> = Dict.make()
@@ -24,10 +33,12 @@ let getDcbQueueUrl = () => dcbQueueUrlRef.contents
 let registerAutomationSlice = (
   ~name,
   ~specModulePath,
+  ~bodyModulePath,
   ~callbackType="automation",
   ~queryDbTableName,
+  ~context=?,
 ) =>
-  bundledInfos->Dict.set(name, {specModulePath, callbackType, queryDbTableName})
+  bundledInfos->Dict.set(name, {specModulePath, bodyModulePath, callbackType, queryDbTableName, context})
 
 type storedSpec = {
   componentName: string,
@@ -128,17 +139,31 @@ let finish = () =>
           | Some(info) =>
             let pkg = Util_Bundle.extractPackageName(info.specModulePath)
             packageDirs->Dict.set(pkg, Util_Bundle.resolvePackageRoot(pkg))
+            // Usually the same package as the spec, but bundle it explicitly —
+            // the entry point imports the body module by specifier too.
+            let bodyPkg = Util_Bundle.extractPackageName(info.bodyModulePath)
+            packageDirs->Dict.set(bodyPkg, Util_Bundle.resolvePackageRoot(bodyPkg))
 
             let specModule =
               info.specModulePath->JSON.stringifyAny->Option.getOr(`""`)
+            let bodyModule =
+              info.bodyModulePath->JSON.stringifyAny->Option.getOr(`""`)
             let callbackType =
               info.callbackType->JSON.stringifyAny->Option.getOr(`""`)
+            let contextFragment = switch info.context {
+            | Some(context) =>
+              context
+              ->JSON.stringifyAny
+              ->Option.map(json => `,"context":${json}`)
+              ->Option.getOr("")
+            | None => ""
+            }
 
             let handlerJson =
               Pulumi.Output.all3((info.queryDbTableName, dcbQueueUrl, spec.sourceUrns))
               ->Pulumi.Output.apply(((tableName, queueUrl, urns)) => {
                 let sourceUrn = urns->Array.getUnsafe(0)
-                `{"specModule":${specModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${sourceUrn}"}`
+                `{"specModule":${specModule},"bodyModule":${bodyModule},"callbackType":${callbackType},"queryDbTableName":"${tableName}","dcbQueueUrl":"${queueUrl}","sourceUrn":"${sourceUrn}"${contextFragment}}`
               })
             let _ = handlerOutputs->Array.push(handlerJson)
           | None =>

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

@@ -26,12 +26,14 @@ function getDcbQueueUrl() {
   return dcbQueueUrlRef.contents;
 }
 
-function registerAutomationSlice(name, specModulePath, callbackTypeOpt, queryDbTableName) {
+function registerAutomationSlice(name, specModulePath, bodyModulePath, callbackTypeOpt, queryDbTableName, context) {
   let callbackType = callbackTypeOpt !== undefined ? callbackTypeOpt : "automation";
   bundledInfos[name] = {
     specModulePath: specModulePath,
+    bodyModulePath: bodyModulePath,
     callbackType: callbackType,
-    queryDbTableName: queryDbTableName
+    queryDbTableName: queryDbTableName,
+    context: context
   };
 }
 
@@ -104,15 +106,20 @@ function finish() {
         }
         let pkg = Util_Bundle$ReventlessAws.extractPackageName(info.specModulePath);
         packageDirs[pkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(pkg);
+        let bodyPkg = Util_Bundle$ReventlessAws.extractPackageName(info.bodyModulePath);
+        packageDirs[bodyPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(bodyPkg);
         let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
+        let bodyModule = Stdlib_Option.getOr(JSON.stringify(info.bodyModulePath), `""`);
         let callbackType = Stdlib_Option.getOr(JSON.stringify(info.callbackType), `""`);
+        let context = info.context;
+        let contextFragment = context !== undefined ? Stdlib_Option.getOr(Stdlib_Option.map(JSON.stringify(context), json => `,"context":` + json), "") : "";
         let handlerJson = Pulumi.all([
           info.queryDbTableName,
           dcbQueueUrl,
           spec.sourceUrns
         ]).apply(param => {
           let sourceUrn = param[2][0];
-          return `{"specModule":` + specModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + sourceUrn + `"}`;
+          return `{"specModule":` + specModule + `,"bodyModule":` + bodyModule + `,"callbackType":` + callbackType + `,"queryDbTableName":"` + param[0] + `","dcbQueueUrl":"` + param[1] + `","sourceUrn":"` + sourceUrn + `"` + contextFragment + `}`;
         });
         handlerOutputs.push(handlerJson);
       });