@reventlessdev/reventless-aws 3.0.0-alpha.263 → 3.0.0-alpha.265

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -27,6 +27,10 @@ type handlerEntry = {
   callbackType: string,
   queryDbTableName: string,
   dcbQueueUrl: string,
+  /** Whether `dcbQueueUrl` is a FIFO queue. Absent in a config written before
+      the flavor travelled with the URL, where `false` — a standard queue — is
+      what these command topics actually are. */
+  commandQueueIsFifo: option<bool>,
   sourceUrn: string,
   context: option<Reventless.AutomationSlice.context>,
 }
@@ -53,6 +57,7 @@ let decodeEntry = (json: JSON.t): option<handlerEntry> =>
     callbackType: h->strOf("callbackType")->Option.getOr("automation"),
     queryDbTableName: h->strOf("queryDbTableName")->Option.getOr(""),
     dcbQueueUrl: h->strOf("dcbQueueUrl")->Option.getOr(""),
+    commandQueueIsFifo: h->Dict.get("commandQueueIsFifo")->Option.flatMap(JSON.Decode.bool),
     sourceUrn: h->strOf("sourceUrn")->Option.getOr(""),
     context: h->Dict.get("context")->Option.flatMap(decodeContext),
   })
@@ -88,9 +93,13 @@ let defaultContext = (sliceName: string): Reventless.AutomationSlice.context =>
 
 // ── Shared plumbing ─────────────────────────────────────────────────────────
 
-let makePublishJsons = (queueUrl: string): ReventlessCore.CommandTopic.publishJsons => {
+// The flavor comes from the handler config rather than being assumed. It used to
+// be hardcoded FIFO while the command topics are standard queues, and SQS rejects
+// the MessageGroupId a FIFO publisher attaches — a failure nothing had reached,
+// because the role had no sqs:SendMessage to get that far.
+let makePublishJsons = (queueUrl: string, ~isFifo: bool): ReventlessCore.CommandTopic.publishJsons => {
   let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
-  queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO)
+  queue->CommandTopicChannel_SQS_Runtime.publishJsons(isFifo ? AWS.SQS_FIFO : AWS.SQS)
 }
 
 // Overwrite-sync the in-memory TODO list into the slice's view table. Rows are
@@ -119,6 +128,111 @@ let makeSyncTodoItems = (
   }
 }
 
