@reventlessdev/reventless-aws 3.0.0-alpha.420 → 3.0.0-alpha.422

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.422 (2026-11-05)
+
+**Note:** Version bump only for package @reventlessdev/reventless-aws
+
+
+
+
+
+# 3.0.0-alpha.421 (2026-11-02)
+
+### Bug Fixes
+
+* **aws:** a dead letter's first delivery writes its full line ([3436633](https://github.com/ReventlessDev/reventless-core/commit/3436633809b671fc750fc5f717523f080c084b64))
+### Features
+
+* a view row knows its last change, and the local platform keeps every change ([1a1fd71](https://github.com/ReventlessDev/reventless-core/commit/1a1fd7117d9837696a7c0080dcd6f0983e57780c))
+* **local:** the app's API logs each request and subscription it answers ([31a163c](https://github.com/ReventlessDev/reventless-core/commit/31a163c945d8929e9a604cc0dc8a74939320f85e))
+
+
 # 3.0.0-alpha.420 (2026-11-01)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.420",
+  "version": "3.0.0-alpha.422",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -22,19 +22,19 @@
     "sury": "11.0.0",
     "uuid": "^13.0.0",
     "yaml": "^2.8.3",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.38",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.39",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.38",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.25",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.26",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.39",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
     "@reventlessdev/rescript-web": "1.0.0-alpha.8",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.221",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.191",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.327",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.192",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.42"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.223",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.42",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.194",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.193",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.329"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/adapter/CommandTopic/CommandTopicChannel_SQS.res

@@ -60,7 +60,10 @@ let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
       PulumiAws.SQS.Queue.visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make, // TODO rethink timeout
       redrivePolicy: Util_DeadLetterQueue.queue.arn
       ->Pulumi.Output.apply(dlqArn =>
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       )
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/CommandTopic/CommandTopicChannel_SQS.res.mjs

@@ -43,7 +43,7 @@ function make(name, owner, opts) {
   let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
   let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType, "CommandTopic", undefined, undefined, owner, undefined, undefined);
   let queue = new (Aws.sqs.Queue)(name, {
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: tags,
     visibilityTimeoutSeconds: 180,
     sqsManagedSseEnabled: false

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Async.res

@@ -37,7 +37,10 @@ let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
       visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make,
       redrivePolicy: Util_DeadLetterQueue.fifoQueue.arn
       ->Pulumi.Output.apply(dlqArn => {
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       })
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Async.res.mjs

@@ -24,7 +24,7 @@ function make(name, owner, opts) {
   let queue = new (Aws.sqs.Queue)(name, {
     contentBasedDeduplication: true,
     fifoQueue: true,
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: tags,
     visibilityTimeoutSeconds: 180,
     deduplicationScope: "messageGroup",

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_FIFO.res

@@ -26,7 +26,10 @@ let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
       visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make,
       redrivePolicy: Util_DeadLetterQueue.fifoQueue.arn
       ->Pulumi.Output.apply(dlqArn => {
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       })
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_FIFO.res.mjs

@@ -24,7 +24,7 @@ function make(name, owner, opts) {
   let queue = new (Aws.sqs.Queue)(name, {
     contentBasedDeduplication: true,
     fifoQueue: true,
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: tags,
     visibilityTimeoutSeconds: 180,
     deduplicationScope: "messageGroup",

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res

@@ -40,7 +40,10 @@ let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
       PulumiAws.SQS.Queue.visibilityTimeoutSeconds: (6 * 30)->Pulumi.Input.make,
       redrivePolicy: Util_DeadLetterQueue.queue.arn
       ->Pulumi.Output.apply(dlqArn =>
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       )
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs

@@ -23,7 +23,7 @@ function make(name, owner, opts) {
   let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
   let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType, "CommandTopic", undefined, undefined, owner, undefined, undefined);
   let queue = new (Aws.sqs.Queue)(name, {
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: tags,
     visibilityTimeoutSeconds: 180,
     sqsManagedSseEnabled: false

package/src/adapter/EventCollector/EventCollectorChannel_SQS.res

@@ -49,7 +49,10 @@ let make: ReventlessCore.EventCollector_Adapter.channelMaker<
       PulumiAws.SQS.Queue.visibilityTimeoutSeconds: 120->Pulumi.Input.make,
       redrivePolicy: Util_DeadLetterQueue.queue.arn
       ->Pulumi.Output.apply(dlqArn =>
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       )
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/EventCollector/EventCollectorChannel_SQS.res.mjs

@@ -29,7 +29,7 @@ function make(name, eventTopics, owner, opts) {
   let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
   let tags = AWS_Tags$ReventlessAws.make(name, EventCollector$ReventlessCore.componentType, "EventCollector", undefined, undefined, owner, undefined, undefined);
   let queue = new (Aws.sqs.Queue)(name, {
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: tags,
     visibilityTimeoutSeconds: 120,
     sqsManagedSseEnabled: false

package/src/adapter/EventCollector/EventCollectorChannel_SQS_FIFO.res

@@ -27,7 +27,10 @@ let make: ReventlessCore.EventCollector_Adapter.channelMaker<
       visibilityTimeoutSeconds: 30->Pulumi.Input.make, // TODO fix timeout
       redrivePolicy: Util_DeadLetterQueue.fifoQueue.arn
       ->Pulumi.Output.apply(dlqArn =>
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       )
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/EventCollector/EventCollectorChannel_SQS_FIFO.res.mjs

@@ -16,7 +16,7 @@ function make(name, eventTopics, owner, opts) {
   let queue = new (Aws.sqs.Queue)(name, {
     contentBasedDeduplication: true,
     fifoQueue: true,
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.fifoQueue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: tags,
     visibilityTimeoutSeconds: 30,
     deduplicationScope: "messageGroup",

package/src/adapter/EventLogSubscription/EventLogSubscription_AppSync.res

@@ -39,7 +39,10 @@ let make = (
       SQS.Queue.visibilityTimeoutSeconds: 60->Pulumi.Input.make,
       redrivePolicy: Util_DeadLetterQueue.queue.arn
       ->Pulumi.Output.apply(dlqArn =>
-        SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       )
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/EventLogSubscription/EventLogSubscription_AppSync.res.mjs

@@ -21,7 +21,7 @@ function channelNameOf(topicName) {
 
 function make(name, topicName, eventTopicOutputs, eventsApi, opts) {
   let queue = new (Aws.sqs.Queue)(name + "EventLogSubQueue", {
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: AWS_Tags$ReventlessAws.make(name + "EventLogSubQueue", EventTopic$ReventlessCore.componentType, "EventLogSubscription", undefined, name, undefined, undefined, undefined),
     visibilityTimeoutSeconds: 60,
     sqsManagedSseEnabled: false

package/src/adapter/Postgres/PgProjectionFeed.res

@@ -47,7 +47,10 @@ let makeQueue = (
       PulumiAws.SQS.Queue.visibilityTimeoutSeconds: 120->Pulumi.Input.make,
       redrivePolicy: Util_DeadLetterQueue.queue.arn
       ->Pulumi.Output.apply(dlqArn =>
-        PulumiAws.SQS.Queue.RedrivePolicy.make(~deadLetterTargetArn=dlqArn, ~maxReceiveCount=5)
+        PulumiAws.SQS.Queue.RedrivePolicy.make(
+          ~deadLetterTargetArn=dlqArn,
+          ~maxReceiveCount=Util_DeadLetterQueue.maxReceiveCount,
+        )
       )
       ->Pulumi.Output.asInput,
       sqsManagedSseEnabled: false->Pulumi.Input.make,

package/src/adapter/Postgres/PgProjectionFeed.res.mjs

@@ -15,7 +15,7 @@ function getFeedQueues() {
 
 function makeQueue(name, scope, includeClassic, includeDcb, opts) {
   let queue = new (Aws.sqs.Queue)(name, {
-    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, Util_DeadLetterQueue$ReventlessAws.maxReceiveCount)),
     tags: AWS_Tags$ReventlessAws.make(name, "Plugin", "EventCollector", "Plugin", undefined, undefined, undefined, undefined),
     visibilityTimeoutSeconds: 120,
     sqsManagedSseEnabled: false

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res

@@ -709,12 +709,24 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
     // is independent of whether this view has a sub-id door, and adding a third
     // dimension to that match would spell eight cases to say one thing.
     let refsResolvers = resolverRefs->Option.mapOr([], r => [r])
+    // The row's last change, for an elevated caller only. A field resolver, so it also covers
+    // a row reached through another view's cross-table field.
+    let changeResolver = Resolver.makeUnitJsResolver(
+      ~name=name ++ "RowChange",
+      ~api,
+      ~dataSourceName,
+      ~type_=parentTypeName->Pulumi.Input.make,
+      ~field=ReventlessCore.RowChange.key->Pulumi.Input.make,
+      ~code=Resolver.Functions.rowChangeField(~field=ReventlessCore.RowChange.key, ~elevatedGroups),
+      ~opts,
+    )
     Array.flat([
       mainResolvers,
       refsResolvers,
       resolversByIndex,
       idResolvers,
       idsResolvers,
+      [changeResolver],
     ])->Array.map(Util.AppSync.toResourceNative)
   }
 

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs

@@ -9,6 +9,7 @@ import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/compon
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Adapter.res.mjs";
+import * as RowChange$ReventlessCore from "@reventlessdev/reventless-core/src/RowChange.res.mjs";
 import * as AppSync_Function$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Function.res.mjs";
 import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
@@ -303,12 +304,14 @@ function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolve
           ]
       );
     let refsResolvers = Stdlib_Option.mapOr(resolverRefs, [], r => [r]);
+    let changeResolver = AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + "RowChange", api, dataSourceName, parentTypeName, RowChange$ReventlessCore.key, AppSync_Resolver_Functions$PulumiAws.rowChangeField(RowChange$ReventlessCore.key, elevatedGroups), opts);
     return [
       mainResolvers,
       refsResolvers,
       resolversByIndex,
       idResolvers,
-      idsResolvers
+      idsResolvers,
+      [changeResolver]
     ].flat().map(Util_AppSync$ReventlessAws.toResourceNative);
   };
   return {

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res

@@ -711,8 +711,8 @@ let makeSqsHandlerBundle = (input: bundleInput): bundle => {
     ),
     // Backs both the admin and every per-plugin EventCollector Lambda, so the
     // comp names the plugin whose events it drains — matching the
-    // `Plugin(<id>)` shape Plugin_Callback logs under.
-    comp: `Plugin(${input.pluginDefinition.id})`,
+    // `ExtensionRouting(<id>)` shape Plugin_Callback logs under.
+    comp: `ExtensionRouting(${input.pluginDefinition.id})`,
   }
 }
 

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

@@ -531,7 +531,7 @@ function makeSqsHandlerBundle(input) {
   };
   return {
     sqsHandler: EventCollectorChannel_SQS_Runtime$ReventlessAws.handleDynamoDbOrSqsEvent(queue, Callback.handleJsonEvents),
-    comp: `Plugin(` + input.pluginDefinition.id + `)`
+    comp: `ExtensionRouting(` + input.pluginDefinition.id + `)`
   };
 }
 

package/src/adapter/Runtime/ProjectionEntryPoint_Ops.res

@@ -124,6 +124,23 @@ let withDisplayName = (
     }
   }
 
+/**
+Stamps every saved row with the change being written (`_change`: flow, event, time), as
+`QueryDb_Operations.Make` does on the typed path. Outermost, so the live update publishes
+the stamped row.
+*/
+let withRowChange = (
+  base: ReventlessCore.QueryDb_Adapter.operations,
+): ReventlessCore.QueryDb_Adapter.operations => {
+  ...base,
+  save: (id, state, saveMode, ttl) =>
+    base.save(id, ReventlessCore.RowChange.stamp(state), saveMode, ttl),
+  saveBatch: items =>
+    base.saveBatch(
+      items->Array.map(((id, state, ttl)) => (id, ReventlessCore.RowChange.stamp(state), ttl)),
+    ),
+}
+
 let makeQueryDbOps = (
   ~queryDbTableName: string,
   ~pgConnection: option<PgConnection.connectionConfig>,
@@ -145,4 +162,4 @@ let makeQueryDbOps = (
       ?subIdField,
     })
   | None => QueryDbEntryPoint_Ops.makeDynamoQueryDbOps(~tableName=queryDbTableName)
-  }
+  }->withRowChange

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

@@ -5,6 +5,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 import * as StateTopicPublishMjs from "./StateTopicPublish.mjs";
+import * as RowChange$ReventlessCore from "@reventlessdev/reventless-core/src/RowChange.res.mjs";
 import * as QueryDbEntryPoint_Ops$ReventlessAws from "./QueryDbEntryPoint_Ops.res.mjs";
 import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
 
@@ -70,17 +71,29 @@ function withDisplayName(base, stateSchema) {
   };
 }
 
+function withRowChange(base) {
+  return {
+    load: base.load,
+    loadStream: base.loadStream,
+    save: (id, state, saveMode, ttl) => base.save(id, RowChange$ReventlessCore.stamp(state), saveMode, ttl),
+    saveBatch: items => base.saveBatch(items.map(param => [
+      param[0],
+      RowChange$ReventlessCore.stamp(param[1]),
+      param[2]
+    ])),
+    count: base.count,
+    delete: base.delete,
+    deleteBatch: base.deleteBatch
+  };
+}
+
 function makeQueryDbOps(queryDbTableName, pgConnection, stateTopicName, indexes, subIdField) {
-  if (pgConnection !== undefined) {
-    return StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
+  return withRowChange(pgConnection !== undefined ? StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
       endpoint: process.env["APPSYNC_ENDPOINT"],
       region: process.env["AWS_REGION"],
       topicName: stateTopicName,
       subIdField: subIdField
-    });
-  } else {
-    return QueryDbEntryPoint_Ops$ReventlessAws.makeDynamoQueryDbOps(queryDbTableName);
-  }
+    }) : QueryDbEntryPoint_Ops$ReventlessAws.makeDynamoQueryDbOps(queryDbTableName));
 }
 
 export {
@@ -89,6 +102,7 @@ export {
   withLiveUpdates,
   withUnionMemberTypes,
   withDisplayName,
+  withRowChange,
   makeQueryDbOps,
 }
 /* DisplayName-Reventless Not a pure module */

package/src/util/Util_DeadLetterHandler.res

@@ -0,0 +1,138 @@
+// The dead-letter function's handler. `Util_DeadLetterQueue` ships this module's compiled file
+// as the function's whole code, so it must compile to a file that imports nothing: it keeps
+// working when the layer or the handlers of a deploy are broken, which is when dead letters
+// arrive. So only the Stdlib's externals (which compile inline) and plain switches here: no
+// Stdlib function such as `Option.getOr`, which compiles to an import, and no `try`, whose
+// compiled form imports the runtime's exception helpers.
+//
+// It logs what arrived, then FAILS the invocation on purpose.
+//
+// Returning success would let SQS delete the message, which is what this handler used to do,
+// and it made a dead letter unobservable twice over: the queue's depth returned to 0, so a
+// depth alarm could never fire, and the function's `Errors` metric stayed at 0, so neither
+// could an error alarm. A plugin whose commands failed every 5 minutes for two days produced
+// 217 dead letters and no signal at all; it was found by a person noticing a stale UI.
+//
+// Failing instead keeps the message on the queue and keeps `Errors` non-zero while the
+// condition lasts. Both are conventional alarm subjects, and a monitoring backend attached
+// through the `DeadLetterSink` seam now has something to attach to.
+//
+// The transport retries by design too: a failed batch returns to the queue and is redelivered
+// until retention expires. A handler that fails forever, on a transport that retries forever,
+// is a loop, and it outlives its cause, because nothing about a fixed bug removes the message
+// that was stranded by it. So what the loop costs is a function of the line, not the count:
+// the first delivery here writes the record's ids, kind, size and attribute names (never its
+// body, which is a command or event and may be about a person), and every redelivery after it
+// writes a single identity line. A stranded message is ~150 KB over a fortnight rather than
+// ~17 MB, small enough that ending the loop early is an operator's job.
+
+// How many times a consuming queue delivers a message before it moves it here. Every redrive
+// policy in the framework takes it from here. SQS keeps a message's receive count when it
+// moves it, so a dead letter's first delivery here reports `maxReceiveCount + 1`; a message
+// sent here directly starts at 1.
+let maxReceiveCount = 5
+let firstDeliveryCount = maxReceiveCount + 1
+
+type record = {
+  messageId?: string,
+  body?: string,
+  attributes?: dict<string>,
+  messageAttributes?: dict<JSON.t>,
+  eventSourceARN?: string,
+}
+type event = {@as("Records") records?: array<record>}
+
+// The body parsed, or nothing when it is not JSON. A `try` would import the runtime, so the
+// parse is guarded in plain JS.
+let parseOrNull: string => Nullable.t<JSON.t> = %raw(`function (text) {
+  try { return JSON.parse(text) } catch (_) { return null }
+}`)
+
+// `Option.getOr` would import the Stdlib, so the default is given here.
+let orElse = (value: option<string>, fallback: string) =>
+  switch value {
+  | Some(v) => v
+  | None => fallback
+  }
+
+// The command's or event's tag, "sns" for an SNS envelope, else "unknown".
+let kindOf = (body: string): string =>
+  switch parseOrNull(body)->Nullable.toOption {
+  | Some(JSON.Object(d)) =>
+    let tagOf = key =>
+      switch d->Dict.get(key) {
+      | Some(JSON.Object(inner)) =>
+        switch inner->Dict.get("TAG") {
+        | Some(JSON.String(tag)) => Some(tag)
+        | _ => None
+        }
+      | _ => None
+      }
+    switch (tagOf("command"), tagOf("event"), d->Dict.get("Message")) {
+    | (Some(tag), _, _) | (None, Some(tag), _) => tag
+    | (None, None, Some(_)) => "sns"
+    | (None, None, None) => "unknown"
+    }
+  | _ => "unknown"
+  }
+
+let receiveCountOf = (attrs: dict<string>): int =>
+  switch attrs->Dict.get("ApproximateReceiveCount") {
+  | Some(text) =>
+    let n = Float.parseFloat(text)
+    Float.isNaN(n) ? 1 : Float.toInt(n)
+  | None => 1
+  }
+
+// The line a record writes: the full one on its first delivery here, the short one after.
+let lineOf = (record: record): string => {
+  let attrs = switch record.attributes {
+  | Some(a) => a
+  | None => Dict.make()
+  }
+  let receiveCount = receiveCountOf(attrs)
+  let body = record.body->orElse("")
+  let source = switch attrs->Dict.get("DeadLetterQueueSourceArn") {
+  | Some(arn) => arn
+  | None => record.eventSourceARN->orElse("unknown")
+  }
+  let identity =
+    "messageId=" ++
+    record.messageId->orElse("unknown") ++
+    " source=" ++
+    source ++
+    " receiveCount=" ++
+    Int.toString(receiveCount) ++
+    " bodyBytes=" ++
+    Int.toString(String.length(body))
+  if receiveCount <= firstDeliveryCount {
+    let attributeNames = switch record.messageAttributes {
+    | Some(m) => m->Dict.keysToArray
+    | None => []
+    }
+    "DEAD LETTER ITEM: " ++
+    identity ++
+    " kind=" ++
+    kindOf(body) ++
+    " attributes=" ++
+    attributeNames->Array.join(",")
+  } else {
+    "DEAD LETTER REDELIVERY: " ++ identity
+  }
+}
+
+let handler = async (event: event): unit => {
+  let records = switch event.records {
+  | Some(r) => r
+  | None => []
+  }
+  records->Array.forEach(record => Console.error(lineOf(record)))
+  JsError.throw(
+    JsError.make(
+      "Dead-lettered " ++
+      Int.toString(
+        Array.length(records),
+      ) ++ " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero.",
+    ),
+  )
+}

package/src/util/Util_DeadLetterHandler.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let firstDeliveryCount = 6;
+
+let parseOrNull = (function (text) {
+  try { return JSON.parse(text) } catch (_) { return null }
+});
+
+function orElse(value, fallback) {
+  if (value !== undefined) {
+    return value;
+  } else {
+    return fallback;
+  }
+}
+
+function kindOf(body) {
+  let match = parseOrNull(body);
+  if (match == null) {
+    return "unknown";
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return "unknown";
+  }
+  let tagOf = key => {
+    let match$1 = match[key];
+    if (match$1 === undefined) {
+      return;
+    }
+    if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+      return;
+    }
+    let match$2 = match$1["TAG"];
+    if (typeof match$2 === "string") {
+      return match$2;
+    }
+  };
+  let match$1 = tagOf("command");
+  let match$2 = tagOf("event");
+  let match$3 = match["Message"];
+  if (match$1 !== undefined) {
+    return match$1;
+  } else if (match$2 !== undefined) {
+    return match$2;
+  } else if (match$3 !== undefined) {
+    return "sns";
+  } else {
+    return "unknown";
+  }
+}
+
+function receiveCountOf(attrs) {
+  let text = attrs["ApproximateReceiveCount"];
+  if (text === undefined) {
+    return 1;
+  }
+  let n = parseFloat(text);
+  if (Number.isNaN(n)) {
+    return 1;
+  } else {
+    return n | 0;
+  }
+}
+
+function lineOf(record) {
+  let a = record.attributes;
+  let attrs = a !== undefined ? a : ({});
+  let receiveCount = receiveCountOf(attrs);
+  let value = record.body;
+  let body = value !== undefined ? value : "";
+  let arn = attrs["DeadLetterQueueSourceArn"];
+  let source;
+  if (arn !== undefined) {
+    source = arn;
+  } else {
+    let value$1 = record.eventSourceARN;
+    source = value$1 !== undefined ? value$1 : "unknown";
+  }
+  let value$2 = record.messageId;
+  let identity = "messageId=" + (
+    value$2 !== undefined ? value$2 : "unknown"
+  ) + " source=" + source + " receiveCount=" + receiveCount.toString() + " bodyBytes=" + body.length.toString();
+  if (receiveCount > firstDeliveryCount) {
+    return "DEAD LETTER REDELIVERY: " + identity;
+  }
+  let m = record.messageAttributes;
+  let attributeNames = m !== undefined ? Object.keys(m) : [];
+  return "DEAD LETTER ITEM: " + identity + " kind=" + kindOf(body) + " attributes=" + attributeNames.join(",");
+}
+
+async function handler(event) {
+  let r = event.Records;
+  let records = r !== undefined ? r : [];
+  records.forEach(record => {
+    console.error(lineOf(record));
+  });
+  throw new Error("Dead-lettered " + records.length.toString() + " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero.");
+}
+
+let maxReceiveCount = 5;
+
+export {
+  maxReceiveCount,
+  firstDeliveryCount,
+  parseOrNull,
+  orElse,
+  kindOf,
+  receiveCountOf,
+  lineOf,
+  handler,
+}
+/* No side effect */

package/src/util/Util_DeadLetterQueue.res

@@ -17,6 +17,10 @@ let queueTags = queueName =>
 // 4-day default can expire it over a long weekend before anyone reads it.
 let retentionSeconds = 14 * 24 * 60 * 60
 
+// How many times a consuming queue delivers a message before it moves it here; every redrive
+// policy in the framework takes it from here. Defined beside the handler, which needs it.
+let maxReceiveCount = Util_DeadLetterHandler.maxReceiveCount
+
 // A dead letter has no latency requirement, and the handler below fails on
 // purpose — so a message returns to the queue and is redelivered until retention
 // expires. At 180 s that is ~480 redeliveries per message per day, which outlives
@@ -67,59 +71,12 @@ let lambdaRole = IAM.Role.makeWithDefaultPolicy(
   ~opts,
 )
 
-// Logs what arrived, then FAILS the invocation on purpose.
-//
-// Returning success here would let SQS delete the message, which is what this
-// handler used to do — and it made a dead letter unobservable twice over: the
-// queue's depth returned to 0, so a depth alarm could never fire, and the
-// function's `Errors` metric stayed at 0, so neither could an error alarm. A
-// plugin whose commands failed every 5 minutes for two days produced 217 dead
-// letters and no signal at all; it was found by a person noticing a stale UI.
-//
-// Failing instead keeps the message on the queue and keeps `Errors` non-zero
-// while the condition lasts. Both are conventional alarm subjects, and a
-// monitoring backend attached through the `DeadLetterSink` seam below now has
-// something to attach to.
-//
-// What that reasoning did not account for is that the transport retries by
-// design too: a failed batch returns to the queue and is redelivered until
-// retention expires. A handler that fails forever, on a transport that retries
-// forever, is a loop — and it outlives its cause, because nothing about a fixed
-// bug removes the message that was stranded by it. Seven of them were still
-// cycling twelve hours after the fix that made them impossible.
-//
-// What the loop costs is now a function of the line, not the count: the first
-// delivery writes the record's ids, kind, size and attribute names — never its
-// body, which is a command or event and may be about a person — and every
-// redelivery after it costs a single identity line. A stranded
-// message is ~150 KB over a fortnight rather than ~17 MB, which is small enough
-// that ending the loop early is an operator's job rather than the topology's.
-let entryPointCode = `export const handler = async (event) => {
-  const records = event?.Records ?? [];
-  for (const record of records) {
-    const attrs = record?.attributes ?? {};
-    const receiveCount = Number(attrs.ApproximateReceiveCount ?? 1);
-    const identity =
-      "messageId=" + (record?.messageId ?? "unknown") +
-      " source=" + (attrs.DeadLetterQueueSourceArn ?? record?.eventSourceARN ?? "unknown") +
-      " receiveCount=" + receiveCount +
-      " bodyBytes=" + (record?.body?.length ?? 0);
-    if (receiveCount <= 1) {
-      // Ids, type and size, never the body: a dead letter is a command or event,
-      // and its payload may be about a person.
-      const body = (() => { try { return JSON.parse(record?.body ?? "null") } catch { return null } })();
-      const kind = body?.command?.TAG ?? body?.event?.TAG ?? (body?.Message ? "sns" : "unknown");
-      console.error("DEAD LETTER ITEM: " + identity + " kind=" + kind +
-        " attributes=" + JSON.stringify(Object.keys(record?.messageAttributes ?? {})));
-    } else {
-      console.error("DEAD LETTER REDELIVERY: " + identity);
-    }
-  }
-  throw new Error(
-    "Dead-lettered " + records.length +
-    " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero."
-  );
-};`
+// The function's whole code is `Util_DeadLetterHandler`'s compiled file, which imports
+// nothing (see there), shipped as `index.mjs`. It sits beside `Util_Bundle`'s compiled file,
+// so it resolves from there.
+let entryPointCode = NodeFs.readFileSync(
+  Util_Bundle.localRequire->NodeModule.requireResolve("./Util_DeadLetterHandler.res.mjs"),
+)
 
 let archiveContents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
 archiveContents->Dict.set(

package/src/util/Util_DeadLetterQueue.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Nodefs from "node:fs";
 import * as Aws from "@pulumi/aws";
 import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
 import * as Pulumi from "@pulumi/pulumi";
@@ -11,6 +12,7 @@ import * as Monitoring$ReventlessCore from "@reventlessdev/reventless-core/src/a
 import * as Util_Bundle$ReventlessAws from "./Util_Bundle.res.mjs";
 import * as Util_Lambda$ReventlessAws from "./Util_Lambda.res.mjs";
 import * as Util_LambdaLogging$ReventlessAws from "./Util_LambdaLogging.res.mjs";
+import * as Util_DeadLetterHandler$ReventlessAws from "./Util_DeadLetterHandler.res.mjs";
 import * as Util_EventSourceMapping$ReventlessAws from "./Util_EventSourceMapping.res.mjs";
 
 let name = "DeadLetterQueue";
@@ -45,32 +47,7 @@ let opts = {
 
 let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), AWS_Tags$ReventlessAws.make(name, "Plugin", "Identity", "Plugin", undefined, undefined, undefined, undefined), opts);
 
-let entryPointCode = `export const handler = async (event) => {
-  const records = event?.Records ?? [];
-  for (const record of records) {
-    const attrs = record?.attributes ?? {};
-    const receiveCount = Number(attrs.ApproximateReceiveCount ?? 1);
-    const identity =
-      "messageId=" + (record?.messageId ?? "unknown") +
-      " source=" + (attrs.DeadLetterQueueSourceArn ?? record?.eventSourceARN ?? "unknown") +
-      " receiveCount=" + receiveCount +
-      " bodyBytes=" + (record?.body?.length ?? 0);
-    if (receiveCount <= 1) {
-      // Ids, type and size, never the body: a dead letter is a command or event,
-      // and its payload may be about a person.
-      const body = (() => { try { return JSON.parse(record?.body ?? "null") } catch { return null } })();
-      const kind = body?.command?.TAG ?? body?.event?.TAG ?? (body?.Message ? "sns" : "unknown");
-      console.error("DEAD LETTER ITEM: " + identity + " kind=" + kind +
-        " attributes=" + JSON.stringify(Object.keys(record?.messageAttributes ?? {})));
-    } else {
-      console.error("DEAD LETTER REDELIVERY: " + identity);
-    }
-  }
-  throw new Error(
-    "Dead-lettered " + records.length +
-    " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero."
-  );
-};`;
+let entryPointCode = Nodefs.readFileSync(Util_Bundle$ReventlessAws.localRequire.resolve("./Util_DeadLetterHandler.res.mjs"), "utf8");
 
 let archiveContents = {};
 
@@ -185,6 +162,8 @@ Pulumi.all([
 
 let retentionSeconds = 1209600;
 
+let maxReceiveCount = Util_DeadLetterHandler$ReventlessAws.maxReceiveCount;
+
 let visibilityTimeoutSeconds = 900;
 
 export {
@@ -192,6 +171,7 @@ export {
   nameFifo,
   queueTags,
   retentionSeconds,
+  maxReceiveCount,
   visibilityTimeoutSeconds,
   queue,
   fifoQueue,

package/tests/Util_DeadLetterHandlerTest.res

@@ -0,0 +1,78 @@
+open JestGlobals
+
+module H = Util_DeadLetterHandler
+
+// A dead letter writes one full line on its first delivery here and a short one on every
+// redelivery. A message moved here by a redrive policy keeps its receive count, so its first
+// delivery reports `maxReceiveCount + 1`; reading only 1 as first meant the full line was
+// never written for any of them.
+
+let recordWith = (~receiveCount: int): H.record => {
+  messageId: "m-1",
+  body: `{"command":{"TAG":"Heartbeat"}}`,
+  attributes: Dict.fromArray([
+    ("ApproximateReceiveCount", Int.toString(receiveCount)),
+    ("DeadLetterQueueSourceArn", "arn:aws:sqs:eu-west-1:1:CmdTopic"),
+  ]),
+}
+
+let isItem = line => line->String.startsWith("DEAD LETTER ITEM:")
+
+describe("the dead-letter handler's line", () => {
+  testSync("is the full one when a redriven message first arrives", () => {
+    let line = H.lineOf(recordWith(~receiveCount=H.maxReceiveCount + 1))
+    expect((isItem(line), line->String.includes("kind=Heartbeat")))->toEqual((true, true))
+  })
+
+  testSync("is the full one for a message sent here directly", () =>
+    expect(isItem(H.lineOf(recordWith(~receiveCount=1))))->toBe(true)
+  )
+
+  testSync("is the short one on a redelivery", () => {
+    let line = H.lineOf(recordWith(~receiveCount=H.maxReceiveCount + 2))
+    expect((
+      line->String.startsWith("DEAD LETTER REDELIVERY:"),
+      line->String.includes("kind="),
+    ))->toEqual((true, false))
+  })
+
+  testSync("names an unreadable body's kind unknown, and never writes the body", () => {
+    let line = H.lineOf({
+      messageId: "m-2",
+      body: "not json, about a person",
+      attributes: Dict.make(),
+    })
+    expect((
+      line->String.includes("kind=unknown"),
+      line->String.includes("about a person"),
+    ))->toEqual((true, false))
+  })
+})
+
+describe("the dead-letter handler", () => {
+  test("fails on purpose, so the messages stay on the queue", async () => {
+    let failed = switch await H.handler({records: [recordWith(~receiveCount=6)]}) {
+    | () => false
+    | exception _ => true
+    }
+    expect(failed)->toBe(true)
+  })
+
+  // The function ships the compiled file alone, so it must import nothing.
+  testSync("compiles to a file that imports nothing", () => {
+    let text = NodeFs.readFileSync(
+      NodePath.join([
+        NodePath.dirname(NodeUrl.fileURLToPath(%raw("import.meta.url"))),
+        "..",
+        "src",
+        "util",
+        "Util_DeadLetterHandler.res.mjs",
+      ]),
+    )
+    expect(
+      text
+      ->String.split("\n")
+      ->Array.some(l => l->String.startsWith("import ") || l->String.includes("require(")),
+    )->toBe(false)
+  })
+})

package/tests/Util_DeadLetterHandlerTest.res.mjs

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeurl from "node:url";
+import * as Nodepath from "node:path";
+import * as Util_DeadLetterHandler$ReventlessAws from "../src/util/Util_DeadLetterHandler.res.mjs";
+
+function recordWith(receiveCount) {
+  return {
+    messageId: "m-1",
+    body: `{"command":{"TAG":"Heartbeat"}}`,
+    attributes: Object.fromEntries([
+      [
+        "ApproximateReceiveCount",
+        receiveCount.toString()
+      ],
+      [
+        "DeadLetterQueueSourceArn",
+        "arn:aws:sqs:eu-west-1:1:CmdTopic"
+      ]
+    ])
+  };
+}
+
+function isItem(line) {
+  return line.startsWith("DEAD LETTER ITEM:");
+}
+
+globalThis.describe("the dead-letter handler's line", () => {
+  globalThis.test("is the full one when a redriven message first arrives", () => {
+    let line = Util_DeadLetterHandler$ReventlessAws.lineOf(recordWith(Util_DeadLetterHandler$ReventlessAws.maxReceiveCount + 1 | 0));
+    globalThis.expect([
+      line.startsWith("DEAD LETTER ITEM:"),
+      line.includes("kind=Heartbeat")
+    ]).toEqual([
+      true,
+      true
+    ]);
+  });
+  globalThis.test("is the full one for a message sent here directly", () => {
+    globalThis.expect(Util_DeadLetterHandler$ReventlessAws.lineOf(recordWith(1)).startsWith("DEAD LETTER ITEM:")).toBe(true);
+  });
+  globalThis.test("is the short one on a redelivery", () => {
+    let line = Util_DeadLetterHandler$ReventlessAws.lineOf(recordWith(Util_DeadLetterHandler$ReventlessAws.maxReceiveCount + 2 | 0));
+    globalThis.expect([
+      line.startsWith("DEAD LETTER REDELIVERY:"),
+      line.includes("kind=")
+    ]).toEqual([
+      true,
+      false
+    ]);
+  });
+  globalThis.test("names an unreadable body's kind unknown, and never writes the body", () => {
+    let line = Util_DeadLetterHandler$ReventlessAws.lineOf({
+      messageId: "m-2",
+      body: "not json, about a person",
+      attributes: {}
+    });
+    globalThis.expect([
+      line.includes("kind=unknown"),
+      line.includes("about a person")
+    ]).toEqual([
+      true,
+      false
+    ]);
+  });
+});
+
+globalThis.describe("the dead-letter handler", () => {
+  globalThis.test("fails on purpose, so the messages stay on the queue", async () => {
+    let failed;
+    try {
+      await Util_DeadLetterHandler$ReventlessAws.handler({
+        Records: [recordWith(6)]
+      });
+      failed = false;
+    } catch (exn) {
+      failed = true;
+    }
+    globalThis.expect(failed).toBe(true);
+  });
+  globalThis.test("compiles to a file that imports nothing", () => {
+    let text = Nodefs.readFileSync(Nodepath.join(Nodepath.dirname(Nodeurl.fileURLToPath(import.meta.url)), "..", "src", "util", "Util_DeadLetterHandler.res.mjs"), "utf8");
+    globalThis.expect(text.split("\n").some(l => {
+      if (l.startsWith("import ")) {
+        return true;
+      } else {
+        return l.includes("require(");
+      }
+    })).toBe(false);
+  });
+});
+
+let H;
+
+export {
+  H,
+  recordWith,
+  isItem,
+}
+/*  Not a pure module */