@reventlessdev/reventless-aws 3.0.0-alpha.188 → 3.0.0-alpha.190

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 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.190 (2026-07-10)
+
+**Note:** Version bump only for package @reventlessdev/reventless-aws
+
+
+
+
+
+# 3.0.0-alpha.189 (2026-07-09)
+
+**Note:** Version bump only for package @reventlessdev/reventless-aws
+
+
+
+
+
 # 3.0.0-alpha.188 (2026-07-09)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.188",
+  "version": "3.0.0-alpha.190",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -10,15 +10,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.20",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.47",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.148",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.12",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.69",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.24"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.92",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.14",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.70",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.150"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/adapter/Runtime/AggregateEntryPoint.mjs

@@ -9,11 +9,13 @@ import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/Req
 import { Make as eventLogOperationsMake } from "@reventlessdev/reventless-core/src/components/EventLog/EventLog_Operations.res.mjs";
 import { Make as aggregateCallbackMake } from "@reventlessdev/reventless-core/src/components/Aggregate/Aggregate_Callback.res.mjs";
 import { Make as commandTopicCallbackMake } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Callback.res.mjs";
-import { makeGenerateCommand } from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+import { makeCommandGenerator } from "./CommandGeneratorEntryPoint_Ops.res.mjs";
 import { commandOutcomeToJson, runInlineAndCollect } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
-import { append, replay, replayStream, appendStream } from "@reventlessdev/reventless-aws/src/adapter/EventLog/EventLogStorage_DynamoDb_Runtime.res.mjs";
-import { opsFor as pgEventLogOpsFor } from "@reventlessdev/reventless-aws/src/adapter/EventLog/EventLogStorage_Postgres_Runtime.res.mjs";
 import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+// Typed cold-start core — EventLog storage-ops selection/wiring, compiler-checked