+// Rehydrate the in-memory TODO list from the slice's view table, once per
+// container.
+//
+// `todoItems` is a module-level dict populated only by phase 1, so before this
+// existed a cold start began with an empty list and every row already persisted
+// was unreachable: `phase2` admits `Failed && retryCount < maxRetries`, but only
+// for rows it can see. A transient failure whose container then recycled was
+// stranded permanently, in a row reading `Failed` that nothing would ever pick
+// up again — while `makeSyncTodoItems` kept faithfully writing it back out.
+//
+// Once per container rather than per invocation: within a container the dict is
+// authoritative and `phase2` already re-attempts every actionable row on each
+// batch, so re-reading would buy nothing and cost a scan each time. The backlog
+// is therefore retried on the first event a new container handles.
+//
+// Memory wins on conflict. A row already in the dict may be mid-flight
+// (`Processing`) or a status this invocation just advanced; the stored copy is
+// by definition no fresher.
+//
+// Only `Pending` and `Failed` are read. `Completed` rows are the bulk of a
+// mature table and are never actionable. Retry-exhausted rows are not excluded —
+// `maxRetries` is Spec-level and not known here — but `phase2` filters them, so
+// they are inert rather than wrong.
+let makeLoadTodoItems = (
+  ~queryDbTableName: string,
+  ~todoItems: dict<'row>,
+  ~rowSchema: S.t<'row>,
+  ~comp: string,
+): (unit => promise<unit>) => {
+  let loaded = ref(false)
+  async () =>
+    if loaded.contents {
+      ()
+    } else {
+      loaded := true
+      let params: AwsSdk.DynamoDb.DocumentClient.ScanCommand.input = {
+        tableName: queryDbTableName,
+        consistentRead: true,
+        filterExpression: "#s = :pending OR #s = :failed",
+        expressionAttributeNames: [("#s", "status")]->Dict.fromArray,
+        expressionAttributeValues: [
+          (":pending", "Pending"->JSON.Encode.string),
+          (":failed", "Failed"->JSON.Encode.string),
+        ]->Dict.fromArray,
+      }
+      let restored = await Util_DynamoDb_Runtime.scanStream(params)
+      ->Stream.runCollect
+      ->Effect.map(items =>
+        items->Array.reduce(0, (count, item) => {
+          let json = item->JSON.stringifyAny->Option.getOr("")->JSON.parseOrThrow
+          let id = json->JSON.Decode.object->Option.flatMap(d => d->Dict.get("id"))->Option.flatMap(JSON.Decode.string)
+          switch id {
+          | Some(id) if todoItems->Dict.get(id)->Option.isNone =>
+            switch json->S.parseJsonOrThrow(rowSchema) {
+            | row =>
+              todoItems->Dict.set(id, row)
+              count + 1
+            | exception _ => count
+            }
+          | _ => count
+          }
+        })
+      )
+      ->Effect.catchAll(err =>
+        ReventlessCore.EffectLogger.logError(
+          ~comp,
+          `restore: couldn't read pending TODO rows from ${queryDbTableName}: ${DynamoDb_Error.message(
+              err,
+            )}`,
+        )->Effect.map(_ => 0)
+      )
+      ->Effect.runPromise
+      if restored > 0 {
+        ReventlessCore.EffectLogger.logInfo(
+          ~comp,
+          `restore: reloaded ${restored->Int.toString} unfinished TODO row(s) from ${queryDbTableName}`,
+        )->Effect.runSync
+      }
+    }
+}
+
+// ── Platform capabilities ───────────────────────────────────────────────────
+
+/**
+What this Lambda hands a slice's `translate`.
+
+Built here rather than reached for inside the plugin, because a plugin depends on
+`reventless-spec` and cannot name Amazon Location — the whole point of the
+injected record. This module is the AWS side of that seam and calls the SDK
+directly: no proxy hop through the browser's Function URL, and no dependence on a
+public unauthenticated endpoint for an unattended path.
+
+Resolved per call rather than captured once, so a Lambda whose configuration is
+updated does not need a cold start to see it. An unset `PLACE_INDEX_NAME` reaches
+`Geocoder_AwsLocation_Backend` as `""`, which answers `Unavailable` — a retryable
+outcome, not a verdict on the address.
+*/
+let capabilities = (): Reventless.Capabilities.t => {
+  geocode: (~text) =>
+    Geocoder_AwsLocation_Backend.search(
+      ~indexName=NodeProcess.env->Dict.get("PLACE_INDEX_NAME")->Option.getOr(""),
+      ~text,
+    ),
+}
+
 // ── 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
