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

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.232 (2026-07-27)
+
+### Bug Fixes
+
+* **aws:** keep InboundTranslationSlice runtime path out of the Pulumi graph ([9166cff](https://github.com/ReventlessDev/reventless-core/commit/9166cff85939012d12e44835e2eb79a88fd1b66a))
+
+
+# 3.0.0-alpha.231 (2026-07-27)
+
+### Bug Fixes
+
+* **aws:** route InboundTranslationSlice mutations in the deployed DCB Lambda ([feb129c](https://github.com/ReventlessDev/reventless-core/commit/feb129caf291395e7d35bb953030a1e3efa06e1a))
+
+
 # 3.0.0-alpha.230 (2026-07-27)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.230",
+  "version": "3.0.0-alpha.232",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -11,16 +11,16 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.24",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.60",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.182",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.183",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.46",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.47",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.81"
   },
   "devDependencies": {

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -25,7 +25,8 @@ import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessde
 // per-slice handler building (functor + decode + handleCommands), all
 // compiler-checked against the framework signatures (see the module header and
 // docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
-import { deriveScope, commandTypeNames, makeStorageOps, buildSliceHandler } from "./DcbCommandTopicEntryPoint_Ops.res.mjs";
+import { deriveScope, commandTypeNames, makeStorageOps, buildSliceHandler, buildInboundReceiver } from "./DcbCommandTopicEntryPoint_Ops.res.mjs";
+import { makeDynamoQueryDbOps } from "./QueryDbEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
@@ -145,6 +146,32 @@ export async function buildHandlersForConfig(config, opts = {}) {
   const sqsHandler = handleQueueEvent(resolvedQueue, compositeJsonCommandsHandler);
   const publishJsons = sqsPublishJsons(resolvedQueue, "SQS_FIFO");
 
+  // Route 0 registry: InboundTranslationSlice receive handlers keyed by their
+  // AppSync mutation field name. The resolver invokes this Lambda with
+  // {__inboundTranslation, fieldName, arguments}; the field name is
+  // `<pluginName>_<sliceName>` (Api_Naming.sliceMutationField — the deploy side
+  // uses the same `name` that HANDLER_CONFIG.pluginName carries). The spec +
+  // translation modules are the one untyped seam (dynamic import); the typed
+  // `buildInboundReceiver` owns the functor call + audit persistence. Audit ops
+  // are DynamoDB-only for now (makeDynamoQueryDbOps); Postgres audit is a
+  // follow-up, so on that backend the receiver runs without persistence.
+  const inboundModules = config.inboundTranslationSliceModules || [];
+  const inboundReceiversByField = {};
+  await Promise.all(inboundModules.map(async ({ spec, translation, auditTableName }) => {
+    const specModule = await loadModule(spec);
+    const translationModule = await loadModule(translation);
+    const auditOps = (auditTableName && !config.pgConnection)
+      ? makeDynamoQueryDbOps(auditTableName)
+      : undefined;
+    const fieldName = config.pluginName + "_" + specModule.name;
+    inboundReceiversByField[fieldName] = buildInboundReceiver(
+      specModule,
+      translationModule,
+      publishJsons,
+      auditOps,
+    );
+  }));
+
   // Sync (default): inline-dispatch the command via the same composite handler
   // that Route 2 uses, so the AppSync resolver gets a typed Accepted/Rejected
   // outcome. Async: undefined → makeCommandGenerator falls back to publishJsons
@@ -185,10 +212,11 @@ export async function buildHandlersForConfig(config, opts = {}) {
     return generateCommand({ ...event, meta, identity });
   };
 
-  // Third element is additive — existing callers (the integration tests) keep
-  // destructuring the first two. No deploy-time `plugin` fragment needed here:
-  // this Lambda serves exactly one plugin and HANDLER_CONFIG already names it.
-  return [sqsHandler, cmdGenHandler, dcbComp(config.pluginName), config.pluginName];
+  // Elements past the first two are additive — existing callers (the integration
+  // tests) keep destructuring the first two. No deploy-time `plugin` fragment
+  // needed here: this Lambda serves exactly one plugin and HANDLER_CONFIG already
+  // names it. The 5th element is the Route 0 inbound-translation registry.
+  return [sqsHandler, cmdGenHandler, dcbComp(config.pluginName), config.pluginName, inboundReceiversByField];
 }
 
 async function buildHandler() {
@@ -205,7 +233,24 @@ const initPromise = buildHandler();
 
 export async function handler(event, context) {
   setRequestId(context?.awsRequestId);
-  const [sqsHandler, cmdGenHandler, comp, plugin] = await initPromise;
+  const [sqsHandler, cmdGenHandler, comp, plugin, inboundReceivers] = await initPromise;
+
+  // Route 0: InboundTranslationSlice mutation — the AppSync resolver invokes this
+  // Lambda with `{__inboundTranslation: true, fieldName, arguments}` (no `command`,
+  // no `Records`). Dispatch to the field's receive handler, which translates +
+  // publishes and returns a commandOutcome JSON byte-compatible with Route 1's
+  // `commandOutcomeToJson`. Without this branch the payload fell through to Route 2
+  // and crashed on `event.records` being undefined.
+  if (event.__inboundTranslation === true) {
+    const fieldName = event.fieldName;
+    const receiver = (inboundReceivers || {})[fieldName];
+    if (receiver === undefined) {
+      log.warn("no inbound translation receiver for field: " + fieldName, { comp: "DcbCommandTopicRuntime" });
+      throw new Error("no inbound translation receiver for field: " + fieldName);
+    }
+    log.debug("InboundTranslation invocation (" + fieldName + ")", { comp: "DcbCommandTopicRuntime" });
+    return await receiver(event.arguments);
+  }
 
   // Route 1: AppSync direct invocation — payload carries the CommandGenerator.payload
   // shape (`{command, arguments, meta, identity?}`).

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res

@@ -219,3 +219,66 @@ let buildSliceHandler = (
     callback.handleCommands(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLog, decodedStream)
   }
 }
+
+// ── Inbound translation receiver wiring (Route 0) ───────────────────────────
+// The DCB command Lambda is also the target of every InboundTranslationSlice
+// mutation on the plugin's API — its AppSync resolver invokes this Lambda with an
+// `{__inboundTranslation, fieldName, arguments}` payload. Building the per-field
+// `receive` here keeps the curried `InboundTranslationSlice_Callback.Make` functor
+// call compiler-checked (same rationale as `buildSliceHandler`) and mirrors the
+// in-process composite handler in `Dcb_Builder.res`, so the deployed surface and
+// the local surface encode the same `commandOutcome`.
+
+// The dynamically-imported Translation module — opaque; a clean pass-through to
+// the functor (only `translate` is read, inside the compiled callback).
+type translationModule
+
+type inboundCallback = {
+  receive: (
+    ReventlessInfra.CommandTopic.publishJsons,
+    JSON.t,
+  ) => promise<ReventlessInfra.InboundTranslationSlice.receiveResult>,
+  auditLog: dict<ReventlessCore.InboundTranslationSlice_Callback.auditRow>,
+}
+@module("@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs")
+external makeInboundCallback: specModule => translationModule => inboundCallback = "Make"
+
+// Builds the inbound receive handler: run the slice's `receive` (which validates
+// the external input against the spec schema, translates, and publishes the mapped
+// commands via `publishJsons`), then — when an audit table name was threaded —
+// drain the in-memory audit log to that table (best-effort, matching
+// `InboundTranslationSlice_Builder`'s inline `syncToQueryDb`). Returns the
+// `commandOutcome` JSON, byte-compatible with the AppSync direct-invocation route.
+let buildInboundReceiver = (
+  spec: specModule,
+  translation: translationModule,
+  ~publishJsons: ReventlessInfra.CommandTopic.publishJsons,
+  ~auditQueryDbOps: option<ReventlessCore.QueryDb_Adapter.operations>,
+) => {
+  let callback = makeInboundCallback(spec)(translation)
+  async (args: JSON.t): JSON.t => {
+    let result = await callback.receive(publishJsons, args)
+    switch auditQueryDbOps {
+    | Some(ops) =>
+      let rows = callback.auditLog->Dict.toArray
+      let _ = await rows->Array.reduce(Promise.resolve(), async (prev, (id, row)) => {
+        let _ = await prev
+        let json = row->S.reverseConvertToJsonOrThrow(
+          ReventlessCore.InboundTranslationSlice_Callback.auditRowSchema,
+        )
+        try {
+          let _ = await ops.save(id, json, ReventlessCore.QueryDb.Overwrite, None)
+        } catch {
+        | _ => ()
+        }
+      })
+    | None => ()
+    }
+    result
+    ->ReventlessCore.InboundTranslationSlice_Callback.receiveResultToOutcome
+    // `CommandTopic_Helpers`, not `CommandTopic`: the latter imports `Adapter`
+    // (→ `@pulumi/pulumi`) for a deploy-time helper, which would crash this
+    // runtime Lambda's cold start. The encoder itself lives in the pure Helpers.
+    ->ReventlessCore.CommandTopic_Helpers.commandOutcomeToJson
+  }
+}

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

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
@@ -7,9 +9,12 @@ import * as Stream from "effect/Stream";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
+import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
 import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
 import * as DcbEventLogStorage_Postgres_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_Postgres_Runtime.res.mjs";
 import * as StateChangeSlice_CallbackResMjs from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+import * as InboundTranslationSlice_CallbackResMjs from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
 
 function deriveScope(specs) {
   let scope = DcbTag$Reventless.deriveEffectiveScope(specs.map(s => ({
@@ -93,6 +98,27 @@ function buildSliceHandler(spec, behavior, tagKeysByEventType, crossPartitionTag
   };
 }
 
+function buildInboundReceiver(spec, translation, publishJsons, auditQueryDbOps) {
+  let callback = InboundTranslationSlice_CallbackResMjs.Make(spec)(translation);
+  return async args => {
+    let result = await callback.receive(publishJsons, args);
+    if (auditQueryDbOps !== undefined) {
+      let rows = Object.entries(callback.auditLog);
+      await Stdlib_Array.reduce(rows, Promise.resolve(), async (prev, param) => {
+        await prev;
+        let json = S.reverseConvertToJsonOrThrow(param[1], InboundTranslationSlice_Callback$ReventlessCore.auditRowSchema);
+        try {
+          await auditQueryDbOps.save(param[0], json, "Overwrite", undefined);
+          return;
+        } catch (exn) {
+          return;
+        }
+      });
+    }
+    return CommandTopic_Helpers$ReventlessCore.commandOutcomeToJson(InboundTranslationSlice_Callback$ReventlessCore.receiveResultToOutcome(result));
+  };
+}
+
 export {
   deriveScope,
   commandTypeNames,
@@ -100,5 +126,6 @@ export {
   makePostgresStorageOps,
   makeStorageOps,
   buildSliceHandler,
+  buildInboundReceiver,
 }
-/* Id-Reventless Not a pure module */
+/* S Not a pure module */

package/src/adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res

@@ -13,10 +13,22 @@
 
 let log = ReventlessCore.Logger.fromEnv()
 
+// `(specPath, translationPath)` module specifiers per InboundTranslationSlice,
+// plus the resolved audit QueryDb table-name Output (None on the Postgres path or
+// if the component hasn't reported it). The entry point imports both modules,
+// builds `InboundTranslationSlice_Callback.Make(Spec)(Translation).receive`, and
+// — when `auditTableName` is present — persists the audit rows to that table.
+type inboundSlicePaths = {
+  specPath: string,
+  translationPath: string,
+  auditTableName: option<Pulumi.Output.t<string>>,
+}
+
 // `slicePaths`: `(specPath, behaviorPath)` per StateChangeSlice (already merged
 // from auto- and manually-registered sources by the caller).
 let forDcbCommandTopic = (
   ~slicePaths: array<(string, string)>,
+  ~inboundSlices: array<inboundSlicePaths>=[],
   ~dcbTableName: option<Pulumi.Output.t<string>>,
   ~pluginName: string,
   ~syncConfig: ReventlessCore.Runtime.commandHandlerConfig,
@@ -29,7 +41,7 @@ let forDcbCommandTopic = (
   ~connect,
   dcbCommandTopic,
 ) =>
-  if slicePaths->Array.length == 0 {
+  if slicePaths->Array.length == 0 && inboundSlices->Array.length == 0 {
     log.warn(
       ~comp="StateChangeSliceRuntime_Builder_Single",
       "forDcbCommandTopic skipped (no slice specs)",
@@ -122,11 +134,37 @@ let forDcbCommandTopic = (
     | None => Pulumi.Output.make("")
     }
 
+    // InboundTranslationSlice modules — spec + translation paths and the resolved
+    // audit table name (Pulumi-generated, so it must be resolved here). Emitted as
+    // a `,"inboundTranslationSliceModules":[…]` fragment merged into HANDLER_CONFIG
+    // (absent → the entry point has no Route 0 registry, unchanged behaviour).
+    let inboundFragment = switch inboundSlices {
+    | [] => Pulumi.Output.make("")
+    | slices =>
+      slices
+      ->Array.map(s => s.auditTableName->Option.getOr(Pulumi.Output.make("")))
+      ->Pulumi.Output.all
+      ->Pulumi.Output.apply(tableNames => {
+        let entries =
+          slices
+          ->Array.mapWithIndex((s, i) => {
+            let spec = s.specPath->JSON.stringifyAny->Option.getOr(`""`)
+            let translation = s.translationPath->JSON.stringifyAny->Option.getOr(`""`)
+            let tableName = tableNames->Array.getUnsafe(i)
+            let auditJson =
+              tableName == "" ? "null" : tableName->JSON.stringifyAny->Option.getOr("null")
+            `{"spec":${spec},"translation":${translation},"auditTableName":${auditJson}}`
+          })
+          ->Array.join(",")
+        `,"inboundTranslationSliceModules":[${entries}]`
+      })
+    }
+
     let handlerConfigJson =
-      Pulumi.Output.all3((dcbTableName, queue.id, pgConnectionFragment))
-      ->Pulumi.Output.apply(((table, queueUrl, pgFragment)) => {
+      Pulumi.Output.all4((dcbTableName, queue.id, pgConnectionFragment, inboundFragment))
+      ->Pulumi.Output.apply(((table, queueUrl, pgFragment, inbFragment)) => {
         let pluginNameJson = pluginName->JSON.stringifyAny->Option.getOr(`""`)
-        `{"dcbEventLogTableName":"${table}","queueUrl":"${queueUrl}","pluginName":${pluginNameJson},"stateChangeSliceModules":[${sliceModulesJson}]${pgFragment}}`
+        `{"dcbEventLogTableName":"${table}","queueUrl":"${queueUrl}","pluginName":${pluginNameJson},"stateChangeSliceModules":[${sliceModulesJson}]${pgFragment}${inbFragment}}`
       })
     envVars->Dict.set("HANDLER_CONFIG", handlerConfigJson->Pulumi.Output.asInput)
 
@@ -138,6 +176,13 @@ let forDcbCommandTopic = (
       let behaviorPkg = Util_Bundle.extractPackageName(behaviorPath)
       packageDirs->Dict.set(behaviorPkg, Util_Bundle.resolvePackageRoot(behaviorPkg))
     })
+    // Inbound slice spec + translation packages the entry point imports for Route 0.
+    inboundSlices->Array.forEach(s => {
+      let specPkg = Util_Bundle.extractPackageName(s.specPath)
+      packageDirs->Dict.set(specPkg, Util_Bundle.resolvePackageRoot(specPkg))
+      let translationPkg = Util_Bundle.extractPackageName(s.translationPath)
+      packageDirs->Dict.set(translationPkg, Util_Bundle.resolvePackageRoot(translationPkg))
+    })
     // Include the framework packages alongside the entry point so the deployed
     // Lambda picks up uncommitted local changes without waiting for the Lambda
     // Layer rebuild (the layer fetches @reventlessdev/reventless-* from GitHub

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

@@ -16,10 +16,11 @@ import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_L
 
 let log = Logger$ReventlessCore.fromEnv();
 
-function forDcbCommandTopic(slicePaths, dcbTableName, pluginName, syncConfig, asyncConfig, sliceMemoryFloorOpt, sliceTimeoutFloorOpt, connect, dcbCommandTopic) {
+function forDcbCommandTopic(slicePaths, inboundSlicesOpt, dcbTableName, pluginName, syncConfig, asyncConfig, sliceMemoryFloorOpt, sliceTimeoutFloorOpt, connect, dcbCommandTopic) {
+  let inboundSlices = inboundSlicesOpt !== undefined ? inboundSlicesOpt : [];
   let sliceMemoryFloor = sliceMemoryFloorOpt !== undefined ? sliceMemoryFloorOpt : 0;
   let sliceTimeoutFloor = sliceTimeoutFloorOpt !== undefined ? sliceTimeoutFloorOpt : 0;
-  if (slicePaths.length === 0) {
+  if (slicePaths.length === 0 && inboundSlices.length === 0) {
     return log.warn("StateChangeSliceRuntime_Builder_Single", undefined, "forDcbCommandTopic skipped (no slice specs)");
   }
   let commandTopicResource = Component$ReventlessCore.toPulumiResource(dcbCommandTopic);
@@ -58,13 +59,24 @@ function forDcbCommandTopic(slicePaths, dcbTableName, pluginName, syncConfig, as
     return `{"spec":` + s + `,"behavior":` + b + `}`;
   }).join(",");
   let pgConnectionFragment = pgSelection !== undefined ? pgSelection.connectionConfig.apply(cc => `,"pgConnection":` + JSON.stringify(PgConnection$ReventlessAws.connectionConfigToJson(pgSelection.lockStrategy, cc))) : Pulumi.output("");
+  let inboundFragment = inboundSlices.length !== 0 ? Pulumi.all(inboundSlices.map(s => Stdlib_Option.getOr(s.auditTableName, Pulumi.output("")))).apply(tableNames => {
+      let entries = inboundSlices.map((s, i) => {
+        let spec = Stdlib_Option.getOr(JSON.stringify(s.specPath), `""`);
+        let translation = Stdlib_Option.getOr(JSON.stringify(s.translationPath), `""`);
+        let tableName = tableNames[i];
+        let auditJson = tableName === "" ? "null" : Stdlib_Option.getOr(JSON.stringify(tableName), "null");
+        return `{"spec":` + spec + `,"translation":` + translation + `,"auditTableName":` + auditJson + `}`;
+      }).join(",");
+      return `,"inboundTranslationSliceModules":[` + entries + `]`;
+    }) : Pulumi.output("");
   let handlerConfigJson = Pulumi.all([
     dcbTableName$1,
     queue.id,
-    pgConnectionFragment
+    pgConnectionFragment,
+    inboundFragment
   ]).apply(param => {
     let pluginNameJson = Stdlib_Option.getOr(JSON.stringify(pluginName), `""`);
-    return `{"dcbEventLogTableName":"` + param[0] + `","queueUrl":"` + param[1] + `","pluginName":` + pluginNameJson + `,"stateChangeSliceModules":[` + sliceModulesJson + `]` + param[2] + `}`;
+    return `{"dcbEventLogTableName":"` + param[0] + `","queueUrl":"` + param[1] + `","pluginName":` + pluginNameJson + `,"stateChangeSliceModules":[` + sliceModulesJson + `]` + param[2] + param[3] + `}`;
   });
   envVars["HANDLER_CONFIG"] = handlerConfigJson;
   let packageDirs = {};
@@ -74,6 +86,12 @@ function forDcbCommandTopic(slicePaths, dcbTableName, pluginName, syncConfig, as
     let behaviorPkg = Util_Bundle$ReventlessAws.extractPackageName(param[1]);
     packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
   });
+  inboundSlices.forEach(s => {
+    let specPkg = Util_Bundle$ReventlessAws.extractPackageName(s.specPath);
+    packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
+    let translationPkg = Util_Bundle$ReventlessAws.extractPackageName(s.translationPath);
+    packageDirs[translationPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(translationPkg);
+  });
   packageDirs["@reventlessdev/reventless-aws"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-aws");
   packageDirs["@reventlessdev/reventless-core"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-core");
   let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs", packageDirs, undefined);

package/src/components/InboundTranslationSlice_Builder.res

@@ -15,11 +15,37 @@ module Make = (Api: {
     Spec: Reventless.InboundTranslationSlice.Spec,
     Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
   ): (ReventlessCore.InboundTranslationSlice.T with module Spec = Spec) => {
+    // Register spec + translation module paths so the shared DCB command Lambda's
+    // entry point can import them and route `__inboundTranslation` payloads to this
+    // slice's `receive` (mirrors StateChangeSlice_Builder's path registration).
+    PluginRuntime_Builder.registerInboundTranslationSliceSpec(
+      ~specName=Spec.name,
+      ~specPath=Util_Bundle.getModuleSpecifier(Spec.moduleUrl),
+      ~translationPath=Util_Bundle.getModuleSpecifier(Translation.moduleUrl),
+    )
     module InnerMake = Inner.Make(Spec, Translation)
     module Spec = Spec
     module Translation = Translation
     type component = InnerMake.component
     let queryDbName = InnerMake.queryDbName
-    let make = InnerMake.make
+
+    let make = (~publishJsons, ~runtime=?, ~opts=?) => {
+      let component = InnerMake.make(~publishJsons, ~runtime?, ~opts?)
+      // The audit QueryDb's physical table name is Pulumi-generated, so it can only
+      // be read off the constructed component's outputs (resolved synchronously here,
+      // before forDcbCommandTopic builds HANDLER_CONFIG). Thread it so the entry
+      // point's Route 0 can persist the audit rows the in-process path writes inline.
+      let outputs: ReventlessInfra.InboundTranslationSlice.outputs =
+        component->ReventlessCore.Component.outputs
+      switch outputs.queryDb.resources->Array.get(0) {
+      | Some(tableResource) =>
+        PluginRuntime_Builder.registerInboundAuditTableName(
+          ~specName=Spec.name,
+          tableResource.name,
+        )
+      | None => ()
+      }
+      component
+    }
   }
 }

package/src/components/InboundTranslationSlice_Builder.res.mjs

@@ -1,5 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../util/Util_Bundle.res.mjs";
+import * as PluginRuntime_Builder$ReventlessAws from "../plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as QueryDbStorage_DynamoDb$ReventlessAws from "../adapter/QueryDb/QueryDbStorage_DynamoDb.res.mjs";
 import * as QueryDbResolvers_AppSync$ReventlessAws from "../adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs";
 import * as InboundTranslationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Builder.res.mjs";
@@ -11,12 +14,22 @@ function Make(Api) {
     make: QueryDbResolvers_AppSync$ReventlessAws.make
   })(Api);
   let Make$1 = Spec => (Translation => {
+    PluginRuntime_Builder$ReventlessAws.registerInboundTranslationSliceSpec(Spec.name, Util_Bundle$ReventlessAws.getModuleSpecifier(Spec.moduleUrl), Util_Bundle$ReventlessAws.getModuleSpecifier(Translation.moduleUrl));
     let InnerMake = Inner.Make(Spec)(Translation);
+    let make = (publishJsons, runtime, opts) => {
+      let component = InnerMake.make(publishJsons, runtime, opts);
+      let outputs = Component$ReventlessCore.outputs(component);
+      let tableResource = outputs.queryDb.resources[0];
+      if (tableResource !== undefined) {
+        PluginRuntime_Builder$ReventlessAws.registerInboundAuditTableName(Spec.name, tableResource.name);
+      }
+      return component;
+    };
     return {
       Spec: Spec,
       Translation: Translation,
       queryDbName: InnerMake.queryDbName,
-      make: InnerMake.make
+      make: make
     };
   });
   return {
@@ -28,4 +41,4 @@ function Make(Api) {
 export {
   Make,
 }
-/* QueryDbStorage_DynamoDb-ReventlessAws Not a pure module */
+/* Component-ReventlessCore Not a pure module */

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -43,6 +43,44 @@ let registerStateChangeSliceSpec = (~specPath: string, ~behaviorPath: string) =>
   let _ = registeredSliceModulePaths->Array.push({specPath, behaviorPath})
 }
 
+// InboundTranslationSlice registration for the shared DCB command Lambda. Unlike
+// StateChangeSlices (routed by command TAG), inbound slices are invoked directly
+// by their AppSync mutation resolver with an `__inboundTranslation` payload — the
+// entry point routes those to a `receive` handler built from the spec + translation
+// modules. Registration is two-phase: the AWS `InboundTranslationSlice_Builder`
+// functor registers the module paths at instantiation (spec/translation `moduleUrl`,
+// like StateChangeSlice), and its wrapped `make` registers the audit QueryDb's
+// resolved table-name Output once the component is constructed (the physical name
+// is Pulumi-generated, so it can't be reconstructed at runtime). Both fire before
+// `forDcbCommandTopic` reads them.
+type inboundSliceReg = {
+  specPath: string,
+  translationPath: string,
+  mutable auditTableName: option<Pulumi.Output.t<string>>,
+}
+let registeredInboundSlices: dict<inboundSliceReg> = Dict.make()
+
+let registerInboundTranslationSliceSpec = (
+  ~specName: string,
+  ~specPath: string,
+  ~translationPath: string,
+) =>
+  switch registeredInboundSlices->Dict.get(specName) {
+  | Some(reg) => registeredInboundSlices->Dict.set(specName, {...reg, specPath, translationPath})
+  | None =>
+    registeredInboundSlices->Dict.set(specName, {specPath, translationPath, auditTableName: None})
+  }
+
+let registerInboundAuditTableName = (~specName: string, tableName: Pulumi.Output.t<string>) =>
+  switch registeredInboundSlices->Dict.get(specName) {
+  | Some(reg) => reg.auditTableName = Some(tableName)
+  | None =>
+    registeredInboundSlices->Dict.set(
+      specName,
+      {specPath: "", translationPath: "", auditTableName: Some(tableName)},
+    )
+  }
+
 /**
 Redundant with the seams that populate `dcbConfigRef` automatically:
 `pluginName` is set by `registerPluginName` (called from `Plugin_Builder.make`
@@ -768,8 +806,28 @@ module Make = (
       registeredSliceModulePaths
       ->Array.concat(dcbConfig.stateChangeSliceModulePaths)
       ->Array.map(({specPath, behaviorPath}) => (specPath, behaviorPath))
+    // Drop registrations that never received their module paths (a bare
+    // audit-table registration with no matching spec functor — shouldn't happen,
+    // but keeps a half-registered slice out of HANDLER_CONFIG).
+    let inboundSlices =
+      registeredInboundSlices
+      ->Dict.valuesToArray
+      ->Array.filterMap(reg =>
+        reg.specPath == ""
+          ? None
+          : Some(
+              (
+                {
+                  StateChangeSliceRuntime_Builder_Single.specPath: reg.specPath,
+                  translationPath: reg.translationPath,
+                  auditTableName: reg.auditTableName,
+                }: StateChangeSliceRuntime_Builder_Single.inboundSlicePaths
+              ),
+            )
+      )
     StateChangeSliceRuntime_Builder_Single.forDcbCommandTopic(
       ~slicePaths,
+      ~inboundSlices,
       ~dcbTableName=dcbConfig.dcbTableName,
       ~pluginName=dcbConfig.pluginName,
       ~syncConfig=syncStateChangesConfigRef.contents,

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Aws from "@pulumi/aws";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
@@ -50,6 +51,38 @@ function registerStateChangeSliceSpec(specPath, behaviorPath) {
   });
 }
 
+let registeredInboundSlices = {};
+
+function registerInboundTranslationSliceSpec(specName, specPath, translationPath) {
+  let reg = registeredInboundSlices[specName];
+  if (reg !== undefined) {
+    registeredInboundSlices[specName] = {
+      specPath: specPath,
+      translationPath: translationPath,
+      auditTableName: reg.auditTableName
+    };
+  } else {
+    registeredInboundSlices[specName] = {
+      specPath: specPath,
+      translationPath: translationPath,
+      auditTableName: undefined
+    };
+  }
+}
+
+function registerInboundAuditTableName(specName, tableName) {
+  let reg = registeredInboundSlices[specName];
+  if (reg !== undefined) {
+    reg.auditTableName = tableName;
+  } else {
+    registeredInboundSlices[specName] = {
+      specPath: "",
+      translationPath: "",
+      auditTableName: tableName
+    };
+  }
+}
+
 function registerDcbConfig(pluginName, dcbTableName, stateChangeSliceModulePathsOpt, param) {
   let stateChangeSliceModulePaths = stateChangeSliceModulePathsOpt !== undefined ? stateChangeSliceModulePathsOpt : [];
   dcbConfigRef.contents = {
@@ -433,7 +466,18 @@ function Make(EventCollectorChannel) {
       param.specPath,
       param.behaviorPath
     ]);
-    StateChangeSliceRuntime_Builder_Single$ReventlessAws.forDcbCommandTopic(slicePaths, dcbConfig.dcbTableName, dcbConfig.pluginName, syncStateChangesConfigRef.contents, asyncStateChangesConfigRef.contents, memorySize, timeout, connect, dcbCommandTopic);
+    let inboundSlices = Stdlib_Array.filterMap(Object.values(registeredInboundSlices), reg => {
+      if (reg.specPath === "") {
+        return;
+      } else {
+        return {
+          specPath: reg.specPath,
+          translationPath: reg.translationPath,
+          auditTableName: reg.auditTableName
+        };
+      }
+    });
+    StateChangeSliceRuntime_Builder_Single$ReventlessAws.forDcbCommandTopic(slicePaths, inboundSlices, dcbConfig.dcbTableName, dcbConfig.pluginName, syncStateChangesConfigRef.contents, asyncStateChangesConfigRef.contents, memorySize, timeout, connect, dcbCommandTopic);
   };
   let finish = () => {};
   return {
@@ -452,6 +496,9 @@ export {
   dcbConfigRef,
   registeredSliceModulePaths,
   registerStateChangeSliceSpec,
+  registeredInboundSlices,
+  registerInboundTranslationSliceSpec,
+  registerInboundAuditTableName,
   registerDcbConfig,
   registerDcbTableName,
   heartbeatConfigRef,

package/tests/DcbInboundTranslationRoutingTest.res

@@ -0,0 +1,73 @@
+// CI routing guard for the DCB CommandTopic Lambda's Route 0 (InboundTranslation).
+//
+// The AppSync resolver for an InboundTranslationSlice mutation invokes the shared
+// DCB command Lambda with `{__inboundTranslation, fieldName, arguments}` — no
+// `command`, no `Records`. Before Route 0 existed the payload fell through to the
+// SQS route and crashed on `event.records` being undefined ("Cannot read
+// properties of undefined (reading 'length')"), so every inbound mutation 500'd
+// on a deployed stack (docs/plans/done/aws-inbound-translation-lambda-routing.md).
+// The gap that let this ship: `__inboundTranslation` was only ever asserted on the
+// sending side (the resolver-template test). This pins the receiving end.
+//
+// Drives the real `buildHandlersForConfig` with an inbound slice module and a stub
+// loader, then dispatches the payload exactly as `handler`'s Route 0 does. The
+// fixture translation rejects its input, so the receiver returns CommandRejected
+// inline without touching SQS or DynamoDB — no Docker needed, runs in CI.
+
+open JestGlobals
+
+let routeInbound: JSON.t => promise<JSON.t> = %raw(`
+  async (event) => {
+    const { buildHandlersForConfig } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs"
+    );
+    const loadModule = async (specifier) => {
+      if (specifier === "ep-inbound-test://spec") return await import("./EpInboundTestSlice.res.mjs");
+      if (specifier === "ep-inbound-test://translation") return await import("./EpInboundTestSliceTranslation.res.mjs");
+      throw new Error("unknown test specifier: " + specifier);
+    };
+    const config = {
+      pluginName: "EpInboundTestPlugin",
+      dcbEventLogTableName: "ep-inbound-test-table",
+      stateChangeSliceModules: [],
+      queueUrl: "https://sqs.eu-west-1.amazonaws.com/000000000000/ep-inbound-test-queue",
+      inboundTranslationSliceModules: [
+        { spec: "ep-inbound-test://spec", translation: "ep-inbound-test://translation", auditTableName: null },
+      ],
+    };
+    const [,,,, inboundReceivers] = await buildHandlersForConfig(config, { loadModule });
+    // Mirror handler's Route 0 dispatch.
+    const receiver = (inboundReceivers || {})[event.fieldName];
+    if (receiver === undefined) throw new Error("no inbound receiver for " + event.fieldName);
+    return await receiver(event.arguments);
+  }
+`)
+
+let inboundEvent = (~fieldName, ~currency): JSON.t => {
+  let arguments = Dict.fromArray([
+    ("sku", "SKU-1"->JSON.Encode.string),
+    ("currency", currency->JSON.Encode.string),
+  ])
+  Dict.fromArray([
+    ("__inboundTranslation", true->JSON.Encode.bool),
+    ("fieldName", fieldName->JSON.Encode.string),
+    ("arguments", arguments->JSON.Encode.object),
+  ])->JSON.Encode.object
+}
+
+describe("DcbCommandTopicEntryPoint Route 0 (InboundTranslation)", () => {
+  test(
+    "routes an __inboundTranslation payload to the slice's receive and encodes the outcome",
+    async () => {
+      // fieldName is `${pluginName}_${specName}` — the same string
+      // Api_Naming.sliceMutationField produces at deploy time.
+      let event = inboundEvent(~fieldName="EpInboundTestPlugin_EpInboundTest", ~currency="EUR")
+      let outcome = await routeInbound(event)
+      let s = outcome->JSON.stringifyAny->Option.getOr("<unserializable>")
+      // A serializable outcome at all proves the payload no longer crashes on the
+      // SQS route; the rejection proves it ran the slice's translate.
+      expect(s->String.includes("CommandRejected"))->toBe(true)
+      expect(s->String.includes("Unsupported currency"))->toBe(true)
+    },
+  )
+})

package/tests/DcbInboundTranslationRoutingTest.res.mjs

@@ -0,0 +1,71 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let routeInbound = (async (event) => {
+    const { buildHandlersForConfig } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs"
+    );
+    const loadModule = async (specifier) => {
+      if (specifier === "ep-inbound-test://spec") return await import("./EpInboundTestSlice.res.mjs");
+      if (specifier === "ep-inbound-test://translation") return await import("./EpInboundTestSliceTranslation.res.mjs");
+      throw new Error("unknown test specifier: " + specifier);
+    };
+    const config = {
+      pluginName: "EpInboundTestPlugin",
+      dcbEventLogTableName: "ep-inbound-test-table",
+      stateChangeSliceModules: [],
+      queueUrl: "https://sqs.eu-west-1.amazonaws.com/000000000000/ep-inbound-test-queue",
+      inboundTranslationSliceModules: [
+        { spec: "ep-inbound-test://spec", translation: "ep-inbound-test://translation", auditTableName: null },
+      ],
+    };
+    const [,,,, inboundReceivers] = await buildHandlersForConfig(config, { loadModule });
+    // Mirror handler's Route 0 dispatch.
+    const receiver = (inboundReceivers || {})[event.fieldName];
+    if (receiver === undefined) throw new Error("no inbound receiver for " + event.fieldName);
+    return await receiver(event.arguments);
+  });
+
+function inboundEvent(fieldName, currency) {
+  let $$arguments = Object.fromEntries([
+    [
+      "sku",
+      "SKU-1"
+    ],
+    [
+      "currency",
+      currency
+    ]
+  ]);
+  return Object.fromEntries([
+    [
+      "__inboundTranslation",
+      true
+    ],
+    [
+      "fieldName",
+      fieldName
+    ],
+    [
+      "arguments",
+      $$arguments
+    ]
+  ]);
+}
+
+globalThis.describe("DcbCommandTopicEntryPoint Route 0 (InboundTranslation)", () => {
+  globalThis.test("routes an __inboundTranslation payload to the slice's receive and encodes the outcome", async () => {
+    let event = inboundEvent("EpInboundTestPlugin_EpInboundTest", "EUR");
+    let outcome = await routeInbound(event);
+    let s = Stdlib_Option.getOr(JSON.stringify(outcome), "<unserializable>");
+    globalThis.expect(s.includes("CommandRejected")).toBe(true);
+    globalThis.expect(s.includes("Unsupported currency")).toBe(true);
+  });
+});
+
+export {
+  routeInbound,
+  inboundEvent,
+}
+/* routeInbound Not a pure module */

package/tests/EpInboundTestSlice.res

@@ -0,0 +1,19 @@
+// Minimal InboundTranslationSlice spec fixture for the DCB entry-point Route 0
+// routing test (DcbInboundTranslationRoutingTest). Hand-written — not a plugin
+// component, so no folder-based ppx; only the fields
+// InboundTranslationSlice_Callback.Make reads at runtime are provided.
+
+let name = "EpInboundTest"
+let moduleUrl = "ep-inbound-test://spec"
+
+@schema
+type externalInput = {
+  sku: string,
+  currency: string,
+}
+
+@schema
+type command = AddThing({thingId: string})
+
+let targetName = "AddThing"
+let externalSystem: option<string> = Some("TestFeed")

package/tests/EpInboundTestSlice.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let externalInputSchema = S.schema(s => ({
+  sku: s.m(S.string),
+  currency: s.m(S.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddThing",
+  thingId: s.m(S.string)
+}));
+
+let name = "EpInboundTest";
+
+let moduleUrl = "ep-inbound-test://spec";
+
+let targetName = "AddThing";
+
+let externalSystem = "TestFeed";
+
+export {
+  name,
+  moduleUrl,
+  externalInputSchema,
+  commandSchema,
+  targetName,
+  externalSystem,
+}
+/* externalInputSchema Not a pure module */

package/tests/EpInboundTestSliceTranslation.res

@@ -0,0 +1,13 @@
+// Translation fixture paired with EpInboundTestSlice. Rejects non-USD input so the
+// routing test exercises the receive reject path — no command is published, so the
+// test needs neither SQS nor DynamoDB.
+
+module Spec = EpInboundTestSlice
+open Spec
+
+let moduleUrl = "ep-inbound-test://translation"
+
+let translate = (input: externalInput): result<array<(string, command)>, string> =>
+  input.currency !== "USD"
+    ? Error("Unsupported currency: " ++ input.currency)
+    : Ok([(input.sku, AddThing({thingId: input.sku}))])

package/tests/EpInboundTestSliceTranslation.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function translate(input) {
+  if (input.currency !== "USD") {
+    return {
+      TAG: "Error",
+      _0: "Unsupported currency: " + input.currency
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [[
+          input.sku,
+          {
+            TAG: "AddThing",
+            thingId: input.sku
+          }
+        ]]
+    };
+  }
+}
+
+let Spec;
+
+let moduleUrl = "ep-inbound-test://translation";
+
+export {
+  Spec,
+  moduleUrl,
+  translate,
+}
+/* No side effect */