+// against the framework signatures (see the module header and
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
+import { makeStorageOps } from "./AggregateEntryPoint_Ops.res.mjs";
 import { DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb";
 import { unmarshall } from "@aws-sdk/util-dynamodb";
 
@@ -127,24 +129,10 @@ async function checkPluginStatus(event) {
 // (all aggregates share one Postgres table, unlike DynamoDB's table-per-aggregate).
 function buildAggregateParts(specModule, behaviorModule, eventLogTableName, queueUrl, pgConnection) {
   const patchedSpec = patchSpecId(specModule);
-  let rawStorageOps;
-  if (pgConnection) {
-    const pgOps = pgEventLogOpsFor(pgConnection, eventLogTableName);
-    rawStorageOps = {
-      append: pgOps.append,
-      replay: pgOps.replay,
-      replayStream: pgOps.replayStream,
-      appendStream: pgOps.appendStream,
-    };
-  } else {
-    const resolvedTable = { name: eventLogTableName };
-    rawStorageOps = {
-      append: append(resolvedTable),
-      replay: replay(resolvedTable),
-      replayStream: replayStream(resolvedTable),
-      appendStream: appendStream(resolvedTable),
-    };
-  }
+  // Typed core: backend-specific EventLog storage ops (Postgres when pgConnection
+  // is present, else DynamoDB). Returns the full 6-field EventLog_Adapter.operations
+  // — the shell previously dropped latestSnapshot/writeSnapshot.
+  const rawStorageOps = makeStorageOps(eventLogTableName, pgConnection);
   const eventLogOps = eventLogOperationsMake(patchedSpec)({
     Spec: patchedSpec,
     EventTopic: { Spec: patchedSpec },
@@ -178,13 +166,11 @@ function buildCommandGeneratorHandler(parts, dispatchMode) {
   const publishJsonsAndWait = dispatchMode === "async"
     ? undefined
     : (jsons) => runInlineAndCollect(jsons, handleJsonCommands);
-  // Positional args after ReScript compiles labeled params:
-  //   (publishJsons, publishJsonsAndWait, serviceName, commandSchema, componentKind, stripIdFromParams)
-  // The `undefined` for `stripIdFromParams` must be passed explicitly here —
-  // omitting it shifts everything left, sending the schema object through the
-  // serviceName slot (string-concat then throws "Cannot convert object to
-  // primitive value" once the log line tries to print "CommandGenerator(<schema>)").
-  const generateCommand = makeGenerateCommand(publishJsons, publishJsonsAndWait, patchedSpec.name, patchedSpec.commandSchema, "Aggregate", undefined);
+  // Typed core (CommandGeneratorEntryPoint_Ops.res) pins the arg order and the
+  // componentKind/stripIdFromParams positions against the framework signature.
+  // stripIdFromParams=true matches the framework default the old shell relied on
+  // by passing `undefined`.
+  const generateCommand = makeCommandGenerator(publishJsons, publishJsonsAndWait, patchedSpec.name, patchedSpec.commandSchema, "Aggregate", true);
   return (event, _context) => {
     // Add identity fallback: use payload.identity if present, otherwise construct from meta.user.
     const identity = (event.identity != null && typeof event.identity === 'object')
@@ -256,21 +242,32 @@ function extractCorrelationId(records) {
 // variant (Aggregate_Builder_Single_Async) sets DISPATCH_MODE=async.
 const DISPATCH_MODE = process.env["DISPATCH_MODE"] === "async" ? "async" : "sync";
 
-async function buildAllHandlers() {
-  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
-  const config = JSON.parse(configStr);
+// Exported for tests: build the [cmdTopicHandlers, cmdGenHandlers] pair from an
+// already-parsed `HANDLER_CONFIG` shape, with an injectable module loader. In
+// production, `buildAllHandlers` wraps this with the env config + the Lambda's
+// `/var/task/node_modules` dynamic import; the integration test injects a loader
+// returning pre-imported spec/behavior modules so it can drive the real
+// cmdGenHandler end-to-end against DynamoDB Local. (Mirrors the DCB entry point.)
+export async function buildHandlersForConfig(config, opts = {}) {
+  const loadModule = opts.loadModule ?? dynamicImport;
+  const dispatchMode = opts.dispatchMode ?? DISPATCH_MODE;
   const cmdTopicHandlers = {};
   const cmdGenHandlers = {};
-  await Promise.all(config.handlers.map(async h => {
-    const specModule = await dynamicImport(h.specModule);
-    const behaviorModule = await dynamicImport(h.behaviorModule);
+  await Promise.all((config.handlers || []).map(async h => {
+    const specModule = await loadModule(h.specModule);
+    const behaviorModule = await loadModule(h.behaviorModule);
     const parts = buildAggregateParts(specModule, behaviorModule, h.eventLogTable, h.queueUrl, h.pgConnection);
     cmdTopicHandlers[h.queueArn] = parts.sqsHandler;
-    cmdGenHandlers[specModule.name] = buildCommandGeneratorHandler(parts, DISPATCH_MODE);
+    cmdGenHandlers[specModule.name] = buildCommandGeneratorHandler(parts, dispatchMode);
   }));
   return [cmdTopicHandlers, cmdGenHandlers];
 }
 
+async function buildAllHandlers() {
+  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
+  return buildHandlersForConfig(JSON.parse(configStr));
+}
+
 const initPromise = buildAllHandlers();
 
 export async function handler(event, context) {

package/src/adapter/Runtime/AggregateEntryPoint_Ops.res

@@ -0,0 +1,48 @@
+// Typed cold-start core for the Aggregate Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
+// The `.mjs` shell owns the untyped seams — reading `HANDLER_CONFIG`, the dynamic
+// `import()` of user Spec/Behavior modules, and the functor wiring that consumes
+// those runtime-loaded modules (`EventLog_Operations.Make`, `Aggregate_Callback.Make`,
+// `CommandTopic_Callback.Make`). This module owns the one piece that is pure
+// typed framework wiring: selecting and building the EventLog storage operations.
+//
+// The `.mjs` previously built these with positional `append(resolvedTable)` /
+// `replay(...)` calls into the compiled runtime, and — crucially — assembled only
+// FOUR of the six `EventLog_Adapter.operations` fields, silently dropping
+// `latestSnapshot` / `writeSnapshot` on both the DynamoDB and Postgres paths. The
+// deploy-time adapter (EventLogStorage_DynamoDb.res) wires all six. Typing the
+// return as `EventLog_Adapter.operations` forces parity: the Lambda now matches
+// the deploy-time adapter exactly. Snapshot ops are a no-op when snapshotting is
+// disabled (the default) and correct when it is enabled — where the old shell
+// would have called `undefined`.
+
+// The `pgConnection` object as it arrives in `HANDLER_CONFIG` — the resolved
+// `PgConnection.connectionConfig` ({host,port,database,username,secretArn}).
+// Present iff this aggregate is Postgres-backed; `tableName` doubles as the
+// Postgres `event_log.log_name` (all aggregates share one Postgres table).
+type pgConnectionJson
+external asConnectionConfig: pgConnectionJson => PgConnection.connectionConfig = "%identity"
+
+let makeStorageOps = (
+  ~tableName: string,
+  ~pgConnection: option<pgConnectionJson>,
+): ReventlessCore.EventLog_Adapter.operations =>
+  switch pgConnection {
+  | Some(pg) => EventLogStorage_Postgres_Runtime.opsFor(pg->asConnectionConfig, ~logName=tableName)
+  | None =>
+    let table: Util_DynamoDb_Runtime.resolvedTable = {
+      id: "",
+      name: tableName,
+      arn: "",
+      hashKey: "id",
+    }
+    {
+      ReventlessCore.EventLog_Adapter.append: EventLogStorage_DynamoDb_Runtime.append(table),
+      replay: EventLogStorage_DynamoDb_Runtime.replay(table),
+      replayStream: EventLogStorage_DynamoDb_Runtime.replayStream(table),
+      appendStream: EventLogStorage_DynamoDb_Runtime.appendStream(table),
+      latestSnapshot: EventLogStorage_DynamoDb_Runtime.latestSnapshot(table),
+      writeSnapshot: EventLogStorage_DynamoDb_Runtime.writeSnapshot(table),
+    }
+  }

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

@@ -0,0 +1,30 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as EventLogStorage_DynamoDb_Runtime$ReventlessAws from "../EventLog/EventLogStorage_DynamoDb_Runtime.res.mjs";
+import * as EventLogStorage_Postgres_Runtime$ReventlessAws from "../EventLog/EventLogStorage_Postgres_Runtime.res.mjs";
+
+function makeStorageOps(tableName, pgConnection) {
+  if (pgConnection !== undefined) {
+    return EventLogStorage_Postgres_Runtime$ReventlessAws.opsFor(Primitive_option.valFromOption(pgConnection), tableName);
+  }
+  let table = {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id"
+  };
+  return {
+    append: EventLogStorage_DynamoDb_Runtime$ReventlessAws.append(table),
+    replay: EventLogStorage_DynamoDb_Runtime$ReventlessAws.replay(table),
+    replayStream: EventLogStorage_DynamoDb_Runtime$ReventlessAws.replayStream(table),
+    appendStream: EventLogStorage_DynamoDb_Runtime$ReventlessAws.appendStream(table),
+    latestSnapshot: EventLogStorage_DynamoDb_Runtime$ReventlessAws.latestSnapshot(table),
+    writeSnapshot: EventLogStorage_DynamoDb_Runtime$ReventlessAws.writeSnapshot(table)
+  };
+}
+
+export {
+  makeStorageOps,
+}
+/* EventLogStorage_DynamoDb_Runtime-ReventlessAws Not a pure module */

package/src/adapter/Runtime/CommandGeneratorEntryPoint_Ops.res

@@ -0,0 +1,33 @@
+// Typed cold-start core shared by the two command-path entry-point shells
+// (AggregateEntryPoint.mjs, DcbCommandTopicEntryPoint.mjs).
+//
+// Both shells build their AppSync CommandGenerator handler by calling the
+// compiled `CommandGenerator_Callback.makeGenerateCommand` positionally — a call
+// their comments flagged as fragile: omitting the trailing `stripIdFromParams`
+// shifts every argument left, sending the schema object through the `serviceName`
+// slot and throwing "Cannot convert object to primitive value" at the first log
+// line. This wrapper pins that correspondence: the arg order, the
+// `commandComponentKind` variant, and an explicit (non-defaulted)
+// `stripIdFromParams` are all compiler-checked against the framework signature,
+// so a signature change is a build error rather than a silent runtime shift.
+//
+// The shell still calls this positionally from JS, but the wrapper's OWN call
+// into the framework is typed — this file is the stable contract the shells pin
+// to, far less likely to drift than the framework internal.
+
+let makeCommandGenerator = (
+  ~publishJsons,
+  ~publishJsonsAndWait: option<_>,
+  ~serviceName,
+  ~commandSchema,
+  ~componentKind: ReventlessCore.CommandGenerator_Callback.commandComponentKind,
+  ~stripIdFromParams: bool,
+): ReventlessCore.CommandGenerator.commandGenerator =>
+  ReventlessCore.CommandGenerator_Callback.makeGenerateCommand(
+    ~publishJsons,
+    ~publishJsonsAndWait?,
+    ~serviceName,
+    ~commandSchema,
+    ~componentKind,
+    ~stripIdFromParams,
+  )

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

@@ -0,0 +1,12 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as CommandGenerator_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+function makeCommandGenerator(publishJsons, publishJsonsAndWait, serviceName, commandSchema, componentKind, stripIdFromParams) {
+  return CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, publishJsonsAndWait, serviceName, commandSchema, componentKind, stripIdFromParams);
+}
+
+export {
+  makeCommandGenerator,
+}
+/* CommandGenerator_Callback-ReventlessCore Not a pure module */

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -7,22 +7,17 @@ import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import { patchSpecId, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
-import { decodeCommand$p as decodeCommandPrime } from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
-import {
-  extractVariantNames,
-  deriveEffectiveScope,
-  derivePartitionTag,
-} from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
-import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import { Make as dcbEventLogOperationsMake } from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
-import { Make as stateChangeSliceCallbackMake } from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
-import { makeGenerateCommand } from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+import { makeCommandGenerator } from "./CommandGeneratorEntryPoint_Ops.res.mjs";
 import { commandOutcomeToJson, runInlineAndCollect } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 import { json as jsonSchema } from "sury/src/S.res.mjs";
-import { read, append, readStream } from "@reventlessdev/reventless-aws/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
-import { opsFor as pgDcbEventLogOpsFor } from "@reventlessdev/reventless-aws/src/adapter/DcbEventLog/DcbEventLogStorage_Postgres_Runtime.res.mjs";
 import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+// Typed cold-start core — scope/partitionTag derivation, storage-ops wiring, and
+// 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";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
@@ -78,10 +73,6 @@ function extractCorrelationId(records) {
   return undefined;
 }
 
-function getIdStringSchema() {
-  return IdString.schema;
-}
-
 // Exported for tests: build the [sqsHandler, cmdGenHandler] pair from an
 // already-parsed `HANDLER_CONFIG` shape, with an injectable module loader.
 // In production, `buildHandler` below wraps this with the env-config + the
@@ -91,94 +82,33 @@ function getIdStringSchema() {
 export async function buildHandlersForConfig(config, opts = {}) {
   const loadModule = opts.loadModule ?? dynamicImport;
 
-  // Load all spec/behavior pairs first. Both the decision-query scope
-  // (crossPartitionTagKeys / tagKeysByEventType) AND the storage `partitionTag`
-  // are derived from the produced event schemas, and the DynamoDB storage ops
-  // below must be built with them — so slices load before anything else.
+  // Untyped boundary: dynamically import + id-patch the user Spec/Behavior
+  // modules. Their types are unknowable here — this is the one seam the typed
+  // core (below) cannot own, so it stays in the shell.
   const loadedSlices = await Promise.all(
     config.stateChangeSliceModules.map(async ({ spec, behavior }) => {
       const specModule = await loadModule(spec);
       const behaviorModule = await loadModule(behavior);
-      const patchedSpec = patchSpecId(specModule);
-      return { patchedSpec, behaviorModule };
+      return { patchedSpec: patchSpecId(specModule), behaviorModule };
     })
   );
 
-  // Single source of truth with Dcb_Builder.res: prefer slice-graph inference
-  // (which classifies cross-partition `@ref` reference reads), falling back to
-  // annotations only on ambiguity. Re-deriving from annotations alone here
-  // silently dropped inferred cross-partition reads, so every reference-guarded
-  // command was rejected on the deployed path — see
-  // docs/analysis/dcb-runtime-scope-annotation-drift.md.
-  const { crossPartitionTagKeys, tagKeysByEventType } = deriveEffectiveScope(
-    loadedSlices.map(({ patchedSpec }) => ({
-      name: patchedSpec.name,
-      commandSchema: patchedSpec.commandSchema,
-      consumedEventSchema: patchedSpec.consumedEventSchema,
-      eventSchema: patchedSpec.eventSchema,
-    }))
+  // Typed core: scope (crossPartitionTagKeys / tagKeysByEventType) + storage
+  // `partitionTag` derivation and backend-specific storage-ops wiring, all
+  // compiler-checked against the framework signatures — the single source of
+  // truth shared with Dcb_Builder.res. The two prod incidents this prevents are
+  // documented in DcbCommandTopicEntryPoint_Ops.res. `pgConnection`, when present
+  // in HANDLER_CONFIG, selects the Postgres backend (dcbEventLogTableName doubles
+  // as `dcb_event.log_name`); absence keeps the DynamoDB path byte-identical.
+  const specs = loadedSlices.map(({ patchedSpec }) => patchedSpec);
+  const scope = deriveScope(specs);
+  const { crossPartitionTagKeys, tagKeysByEventType } = scope;
+  const rawStorageOps = makeStorageOps(
+    config.dcbEventLogTableName,
+    config.pgConnection,
+    scope,
   );
 
-  // Derive the storage partition tag the SAME way Dcb_Builder.res does at
-  // deploy time (over the produced event schemas). This MUST reach the DynamoDB
-  // `append` — without it `partitionTag` defaults to `None`, the composite-fence
-  // collapse (gated on `Composite`) never fires, and a `@compositePartitionTag`
-  // slice writes one fence PER MEMBER instead of one synthetic composite fence.
-  // A deploy-time fan-out sharing low-cardinality members (environment, plugin,
-  // …) then turns those member fences hot → TransactionConflict → retries
-  // exhausted. The deploy-time adapter (DcbEventLogStorage_DynamoDb.make) already
-  // threads it; the deployed Lambda dropped it. See
-  // docs/plans/dcb-composite-fence-residual-burst-contention.md.
-  // `derivePartitionTag` throws only on a misconfigured spec, which the deploy
-  // would already have rejected; guard defensively so a runtime edge case
-  // degrades to the (old) untagged behaviour rather than crashing cold start.
-  let partitionTag = undefined;
-  try {
-    partitionTag = derivePartitionTag(
-      loadedSlices.map(({ patchedSpec }) => [
-        patchedSpec.name,
-        patchedSpec.moduleUrl ?? patchedSpec.name,
-        patchedSpec.eventSchema,
-      ])
-    );
-  } catch (err) {
-    log.warn("could not derive partitionTag; falling back to untagged fences: " + (err && err.message), { comp: "DcbCommandTopicRuntime" });
-  }
-
-  // `pgConnection`, when present in HANDLER_CONFIG, selects the Postgres DCB
-  // runtime (dcbEventLogTableName doubles as the `dcb_event.log_name`); absence
-  // keeps the DynamoDB path byte-identical. NB: this swaps only the *storage*
-  // ops — event propagation (within-plugin projections + cross-plugin SNS) is
-  // stream-driven on AWS and is handled separately by the change-feed relay
-  // (see docs/plans/aws-postgres-change-feed-bridge.md), not by this Lambda.
-  const rawStorageOps = config.pgConnection
-    ? (() => {
-        // C2: `lockStrategy` ("AdvisoryLocks" | "RowLocks") is the polyvariant's
-        // string name; `opsFor` defaults to "AdvisoryLocks" when it's absent.
-        const pgOps = pgDcbEventLogOpsFor(
-          config.pgConnection,
-          config.dcbEventLogTableName,
-          config.pgConnection.lockStrategy,
-        );
-        return { read: pgOps.read, append: pgOps.append, readStream: pgOps.readStream };
-      })()
-    : (() => {
-        const resolvedTable = { name: config.dcbEventLogTableName };
-        // Positional args match the ReScript-compiled signatures:
-        //   read(table, crossPartitionTagKeys)
-        //   append(table, partitionTag, crossPartitionTagKeys)
-        //   readStream(table, crossPartitionTagKeys)
-        // Threading partitionTag activates the composite-fence collapse; threading
-        // crossPartitionTagKeys routes single-tag `@crossPartition` reads to the
-        // per-tag GSI and bumps their fences on every carrier — matching the
-        // deploy-time adapter's storage ops exactly.
-        return {
-          read: read(resolvedTable, crossPartitionTagKeys),
-          append: append(resolvedTable, partitionTag, crossPartitionTagKeys),
-          readStream: readStream(resolvedTable, crossPartitionTagKeys),
-        };
-      })();
-
   const handlersByType = {};
   const sharedDcbEventLogOps = dcbEventLogOperationsMake({
     name: config.pluginName,
@@ -191,35 +121,20 @@ export async function buildHandlersForConfig(config, opts = {}) {
   });
 
   loadedSlices.forEach(({ patchedSpec, behaviorModule }) => {
-    const sliceCallback = stateChangeSliceCallbackMake(patchedSpec)(behaviorModule);
-    const commandSchema = patchedSpec.commandSchema;
-    const typeNames = extractVariantNames(commandSchema);
-
-    const jsonHandler = stream => {
-      const decodedStream = Stream.flatMap(
-        Stream.mapEffect(stream, topicItem => Effect.sync(() => {
-          try {
-            const decoded = decodeCommandPrime(topicItem.command, getIdStringSchema(), commandSchema);
-            return { TAG: "Some", _0: { command: decoded, reference: topicItem.reference } };
-          } catch (_) {
-            return { TAG: "None", _0: 0 };
-          }
-        })),
-        opt => opt.TAG === "Some" ? Stream.make(opt._0) : Stream.empty
-      );
-      // Positional args match StateChangeSlice_Callback.res's compiled signature:
-      // (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, dcbEventLog, stream).
-      return sliceCallback.handleCommands(
-        tagKeysByEventType,
-        crossPartitionTagKeys,
-        sharedDcbEventLogOps,
-        decodedStream,
-      );
-    };
-
-    typeNames.forEach(typeName => {
+    // Typed core: builds the slice callback (functor), the JSON→command decode,
+    // and the handleCommands invocation — all compiler-checked (was the fragile
+    // positional call this file's line-146 comment warned about; see the
+    // 2026-06-21 arity-drift incident referenced in the _Ops header).
+    const jsonHandler = buildSliceHandler(
+      patchedSpec,
+      behaviorModule,
+      tagKeysByEventType,
+      crossPartitionTagKeys,
+      sharedDcbEventLogOps,
+    );
+    for (const typeName of commandTypeNames(patchedSpec)) {
       handlersByType[typeName] = jsonHandler;
-    });
+    }
   });
 
   // Composite handler used by Route 2 (SQS event source) AND inline dispatch
@@ -251,20 +166,19 @@ export async function buildHandlersForConfig(config, opts = {}) {
 
   // 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 → makeGenerateCommand falls back to publishJsons
+  // outcome. Async: undefined → makeCommandGenerator falls back to publishJsons
   // and returns Pending. The schema is permissive (S.json) because AppSync has
   // already validated input against the SDL — per-slice schemas reapply inside
-  // the slice handlers via decodeCommandPrime.
+  // the typed core's buildSliceHandler decode.
   const publishJsonsAndWait = DISPATCH_MODE === "async"
     ? undefined
     : (jsons) => runInlineAndCollect(jsons, compositeJsonCommandsHandler);
 
-  // Positional args match CommandGenerator_Callback.makeGenerateCommand's
-  // ReScript-compiled signature: (publishJsons, publishJsonsAndWait,
-  // serviceName, commandSchema, componentKind, stripIdFromParams).
-  // stripIdFromParams=false: DCB slices may declare a literal `id` field as part
-  // of the command schema (composite partition keys etc.) — don't strip it.
-  const generateCommand = makeGenerateCommand(
+  // Typed core (CommandGeneratorEntryPoint_Ops.res) pins the arg order against
+  // the framework signature. stripIdFromParams=false: DCB slices may declare a
+  // literal `id` field as part of the command schema (composite partition keys
+  // etc.) — don't strip it.
+  const generateCommand = makeCommandGenerator(
     publishJsons,
     publishJsonsAndWait,
     config.pluginName,