@@ -152,12 +266,14 @@ let makeAutomationJsonEventsHandler = (
   ~callback: automationCallback,
   ~publishJsons: ReventlessCore.CommandTopic.publishJsons,
   ~syncTodoItems: unit => promise<unit>,
+  ~loadTodoItems: unit => promise<unit>,
 ): ReventlessCore.EventCollector.jsonEventsHandler =>
   stream =>
     stream
     ->Stream.runCollect
     ->Effect.flatMap(jsons =>
       Effect.promise(async () => {
+        await loadTodoItems()
         callback.phase1(jsons, context)
         await syncTodoItems()
         await callback.phase2(publishJsons)
@@ -174,6 +290,7 @@ let makeOutboundJsonEventsHandler = (
   ~callback: outboundCallback<'event>,
   ~publishJsons: ReventlessCore.CommandTopic.publishJsons,
   ~syncTodoItems: unit => promise<unit>,
+  ~loadTodoItems: unit => promise<unit>,
 ): ReventlessCore.EventCollector.jsonEventsHandler => {
   let decoder = Reventless.DcbDecode.makeDecoder(consumedEventSchema)
   stream =>
@@ -202,9 +319,10 @@ let makeOutboundJsonEventsHandler = (
     ->Stream.runCollect
     ->Effect.flatMap(events =>
       Effect.promise(async () => {
+        await loadTodoItems()
         callback.phase1(events)
         await syncTodoItems()
-        await callback.phase2(publishJsons)
+        await callback.phase2(publishJsons, ~capabilities=capabilities())
         await syncTodoItems()
       })
     )
@@ -214,24 +332,62 @@ let makeOutboundJsonEventsHandler = (
 // Comp matches what the slice's own callback logs under, so a filter catches
 // both the framework's lines and the application handler's.
 
+/**
+A built slice, in the two ways the Lambda drives it.
+
+`registered` handles a stream batch. `sweep` runs the TODO backlog with no event
+to trigger it — the scheduled path, and the reason `translatePending` exists on
+the in-process builder. Both close over the *same* publish/sync/load closures, so
+a sweep landing on a container that has already served a batch reuses the load it
+did then, and one landing cold does the reload itself.
+*/
+type builtSlice = {
+  registered: StreamRoutedEntryPoint_Ops.registeredHandler,
+  sweep: unit => promise<unit>,
+  comp: string,
+}
+
 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,
+): builtSlice => {
+  let comp = `AutomationSlice(${sliceName})`
+  let publishJsons = makePublishJsons(
+    entry.dcbQueueUrl,
+    ~isFifo=entry.commandQueueIsFifo->Option.getOr(false),
+  )
+  let syncTodoItems = makeSyncTodoItems(
+    ~queryDbTableName=entry.queryDbTableName,
+    ~todoItems=callback.todoItems,
+    ~rowSchema=ReventlessCore.AutomationSlice_Callback.todoRowSchema,
+  )
+  let loadTodoItems = makeLoadTodoItems(
+    ~queryDbTableName=entry.queryDbTableName,
+    ~todoItems=callback.todoItems,
+    ~rowSchema=ReventlessCore.AutomationSlice_Callback.todoRowSchema,
+    ~comp,
+  )
+  {
+    registered: {
+      handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
+        makeAutomationJsonEventsHandler(
+          ~context=entry.context->Option.getOr(defaultContext(sliceName)),
+          ~callback,
+          ~publishJsons,
+          ~syncTodoItems,
+          ~loadTodoItems,
+        ),
       ),
-    ),
-  ),
-  comp: `AutomationSlice(${sliceName})`,
+      comp,
+    },
+    sweep: async () => {
+      await loadTodoItems()
+      await callback.phase2(publishJsons)
+      await syncTodoItems()
+    },
+    comp,
+  }
 }
 
 let makeOutboundRegisteredHandler = (
@@ -239,18 +395,63 @@ let makeOutboundRegisteredHandler = (
   ~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,
+): builtSlice => {
+  let comp = `OutboundTranslationSlice(${sliceName})`
+  let publishJsons = makePublishJsons(
+    entry.dcbQueueUrl,
+    ~isFifo=entry.commandQueueIsFifo->Option.getOr(false),
+  )
+  let syncTodoItems = makeSyncTodoItems(
+    ~queryDbTableName=entry.queryDbTableName,
+    ~todoItems=callback.todoItems,
+    ~rowSchema=ReventlessCore.OutboundTranslationSlice_Callback.todoRowSchema,
+  )
+  let loadTodoItems = makeLoadTodoItems(
+    ~queryDbTableName=entry.queryDbTableName,
+    ~todoItems=callback.todoItems,
+    ~rowSchema=ReventlessCore.OutboundTranslationSlice_Callback.todoRowSchema,
+    ~comp,
+  )
+  {
+    registered: {
+      handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
+        makeOutboundJsonEventsHandler(
+          ~consumedEventSchema,
+          ~callback,
+          ~publishJsons,
+          ~syncTodoItems,
+          ~loadTodoItems,
+        ),
       ),
-    ),
-  ),
-  comp: `OutboundTranslationSlice(${sliceName})`,
+      comp,
+    },
+    sweep: async () => {
+      await loadTodoItems()
+      await callback.phase2(publishJsons, ~capabilities=capabilities())
+      await syncTodoItems()
+    },
+    comp,
+  }
+}
+
+/**
+Run every slice's TODO backlog, for a scheduled invocation carrying no records.
+
+Sequential rather than concurrent: the slices in one Lambda share its memory and
+its downstream quotas, and a sweep is never latency-critical. A slice that throws
+is logged and does not stop the rest — a sweep that abandoned the remaining
+slices because one geocoder was down would be a worse version of the problem it
+exists to fix.
+*/
+let runSweeps = async (slices: array<builtSlice>) => {
+  for i in 0 to slices->Array.length - 1 {
+    let slice = slices->Array.getUnsafe(i)
+    try {
+      await slice.sweep()
+    } catch {
+    | exn =>
+      let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+      ReventlessCore.EffectLogger.logError(~comp=slice.comp, `sweep failed: ${msg}`)->Effect.runSync
+    }
+  }
 }

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

@@ -4,14 +4,20 @@ 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_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.mjs";
+import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.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 Geocoder_AwsLocation_Backend$ReventlessAws from "../Geocoder/Geocoder_AwsLocation_Backend.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";
@@ -36,6 +42,7 @@ function decodeEntry(json) {
     callbackType: Stdlib_Option.getOr(strOf(h, "callbackType"), "automation"),
     queryDbTableName: Stdlib_Option.getOr(strOf(h, "queryDbTableName"), ""),
     dcbQueueUrl: Stdlib_Option.getOr(strOf(h, "dcbQueueUrl"), ""),
+    commandQueueIsFifo: Stdlib_Option.flatMap(h["commandQueueIsFifo"], Stdlib_JSON.Decode.bool),
     sourceUrn: Stdlib_Option.getOr(strOf(h, "sourceUrn"), ""),
     context: Stdlib_Option.flatMap(h["context"], decodeContext)
   }));
@@ -64,13 +71,13 @@ function defaultContext(sliceName) {
   };
 }
 
-function makePublishJsons(queueUrl) {
+function makePublishJsons(queueUrl, isFifo) {
   let queue = {
     id: queueUrl,
     name: queueUrl,
     arn: ""
   };
-  return CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
+  return CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, isFifo ? "SQS_FIFO" : "SQS");
 }
 
 function makeSyncTodoItems(queryDbTableName, todoItems, rowSchema) {
@@ -86,8 +93,71 @@ function makeSyncTodoItems(queryDbTableName, todoItems, rowSchema) {
   };
 }
 
-function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems) {
+function makeLoadTodoItems(queryDbTableName, todoItems, rowSchema, comp) {
+  let loaded = {
+    contents: false
+  };
+  return async () => {
+    if (loaded.contents) {
+      return;
+    }
+    loaded.contents = true;
+    let params_ConsistentRead = true;
+    let params_ExpressionAttributeNames = Object.fromEntries([[
+        "#s",
+        "status"
+      ]]);
+    let params_ExpressionAttributeValues = Object.fromEntries([
+      [
+        ":pending",
+        "Pending"
+      ],
+      [
+        ":failed",
+        "Failed"
+      ]
+    ]);
+    let params_FilterExpression = "#s = :pending OR #s = :failed";
+    let params = {
+      TableName: queryDbTableName,
+      ConsistentRead: params_ConsistentRead,
+      ExpressionAttributeNames: params_ExpressionAttributeNames,
+      ExpressionAttributeValues: params_ExpressionAttributeValues,
+      FilterExpression: params_FilterExpression
+    };
+    let restored = await Effect.runPromise(Effect.catchAll(Effect.map(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream(params)), items => Stdlib_Array.reduce(items, 0, (count, item) => {
+      let json = JSON.parse(Stdlib_Option.getOr(JSON.stringify(item), ""));
+      let id = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["id"]), Stdlib_JSON.Decode.string);
+      if (id === undefined) {
+        return count;
+      }
+      if (!Stdlib_Option.isNone(todoItems[id])) {
+        return count;
+      }
+      let row;
+      try {
+        row = S.parseJsonOrThrow(json, rowSchema);
+      } catch (exn) {
+        return count;
+      }
+      todoItems[id] = row;
+      return count + 1 | 0;
+    })), err => Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `restore: couldn't read pending TODO rows from ` + queryDbTableName + `: ` + DynamoDb_Error$ReventlessAws.message(err)), () => 0)));
+    if (restored > 0) {
+      return Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `restore: reloaded ` + restored.toString() + ` unfinished TODO row(s) from ` + queryDbTableName));
+    }
+  };
+}
+
+function capabilities() {
+  return {
+    geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined)
+  };
+}
+
+function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTodoItems, loadTodoItems) {
   return stream => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.promise(async () => {
+    await loadTodoItems();
     callback.phase1(jsons, context);
     await syncTodoItems();
     await callback.phase2(publishJsons);
@@ -95,7 +165,7 @@ function makeAutomationJsonEventsHandler(context, callback, publishJsons, syncTo
   }));
 }
 
-function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems) {
+function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems, loadTodoItems) {
   let decoder = DcbDecode$Reventless.makeDecoder(consumedEventSchema);
   return stream => Effect.flatMap(Stream.runCollect(Stream$1.flatMap(Stream$1.mapEffect(stream, json => Effect.sync(() => {
     let envelope = Stdlib_JSON.Decode.object(json);
@@ -112,27 +182,69 @@ function makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJso
       return [];
     }
   })), events => Stream$1.fromIterable(events))), events => Effect.promise(async () => {
+    await loadTodoItems();
     callback.phase1(events);
     await syncTodoItems();
-    await callback.phase2(publishJsons);
+    await callback.phase2(publishJsons, {
+      geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined)
+    });
     return await syncTodoItems();
   }));
 }
 
 function makeAutomationRegisteredHandler(entry, sliceName, callback) {
+  let comp = `AutomationSlice(` + sliceName + `)`;
+  let publishJsons = makePublishJsons(entry.dcbQueueUrl, Stdlib_Option.getOr(entry.commandQueueIsFifo, false));
+  let syncTodoItems = makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, AutomationSlice_Callback$ReventlessCore.todoRowSchema);
+  let loadTodoItems = makeLoadTodoItems(entry.queryDbTableName, callback.todoItems, AutomationSlice_Callback$ReventlessCore.todoRowSchema, comp);
   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 + `)`
+    registered: {
+      handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeAutomationJsonEventsHandler(Stdlib_Option.getOr(entry.context, defaultContext(sliceName)), callback, publishJsons, syncTodoItems, loadTodoItems)),
+      comp: comp
+    },
+    sweep: async () => {
+      await loadTodoItems();
+      await callback.phase2(publishJsons);
+      return await syncTodoItems();
+    },
+    comp: comp
   };
 }
 
 function makeOutboundRegisteredHandler(entry, sliceName, consumedEventSchema, callback) {
+  let comp = `OutboundTranslationSlice(` + sliceName + `)`;
+  let publishJsons = makePublishJsons(entry.dcbQueueUrl, Stdlib_Option.getOr(entry.commandQueueIsFifo, false));
+  let syncTodoItems = makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema);
+  let loadTodoItems = makeLoadTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema, comp);
   return {
-    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeOutboundJsonEventsHandler(consumedEventSchema, callback, makePublishJsons(entry.dcbQueueUrl), makeSyncTodoItems(entry.queryDbTableName, callback.todoItems, OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema))),
-    comp: `OutboundTranslationSlice(` + sliceName + `)`
+    registered: {
+      handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeOutboundJsonEventsHandler(consumedEventSchema, callback, publishJsons, syncTodoItems, loadTodoItems)),
+      comp: comp
+    },
+    sweep: async () => {
+      await loadTodoItems();
+      await callback.phase2(publishJsons, {
+        geocode: text => Geocoder_AwsLocation_Backend$ReventlessAws.search(Stdlib_Option.getOr(process.env["PLACE_INDEX_NAME"], ""), text, undefined)
+      });
+      return await syncTodoItems();
+    },
+    comp: comp
   };
 }
 
+async function runSweeps(slices) {
+  for (let i = 0, i_finish = slices.length; i < i_finish; ++i) {
+    let slice = slices[i];
+    try {
+      await slice.sweep();
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
+      Effect.runSync(EffectLogger$ReventlessCore.logError(slice.comp, undefined, `sweep failed: ` + msg));
+    }
+  }
+}
+
 export {
   strOf,
   decodeContext,
@@ -142,9 +254,12 @@ export {
   defaultContext,
   makePublishJsons,
   makeSyncTodoItems,
+  makeLoadTodoItems,
+  capabilities,
   makeAutomationJsonEventsHandler,
   makeOutboundJsonEventsHandler,
   makeAutomationRegisteredHandler,
   makeOutboundRegisteredHandler,
+  runSweeps,
 }
 /* S Not a pure module */